async def test_search_detailed_contracts(self): """Test function `search_detailed_contracts`.""" contract = sample_contracts.us_future() contract.lastTradeDateOrContractMonth = '' res = await self._bridge.search_detailed_contracts(contract=contract) self.assertGreater(len(res), 1) for item in res: print(item.contract)
async def test_resolve_head_timestamp(self): """Test function `resolve_head_timestamp`.""" head_timestamp = await self._client.resolve_head_timestamp( req_id=Const.RID_RESOLVE_HEAD_TIMESTAMP.value, contract=sample_contracts.us_future(), show=dt.EarliestDataPoint.BID) print(head_timestamp) self.assertIsNotNone(head_timestamp) self.assertIsInstance(head_timestamp, int)
async def test_resolve_contracts(self): """Test function `resolve_contracts`.""" contract: ib_contract.Contract = sample_contracts.us_future() contract.lastTradeDateOrContractMonth = '' res: List[ib_contract.ContractDetails] = await self._client\ .resolve_contracts(req_id=Const.RID_RESOLVE_CONTRACTS.value, contract=contract) self.assertTrue(res) self.assertGreater(len(res), 1)
async def test_req_historical_ticks_2(self): """Test function `req_historical_ticks`. * Reqest tick data for `TRADES`. """ async for result in self._bridge.req_historical_ticks( contract=sample_contracts.us_future(), start=self._start, end=self._end, tick_type=datatype.HistoricalTicks.TRADES, retry=0): self.assertTrue(result.ticks) self.assertIsInstance(result.ticks[0], wrapper.HistoricalTickLast)
async def test_req_historical_ticks_2(self): """Test function `req_historical_ticks`. * Request tick data for `MidPoint`. """ result = await self._client.req_historical_ticks( req_id=self._req_id, contract=sample_contracts.us_future(), start_date_time=self._start.replace(tzinfo=None), show=datatype.HistoricalTicks.TRADES) self.assertTrue(result) self.assertIsInstance(result, list) self.assertIsInstance(result[0], wrapper.HistoricalTickLast)
async def test_tick_by_tick_all_last_0(self): """Test overridden function `tickByTickAllLast` with tick type `Last`. """ self._client.reqTickByTickData( reqId=self._req_id, contract=sample_contracts.us_future(), tickType=datatype.LiveTicks.LAST.value, numberOfTicks=0, ignoreSize=True ) async for elem in self._queue.stream(): if elem is fq.Status.FINISHED: continue # Let the async task finish if not self._received: # Expect `HistoricalTickLast` to be sent to queue self.assertIsInstance(elem, wrapper.HistoricalTickLast) await self._stop_streaming(req_id=self._req_id)
async def test_stream_live_ticks_3(self): """Test function `stream_live_ticks`. * Request tick data for `LAST`. """ req_id = await self._bridge.stream_live_ticks( contract=sample_contracts.us_future(), listener=self._listener, tick_type=datatype.LiveTicks.LAST) while not self._listener.ticks: await asyncio.sleep(0.5) self.assertIsInstance(self._listener.ticks[0], wrapper.HistoricalTickLast) self._bridge._client.cancel_live_ticks_stream(req_id) await asyncio.sleep(0.5)
async def test_tick_by_tick_all_last(self): """Test overridden function `tickByTickAllLast`.""" f_queue = self._wrapper.get_request_queue( req_id=Const.RID_REQ_TICK_BY_TICK_DATA_ALL_LAST) self._client.reqTickByTickData( reqId=Const.RID_REQ_TICK_BY_TICK_DATA_ALL_LAST.value, contract=sample_contracts.us_future(), tickType='AllLast', numberOfTicks=0, ignoreSize=True) async for ele in f_queue.stream(): self.assertIsInstance(ele, (ib_wrapper.HistoricalTickLast, fq._Status)) self.assertIsNot(ele, fq._Status.ERROR) if ele is not fq._Status.FINISHED: self._client.cancelTickByTickData( reqId=Const.RID_REQ_TICK_BY_TICK_DATA_ALL_LAST.value) f_queue.put(element=fq._Status.FINISHED)