'This is a utility method that asserts expected
results for conversion of orders to transactions given a
trade history'

def transaction_sim(self, **params):

    trade_count = params['trade_count']
    trade_interval = params['trade_interval']
    order_count = params['order_count']
    order_amount = params['order_amount']
    order_interval = params['order_interval']
    expected_txn_count = params['expected_txn_count']
    expected_txn_volume = params['expected_txn_volume']
    alternate = params.get('alternate')
    complete_fill = params.get('complete_fill')
    asset1 = self.asset_finder.retrieve_asset(1)
    metadata = make_simple_equity_info([asset1.sid], self.start, self.end)
    with TempDirectory() as tempdir:
        with tmp_trading_env(equities=metadata, load=self.make_load_function()) as env:
            if (trade_interval < timedelta(days=1)):
                sim_params = factory.create_simulation_parameters(start=self.start, end=self.end, data_frequency='minute')
                minutes = self.trading_calendar.minutes_window(sim_params.first_open, (int(((trade_interval.total_seconds() / 60) * trade_count)) + 100))
                price_data = np.array(([10.1] * len(minutes)))
                assets = {asset1.sid: pd.DataFrame({'open': price_data, 'high': price_data, 'low': price_data, 'close': price_data, 'volume': np.array(([100] * len(minutes))), 'dt': minutes}).set_index('dt')}
                write_bcolz_minute_data(self.trading_calendar, self.trading_calendar.sessions_in_range(self.trading_calendar.minute_to_session_label(minutes[0]), self.trading_calendar.minute_to_session_label(minutes[(-1)])), tempdir.path, iteritems(assets))
                equity_minute_reader = BcolzMinuteBarReader(tempdir.path)
                data_portal = DataPortal(env.asset_finder, self.trading_calendar, first_trading_day=equity_minute_reader.first_trading_day, equity_minute_reader=equity_minute_reader)
            else:
                sim_params = factory.create_simulation_parameters(data_frequency='daily')
                days = sim_params.sessions
                assets = {1: pd.DataFrame({'open': ([10.1] * len(days)), 'high': ([10.1] * len(days)), 'low': ([10.1] * len(days)), 'close': ([10.1] * len(days)), 'volume': ([100] * len(days)), 'day': [day.value for day in days]}, index=days)}
                path = os.path.join(tempdir.path, 'testdata.bcolz')
                BcolzDailyBarWriter(path, self.trading_calendar, days[0], days[(-1)]).write(assets.items())
                equity_daily_reader = BcolzDailyBarReader(path)
                data_portal = DataPortal(env.asset_finder, self.trading_calendar, first_trading_day=equity_daily_reader.first_trading_day, equity_daily_reader=equity_daily_reader)
            if (('default_slippage' not in params) or (not params['default_slippage'])):
                slippage_func = FixedSlippage()
            else:
                slippage_func = None
            blotter = Blotter(sim_params.data_frequency, slippage_func)
            start_date = sim_params.first_open
            if alternate:
                alternator = (-1)
            else:
                alternator = 1
            tracker = PerformanceTracker(sim_params, self.trading_calendar, self.env)
            if (sim_params.data_frequency == 'minute'):
                ticks = minutes
            else:
                ticks = days
            transactions = []
            order_list = []
            order_date = start_date
            for tick in ticks:
                blotter.current_dt = tick
                if ((tick >= order_date) and (len(order_list) < order_count)):
                    direction = (alternator ** len(order_list))
                    order_id = blotter.order(asset1, (order_amount * direction), MarketOrder())
                    order_list.append(blotter.orders[order_id])
                    order_date = (order_date + order_interval)
                    if (order_date.hour >= 21):
                        if (order_date.minute >= 0):
                            order_date = (order_date + timedelta(days=1))
                            order_date = order_date.replace(hour=14, minute=30)
                else:
                    bar_data = BarData(data_portal=data_portal, simulation_dt_func=(lambda : tick), data_frequency=sim_params.data_frequency, trading_calendar=self.trading_calendar, restrictions=NoRestrictions())
                    (txns, _, closed_orders) = blotter.get_transactions(bar_data)
                    for txn in txns:
                        tracker.process_transaction(txn)
                        transactions.append(txn)
                    blotter.prune_orders(closed_orders)
            for i in range(order_count):
                order = order_list[i]
                self.assertEqual(order.asset, asset1)
                self.assertEqual(order.amount, (order_amount * (alternator ** i)))
            if complete_fill:
                self.assertEqual(len(transactions), len(order_list))
            total_volume = 0
            for i in range(len(transactions)):
                txn = transactions[i]
                total_volume += txn.amount
                if complete_fill:
                    order = order_list[i]
                    self.assertEqual(order.amount, txn.amount)
            self.assertEqual(total_volume, expected_txn_volume)
            self.assertEqual(len(transactions), expected_txn_count)
            cumulative_pos = tracker.position_tracker.positions[asset1]
            if (total_volume == 0):
                self.assertIsNone(cumulative_pos)
            else:
                self.assertEqual(total_volume, cumulative_pos.amount)
            oo = blotter.open_orders
            self.assertNotIn(asset1, oo, 'Entry    is    removed    when    no    open    orders')
