docstr: This is a utility method that asserts expected
  results for conversion of orders to transactions given a
  trade history
docstr_tok: ["This","is","a","utility","method","that","asserts","expected","results","for","conversion","of","orders","to","transactions","given","a","trade","history"]
code: def transaction_sim(self, **params):
      """This is a utility method that asserts expected
      results for conversion of orders to transactions given a
      trade history
      """
      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"]
  
      # optional parameters
      # ---------------------
      # if present, alternate between long and short sales
      alternate = params.get("alternate")
  
      # if present, expect transaction amounts to match orders exactly.
      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, 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,
                  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,
                  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
          )
  
          # replicate what tradesim does by going through every minute or day
          # of the simulation and processing open orders each time
          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:
                  # place an order
                  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
                  # move after market orders to just after market next
                  # market open.
                  if order_date.hour >= 21:
                      if order_date.minute >= 00:
                          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)
  
          # the open orders should not contain the asset.
          oo = blotter.open_orders
          self.assertNotIn(
              asset1, oo, "Entry is removed when no open orders"
          )
  
imports: from datetime import datetime, timedelta
  import os
  from nose.tools import timed
  import numpy
  import pandas
  import pytz
  from six import iteritems
  from six.moves import range
  from testfixtures import TempDirectory
  from catalyst.assets.synthetic import make_simple_equity_info
  from catalyst.finance.blotter import Blotter
  from catalyst.finance.execution import MarketOrder, LimitOrder
  from catalyst.finance.performance import PerformanceTracker
  from catalyst.finance.trading import SimulationParameters
  from catalyst.data.us_equity_pricing import BcolzDailyBarReader
  from catalyst.data.minute_bars import BcolzMinuteBarReader
  from catalyst.data.data_portal import DataPortal
  from catalyst.data.us_equity_pricing import BcolzDailyBarWriter
  from catalyst.finance.slippage import FixedSlippage
  from catalyst.finance.asset_restrictions import NoRestrictions
  from catalyst.protocol import BarData
  from catalyst.testing import tmp_trading_env, write_bcolz_minute_data
  from catalyst.testing.fixtures import WithLogger, WithTradingEnvironment, CatalystTestCase
  import catalyst.utils.factory
label_desc: Use image node_id 5 for calling the FinanceTestCase obj's underlying member method code with example usage: obj.transaction_sim() without return types