26011892968

Committed 18 May 2026 03:28AM UTC coverage: 92.119%. Remained the same

Build # 26011892968

Build Type

push

github

Committed by

web-flow

Commit Message

errors: EOF / no-response sites → Error::UnexpectedEndOfStream (#585)

PR-2 of plans/error-variants-audit.md. Flip 8 no-response sites from
Error::Simple to Error::UnexpectedEndOfStream so callers can pattern-match
on the typed variant:

- accounts/{sync,async}/mod.rs server_time + server_time_millis (4)
- orders/{sync,async}/mod.rs next_valid_id no-response (2)
- orders/builder/{sync,async}_impl.rs what-if analyze() empty stream (2)

Downstream tests and parallel mocks updated accordingly. Renames the
test-table sentinel string "No response from server" → "unexpected
end of stream" so the table entry reflects the actual error variant.

Verified default + sync + all-features clippy and tests.

Coverage Stats

4 of 9 new or added lines in 7 files covered. (44.44%)

18982 of 20606 relevant lines covered (92.12%)

27.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/orders/builder/sync_impl.rs

use super::{BracketOrderBuilder, BracketOrderIds, OrderBuilder, OrderId};
use crate::client::sync::Client;
use crate::contracts::Contract;
use crate::errors::Error;
#[cfg(test)]
mod tests;

impl<'a> OrderBuilder<'a, Client> {
    /// Submit the order synchronously
    /// Returns the order ID assigned to the submitted order
    pub fn submit(self) -> Result<OrderId, Error> {
        let client = self.client;
        let contract = self.contract;
        let order_id = client.next_order_id();
        let order = self.build()?;
        client.submit_order(order_id, contract, &order)?;
        Ok(OrderId::new(order_id))
    }

    /// Build the order and return it without submitting
    /// Useful for batch operations or custom submission logic
    pub fn build_order(self) -> Result<crate::orders::Order, Error> {
        self.build().map_err(Into::into)
    }

    /// Analyze order for margin/commission (what-if)
    pub fn analyze(mut self) -> Result<crate::orders::OrderState, Error> {
        self.what_if = true;
        let client = self.client;
        let contract = self.contract;
        let order_id = client.next_order_id();
        let order = self.build()?;

        // Submit what-if order and get the response
        let responses = client.place_order(order_id, contract, &order)?;

        // Look for the order state in the responses
        for response in responses.iter_data() {
            if let Ok(crate::orders::PlaceOrder::OpenOrder(order_data)) = response {
                if order_data.order_id == order_id {
                    return Ok(order_data.order_state);
                }
            }
        }

        Err(Error::UnexpectedEndOfStream)
    }
}

impl<'a> BracketOrderBuilder<'a, Client> {
    /// Submit bracket orders synchronously
    /// Returns BracketOrderIds containing all three order IDs
    pub fn submit_all(self) -> Result<BracketOrderIds, Error> {
        let client = self.parent_builder.client;
        let contract = self.parent_builder.contract;
        let orders = self.build()?;

        // Reserve all order IDs upfront to prevent collisions
        let parent_id = client.next_order_id();
        let tp_id = client.next_order_id();
        let sl_id = client.next_order_id();
        let reserved_ids = [parent_id, tp_id, sl_id];

        for (i, mut order) in orders.into_iter().enumerate() {
            let order_id = reserved_ids[i];
            order.order_id = order_id;

            // Update parent_id for child orders
            if i > 0 {
                order.parent_id = parent_id;
            }

            // Only transmit the last order
            if i == 2 {
                order.transmit = true;
            }

            client.submit_order(order_id, contract, &order)?;
        }

        Ok(BracketOrderIds::new(parent_id, tp_id, sl_id))
    }
}

/// Extension trait for submitting multiple OCA orders
impl Client {
    /// Submit multiple OCA (One-Cancels-All) orders
    ///
    /// When one order in the group is filled, all others are automatically cancelled.
    ///
    /// # Example
    /// ```no_run
    /// use ibapi::client::blocking::Client;
    /// use ibapi::contracts::Contract;
    ///
    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");
    ///
    /// let contract1 = Contract::stock("AAPL").build();
    /// let contract2 = Contract::stock("MSFT").build();
    ///
    /// let order1 = client.order(&contract1)
    ///     .buy(100)
    ///     .limit(50.0)
    ///     .oca_group("MyOCA", 1)
    ///     .build_order().expect("order build failed");
    ///     
    /// let order2 = client.order(&contract2)
    ///     .buy(100)
    ///     .limit(45.0)
    ///     .oca_group("MyOCA", 1)
    ///     .build_order().expect("order build failed");
    ///
    /// let order_ids = client.submit_oca_orders(
    ///     vec![(contract1, order1), (contract2, order2)]
    /// ).expect("OCA submission failed");
    /// ```
    pub fn submit_oca_orders(&self, orders: Vec<(Contract, crate::orders::Order)>) -> Result<Vec<OrderId>, Error> {
        let mut order_ids = Vec::new();

        for (contract, mut order) in orders.into_iter() {
            let order_id = self.next_order_id();
            order.order_id = order_id;
            order_ids.push(OrderId::new(order_id));
            self.submit_order(order_id, &contract, &order)?;
        }

        Ok(order_ids)
    }
}

1	use super::{BracketOrderBuilder, BracketOrderIds, OrderBuilder, OrderId};
2	use crate::client::sync::Client;
3	use crate::contracts::Contract;
4	use crate::errors::Error;
5	#[cfg(test)]
6	mod tests;
7
8	impl<'a> OrderBuilder<'a, Client> {
9	/// Submit the order synchronously
10	/// Returns the order ID assigned to the submitted order
11	pub fn submit(self) -> Result<OrderId, Error> {	×
12	let client = self.client;	×
13	let contract = self.contract;	×
14	let order_id = client.next_order_id();	×
15	let order = self.build()?;	×
16	client.submit_order(order_id, contract, &order)?;	×
17	Ok(OrderId::new(order_id))	×
18	}	×
19
20	/// Build the order and return it without submitting
21	/// Useful for batch operations or custom submission logic
22	pub fn build_order(self) -> Result<crate::orders::Order, Error> {	×
23	self.build().map_err(Into::into)	×
24	}	×
25
26	/// Analyze order for margin/commission (what-if)
27	pub fn analyze(mut self) -> Result<crate::orders::OrderState, Error> {	×
28	self.what_if = true;	×
29	let client = self.client;	×
30	let contract = self.contract;	×
31	let order_id = client.next_order_id();	×
32	let order = self.build()?;	×
33
34	// Submit what-if order and get the response
35	let responses = client.place_order(order_id, contract, &order)?;	×
36
37	// Look for the order state in the responses
38	for response in responses.iter_data() {	×
39	if let Ok(crate::orders::PlaceOrder::OpenOrder(order_data)) = response {	×
40	if order_data.order_id == order_id {	×
41	return Ok(order_data.order_state);	×
42	}	×
43	}	×
44	}
45
NEW 46	Err(Error::UnexpectedEndOfStream)	×
47	}	×
48	}
49
50	impl<'a> BracketOrderBuilder<'a, Client> {
51	/// Submit bracket orders synchronously
52	/// Returns BracketOrderIds containing all three order IDs
53	pub fn submit_all(self) -> Result<BracketOrderIds, Error> {	×
54	let client = self.parent_builder.client;	×
55	let contract = self.parent_builder.contract;	×
56	let orders = self.build()?;	×
57
58	// Reserve all order IDs upfront to prevent collisions
59	let parent_id = client.next_order_id();	×
60	let tp_id = client.next_order_id();	×
61	let sl_id = client.next_order_id();	×
62	let reserved_ids = [parent_id, tp_id, sl_id];	×
63
64	for (i, mut order) in orders.into_iter().enumerate() {	×
65	let order_id = reserved_ids[i];	×
66	order.order_id = order_id;	×
67
68	// Update parent_id for child orders
69	if i > 0 {	×
70	order.parent_id = parent_id;	×
71	}	×
72
73	// Only transmit the last order
74	if i == 2 {	×
75	order.transmit = true;	×
76	}	×
77
78	client.submit_order(order_id, contract, &order)?;	×
79	}
80
81	Ok(BracketOrderIds::new(parent_id, tp_id, sl_id))	×
82	}	×
83	}
84
85	/// Extension trait for submitting multiple OCA orders
86	impl Client {
87	/// Submit multiple OCA (One-Cancels-All) orders
88	///
89	/// When one order in the group is filled, all others are automatically cancelled.
90	///
91	/// # Example
92	/// ```no_run
93	/// use ibapi::client::blocking::Client;
94	/// use ibapi::contracts::Contract;
95	///
96	/// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");
97	///
98	/// let contract1 = Contract::stock("AAPL").build();
99	/// let contract2 = Contract::stock("MSFT").build();
100	///
101	/// let order1 = client.order(&contract1)
102	/// .buy(100)
103	/// .limit(50.0)
104	/// .oca_group("MyOCA", 1)
105	/// .build_order().expect("order build failed");
106	///
107	/// let order2 = client.order(&contract2)
108	/// .buy(100)
109	/// .limit(45.0)
110	/// .oca_group("MyOCA", 1)
111	/// .build_order().expect("order build failed");
112	///
113	/// let order_ids = client.submit_oca_orders(
114	/// vec![(contract1, order1), (contract2, order2)]
115	/// ).expect("OCA submission failed");
116	/// ```
117	pub fn submit_oca_orders(&self, orders: Vec<(Contract, crate::orders::Order)>) -> Result<Vec<OrderId>, Error> {	×
118	let mut order_ids = Vec::new();	×
119
120	for (contract, mut order) in orders.into_iter() {	×
121	let order_id = self.next_order_id();	×
122	order.order_id = order_id;	×
123	order_ids.push(OrderId::new(order_id));	×
124	self.submit_order(order_id, &contract, &order)?;	×
125	}
126
127	Ok(order_ids)	×
128	}	×
129	}

wboayue / rust-ibapi / 26011892968

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous