ib-ruby 0.5.19 → 0.5.21

data/spec/ib-ruby/models/order_spec.rb

@@ -47,40 +47,73 @@ describe IB::Models::Order do
 
     it 'allows setting attributes' do
       x = IB::Models::Order.new
-      expect {
-        x.outside_rth = true
-        x.open_close = 'C'
-        x.origin = IB::Models::Order::Origin_Firm
-        x.transmit = false
-        x.designated_location = "WHATEVER"
-        x.exempt_code = 123
-        x.delta_neutral_order_type = "HACK"
-        x.what_if = true
-        x.not_held = true
-      }.to_not raise_error
-
-      x.outside_rth.should == true
-      x.open_close.should == 'C'
-      x.origin.should == IB::Models::Order::Origin_Firm
-      x.transmit.should == false
-      x.designated_location.should == "WHATEVER"
-      x.exempt_code.should == 123
-      x.delta_neutral_order_type.should == "HACK"
-      x.what_if.should == true
-      x.not_held.should == true
+      properties.each do |name, value|
+        subject.send("#{name}=", value)
+        subject.send(name).should == value
+      end
     end
   end #instantiation
 
   context 'equality' do
     subject { IB::Models::Order.new properties }
 
-    it 'be self-equal ' do
+    it 'is  self-equal ' do
       should == subject
     end
 
-    it 'be equal to Order with the same properties' do
+    it 'is equal to Order with the same properties' do
       should == IB::Models::Order.new(properties)
     end
+
+    it 'is not equal for Orders with different limit price' do
+      order1 = IB::Models::Order.new :total_quantity => 100,
+                                     :limit_price => 1,
+                                     :action => 'BUY'
+
+      order2 = IB::Models::Order.new :total_quantity => 100,
+                                     :limit_price => 2,
+                                     :action => 'BUY'
+      order1.should_not == order2
+      order2.should_not == order1
+    end
+
+    it 'is not equal for Orders with different total_quantity' do
+      order1 = IB::Models::Order.new :total_quantity => 20000,
+                                     :limit_price => 1,
+                                     :action => 'BUY'
+
+      order2 = IB::Models::Order.new :total_quantity => 100,
+                                     :action => 'BUY',
+                                     :limit_price => 1
+      order1.should_not == order2
+      order2.should_not == order1
+    end
+
+    it 'is not equal for Orders with different action/side' do
+      order1 = IB::Models::Order.new :total_quantity => 100,
+                                     :limit_price => 1,
+                                     :action => 'SELL'
+
+      order2 = IB::Models::Order.new :total_quantity => 100,
+                                     :action => 'BUY',
+                                     :limit_price => 1
+      order1.should_not == order2
+      order2.should_not == order1
+    end
+
+    it 'is not equal for Orders with different order_type' do
+      order1 = IB::Models::Order.new :total_quantity => 100,
+                                     :limit_price => 1,
+                                     :action => 'BUY',
+                                     :order_type => 'LMT'
+
+      order2 = IB::Models::Order.new :total_quantity => 100,
+                                     :action => 'BUY',
+                                     :limit_price => 1,
+                                     :order_type => 'MKT'
+      order1.should_not == order2
+      order2.should_not == order1
+    end
   end
 
 end # describe IB::Models::Order

data/spec/integration/account_info_spec.rb

@@ -0,0 +1,85 @@
+require 'integration_helper'
+
+shared_examples_for 'Valid account data request' do
+
+  after(:all) do
+    @ib.send_message :RequestAccountData, :subscribe => false
+    clean_connection
+  end
+
+  context "received :AccountUpdateTime message" do
+    subject { @received[:AccountUpdateTime].first }
+
+    it { should be_an IB::Messages::Incoming::AccountUpdateTime }
+    its(:data) { should be_a Hash }
+    its(:time_stamp) { should =~ /\d\d:\d\d/ }
+    its(:to_human) { should =~ /AccountUpdateTime/ }
+  end
+
+  context "received :AccountValue message" do
+    subject { @received[:AccountValue].first }
+
+    #ps
+    it { should be_an IB::Messages::Incoming::AccountValue }
+    its(:data) { should be_a Hash }
+    its(:account_name) { should =~ /\w\d/ }
+    its(:key) { should be_a String }
+    its(:value) { should be_a String }
+    its(:currency) { should be_a String }
+    its(:to_human) { should =~ /AccountValue/ }
+  end
+
+  context "received :PortfolioValue message" do
+    subject { @received[:PortfolioValue].first }
+
+    it { should be_an IB::Messages::Incoming::PortfolioValue }
+    its(:contract) { should be_a IB::Models::Contract }
+    its(:data) { should be_a Hash }
+    its(:position) { should be_a Integer }
+    its(:market_price) { should be_a Float }
+    its(:market_value) { should be_a Float }
+    its(:average_cost) { should be_a Float }
+    its(:unrealized_pnl) { should be_a Float }
+    its(:realized_pnl) { should be_a Float }
+    its(:account_name) { should =~ /\w\d/ }
+    its(:to_human) { should =~ /PortfolioValue/ }
+  end
+
+  context "received :AccountDownloadEnd message" do
+    subject { @received[:AccountDownloadEnd].first }
+
+    it { should be_an IB::Messages::Incoming::AccountDownloadEnd }
+    its(:data) { should be_a Hash }
+    its(:account_name) { should =~ /\w\d/ }
+    its(:to_human) { should =~ /AccountDownloadEnd/ }
+  end
+end
+
+describe "Request Account Data", :connected => true, :integration => true do
+
+  before(:all) do
+    verify_account
+    connect_and_receive(:Alert, :AccountValue, :AccountDownloadEnd,
+                        :PortfolioValue, :AccountUpdateTime)
+  end
+
+  after(:all) { close_connection }
+
+  context "with subscribe option set" do
+    before(:all) do
+      @ib.send_message :RequestAccountData, :subscribe => true
+      wait_for(5) { received? :AccountDownloadEnd }
+    end
+
+    it_behaves_like 'Valid account data request'
+  end
+
+  context "without subscribe option" do
+    before(:all) do
+      @ib.send_message :RequestAccountData
+      wait_for(5) { received? :AccountDownloadEnd }
+    end
+
+    it_behaves_like 'Valid account data request'
+  end
+end # Request Account Data

data/spec/integration/contract_info_spec.rb

@@ -0,0 +1,209 @@
+require 'integration_helper'
+
+describe "Request Contract Info", :connected => true, :integration => true do
+
+  before(:all) do
+    verify_account
+    connect_and_receive :NextValidID, :Alert, :ContractData, :ContractDataEnd
+    wait_for { received? :NextValidID }
+  end
+
+  after(:all) { close_connection }
+
+  context "Request Stock data" do
+
+    before(:all) do
+      @contract = IB::Models::Contract.new :symbol => 'AAPL',
+                                           :sec_type => IB::SECURITY_TYPES[:stock]
+      @ib.send_message :RequestContractData,
+                       :id => 111,
+                       :contract => @contract
+
+      wait_for(3) { received? :ContractDataEnd }
+    end
+
+    after(:all) { clean_connection } # Clear logs and message collector
+
+    it { @received[:ContractData].should have_exactly(2).contract_data }
+    it { @received[:ContractDataEnd].should have_exactly(1).contract_data_end }
+
+    it 'receives Contract Data for requested contract' do
+      msg = @received[:ContractData].first
+      msg.request_id.should == 111
+      msg.contract.should == @contract
+    end
+
+    it 'receives Contract Data with extended fields' do
+      # Returns 2 contracts, one for NASDAQ and one for IBIS - internal crossing?
+
+      @received[:ContractData].each do |msg|
+        contract = msg.contract
+        contract.symbol.should == 'AAPL'
+
+        contract.local_symbol.should =~ /AAPL|APC/
+        contract.market_name.should =~ /NMS|USSTARS/
+        contract.trading_class.should =~ /NMS|USSTARS/
+        contract.long_name.should == 'APPLE INC'
+        contract.industry.should == 'Technology'
+        contract.category.should == 'Computers'
+        contract.subcategory.should == 'Computers'
+        contract.exchange.should == 'SMART'
+        contract.con_id.should be_an Integer
+        contract.trading_hours.should =~ /\d{8}:\d{4}-\d{4}/
+        contract.liquid_hours.should =~ /\d{8}:\d{4}-\d{4}/
+        contract.valid_exchanges.should =~ /ISLAND|IBIS/
+        contract.order_types.should be_a String
+        contract.price_magnifier.should == 1
+        contract.min_tick.should be <= 0.01
+
+        contract.expiry.should be_nil
+      end
+    end
+  end # Stock
+
+  context "Request Option contract data" do
+
+    before(:all) do
+      @contract = IB::Models::Contract::Option.new :symbol => "AAPL",
+                                                   :expiry => "201301",
+                                                   :right => "CALL",
+                                                   :strike => 500
+      @ib.send_message :RequestContractData,
+                       :id => 123,
+                       :contract => @contract
+
+      wait_for(3) { received? :ContractDataEnd }
+    end
+
+    after(:all) { clean_connection } # Clear logs and message collector
+
+    subject { @received[:ContractData].first }
+
+    it { @received[:ContractData].should have_exactly(1).contract_data }
+    it { @received[:ContractDataEnd].should have_exactly(1).contract_data_end }
+
+    it 'receives Contract Data for requested contract' do
+      subject.request_id.should == 123
+      subject.contract.should == @contract
+    end
+
+    it 'receives Contract Data with extended fields' do
+      contract = subject.contract
+      contract.symbol.should == 'AAPL'
+
+      contract.local_symbol.should == 'AAPL  130119C00500000'
+      contract.market_name.should == 'AAPL'
+      contract.trading_class.should == 'AAPL'
+      contract.long_name.should == 'APPLE INC'
+      contract.industry.should == 'Technology'
+      contract.category.should == 'Computers'
+      contract.subcategory.should == 'Computers'
+      contract.expiry.should == '20130118'
+      contract.exchange.should == 'SMART'
+      contract.con_id.should be_an Integer
+      contract.trading_hours.should =~ /\d{8}:\d{4}-\d{4}/
+      contract.liquid_hours.should =~ /\d{8}:\d{4}-\d{4}/
+      contract.valid_exchanges.should =~ /CBOE/
+      contract.order_types.should be_a String
+      contract.price_magnifier.should == 1
+      contract.min_tick.should == 0.01
+    end
+  end # Request Option data
+
+  context "Request Forex contract data" do
+
+    before(:all) do
+      @contract = IB::Models::Contract.new :symbol => 'EUR', # EURUSD pair
+                                           :currency => "USD",
+                                           :exchange => "IDEALPRO",
+                                           :sec_type => IB::SECURITY_TYPES[:forex]
+
+      @ib.send_message :RequestContractData,
+                       :id => 135,
+                       :contract => @contract
+
+      wait_for(3) { received? :ContractDataEnd }
+    end
+
+    after(:all) { clean_connection } # Clear logs and message collector
+
+    subject { @received[:ContractData].first }
+
+    it { @received[:ContractData].should have_exactly(1).contract_data }
+    it { @received[:ContractDataEnd].should have_exactly(1).contract_data_end }
+
+    it 'receives Contract Data for requested contract' do
+      subject.request_id.should == 135
+      subject.contract.should == @contract
+    end
+
+    it 'receives Contract Data with extended fields' do
+      contract = subject.contract
+      contract.symbol.should == 'EUR'
+
+      contract.local_symbol.should == 'EUR.USD'
+      contract.market_name.should == 'EUR.USD'
+      contract.trading_class.should == 'EUR.USD'
+      contract.long_name.should == 'European Monetary Union euro'
+      contract.industry.should == ''
+      contract.category.should == ''
+      contract.subcategory.should == ''
+      contract.expiry.should be_nil
+      contract.exchange.should == 'IDEALPRO'
+      contract.con_id.should be_an Integer
+      contract.trading_hours.should =~ /\d{8}:\d{4}-\d{4}/
+      contract.liquid_hours.should =~ /\d{8}:\d{4}-\d{4}/
+      contract.valid_exchanges.should =~ /IDEALPRO/
+      contract.order_types.should be_a String
+      contract.price_magnifier.should == 1
+      contract.min_tick.should be <= 0.0001
+    end
+  end # Request Forex data
+
+  context "Request Futures contract data" do
+
+    before(:all) do
+      @contract = IB::Symbols::Futures[:ym] # Mini Dow Jones Industrial
+
+      @ib.send_message :RequestContractData,
+                       :id => 147,
+                       :contract => @contract
+
+      wait_for(3) { received? :ContractDataEnd }
+    end
+
+    after(:all) { clean_connection } # Clear logs and message collector
+
+    subject { @received[:ContractData].first }
+
+    it { @received[:ContractData].should have_exactly(1).contract_data }
+    it { @received[:ContractDataEnd].should have_exactly(1).contract_data_end }
+
+    it 'receives Contract Data for requested contract' do
+      subject.request_id.should == 147
+      subject.contract.should == @contract
+    end
+
+    it 'receives Contract Data with extended fields' do
+      contract = subject.contract
+      contract.symbol.should == 'YM'
+
+      contract.local_symbol.should =~ /YM/
+      contract.market_name.should == 'YM'
+      contract.trading_class.should == 'YM'
+      contract.long_name.should == 'Mini Sized Dow Jones Industrial Average $5'
+      contract.industry.should == ''
+      contract.category.should == ''
+      contract.subcategory.should == ''
+      contract.expiry.should =~ Regexp.new(IB::Symbols.next_expiry)
+      contract.exchange.should == 'ECBOT'
+      contract.con_id.should be_an Integer
+      contract.trading_hours.should =~ /\d{8}:\d{4}-\d{4}/
+      contract.liquid_hours.should =~ /\d{8}:\d{4}-\d{4}/
+      contract.valid_exchanges.should =~ /ECBOT/
+      contract.order_types.should be_a String
+      contract.price_magnifier.should == 1
+      contract.min_tick.should == 1
+    end
+  end # Request Forex data
+end # Contract Data

data/spec/integration/depth_data_spec.rb

@@ -0,0 +1,46 @@
+require 'integration_helper'
+
+describe 'Request Depth of Market Data', :connected => true,
+         :integration => true, :if => :forex_trading_hours do
+
+  before(:all) do
+    verify_account
+    connect_and_receive :Alert, :MarketDepth
+
+    @ib.send_message :RequestMarketDepth, :id => 456, :num_rows => 3,
+                     :contract => IB::Symbols::Forex[:eurusd]
+
+    wait_for(3) { received? :MarketDepth, 8 }
+  end
+
+  after(:all) do
+    @ib.send_message :CancelMarketDepth, :id => 456
+    close_connection
+  end
+
+  subject { @received[:MarketDepth].last }
+
+  it { @received[:MarketDepth].should have_at_least(8).depth_data }
+
+  it { should be_an IB::Messages::Incoming::MarketDepth }
+  its(:request_id) { should == 456 }
+  its(:price) { should be_a Float }
+  its(:size) { should be_an Integer }
+  its(:to_human) { should =~ /MarketDepth/ }
+
+  it 'has position field reflecting the row Id of this market depth entry' do
+    subject.position.should be_an Integer
+    subject.position.should be >= 1
+    subject.position.should be <= 3
+  end
+
+  it 'has operation field reflecting how this entry is applied' do
+    subject.operation.should be_a Symbol
+    subject.operation.to_s.should =~ /insert|update|delete/
+  end
+
+  it 'has side field reflecting side of the book: 0 = ask, 1 = bid' do
+    subject.side.should be_a Symbol
+    subject.side.to_s.should =~ /ask|bid/
+  end
+end # Request Market Depth

data/spec/integration/historic_data_spec.rb

@@ -0,0 +1,82 @@
+require 'integration_helper'
+
+describe 'Request Historic Data', :connected => true, :integration => true do
+
+  before(:all) do
+    verify_account
+    connect_and_receive :Alert, :HistoricalData
+  end
+
+  after(:all) do
+    @ib.send_message :CancelHistoricalData, :id => 456
+    close_connection
+  end
+
+  context 'Wrong Requests' do
+    it 'raises if incorrect bar size' do
+      expect do
+        @ib.send_message :RequestHistoricalData, :id => 456,
+                         :contract => IB::Symbols::Stocks[:wfc],
+                         :end_date_time => Time.now.to_ib,
+                         :duration => '1 D',
+                         :bar_size => '11 min',
+                         :what_to_show => :trades,
+                         :format_date => 1
+      end.to raise_error /bar_size must be one of/
+    end
+
+    it 'raises if incorrect what_to_show' do
+      expect do
+        @ib.send_message :RequestHistoricalData, :id => 456,
+                         :contract => IB::Symbols::Stocks[:wfc],
+                         :end_date_time => Time.now.to_ib,
+                         :duration => '1 D',
+                         :bar_size => '15 mins',
+                         :what_to_show => :nonsense,
+                         :format_date => 1
+      end.to raise_error /:what_to_show must be one of/
+    end
+  end
+
+  context 'Correct Request' do
+    before(:all) do
+      # No historical data for GBP/CASH@IDEALPRO
+      @ib.send_message :RequestHistoricalData, :id => 456,
+                       :contract => IB::Symbols::Stocks[:wfc],
+                       :end_date_time => Time.now.to_ib,
+                       :duration => '1 D',
+                       :bar_size => '15 mins',
+                       :what_to_show => :trades,
+                       :format_date => 1
+
+      wait_for(3) { received? :HistoricalData }
+    end
+
+    subject { @received[:HistoricalData].last }
+
+    it { @received[:HistoricalData].should have_at_least(1).historic_data }
+
+    it { should be_an IB::Messages::Incoming::HistoricalData }
+    its(:request_id) { should == 456 }
+    its(:count) { should be_an Integer }
+    its(:start_date) { should =~ /\d{8} *\d\d:\d\d:\d\d/ } # "20120302  22:46:42"
+    its(:end_date) { should =~ /\d{8} *\d\d:\d\d:\d\d/ }
+    its(:to_human) { should =~ /HistoricalData/ }
+
+    it 'has results Array with returned historic data' do
+      subject.results.should be_an Array
+      subject.results.size.should == subject.count
+      subject.results.each do |bar|
+        bar.should be_an IB::Models::Bar
+        bar.time.should =~ /\d{8} *\d\d:\d\d:\d\d/
+        bar.open.should be_a Float
+        bar.high.should be_a Float
+        bar.low.should be_a Float
+        bar.close.should be_a Float
+        bar.wap.should be_a Float
+        bar.trades.should be_an Integer
+        bar.volume.should be_an Integer
+      end
+    end
+  end
+end # Request Historic Data

data/spec/integration/market_data_spec.rb

@@ -0,0 +1,97 @@
+require 'integration_helper'
+
+describe 'Request Market Data', :connected => true, :integration => true do
+
+  context 'when subscribed to :Tick... messages' do
+
+    before(:all) do
+      verify_account
+      connect_and_receive :Alert, :TickPrice, :TickSize
+
+      ##TODO consider a follow the sun market lookup for windening the types tested
+      @ib.send_message :RequestMarketData, :id => 456,
+                       :contract => IB::Symbols::Forex[:eurusd]
+      wait_for(3) { received? :TickPrice }
+    end
+
+    after(:all) do
+      @ib.send_message :CancelMarketData, :id => 456
+      close_connection
+    end
+
+    context "received :Alert message " do
+      subject { @received[:Alert].first }
+
+      it { should be_an IB::Messages::Incoming::Alert }
+      it { should be_warning }
+      it { should_not be_error }
+      its(:code) { should be_an Integer }
+      its(:message) { should =~ /Market data farm connection is OK/ }
+      its(:to_human) { should =~ /TWS Warning/ }
+    end
+
+    context "received :TickPrice message" do
+      subject { @received[:TickPrice].first }
+
+      it { should be_an IB::Messages::Incoming::TickPrice }
+      its(:tick_type) { should be_an Integer }
+      its(:type) { should be_a Symbol }
+      its(:price) { should be_a Float }
+      its(:size) { should be_an Integer }
+      its(:data) { should be_a Hash }
+      its(:ticker_id) { should == 456 } # ticker_id
+      its(:to_human) { should =~ /TickPrice/ }
+    end
+
+    context "received :TickSize message", :if => :forex_trading_hours do
+      before(:all) do
+        wait_for(3) { received? :TickSize }
+      end
+
+      subject { @received[:TickSize].first }
+
+      it { should be_an IB::Messages::Incoming::TickSize }
+      its(:type) { should_not be_nil }
+      its(:data) { should be_a Hash }
+      its(:tick_type) { should be_an Integer }
+      its(:type) { should be_a Symbol }
+      its(:size) { should be_an Integer }
+      its(:ticker_id) { should == 456 }
+      its(:to_human) { should =~ /TickSize/ }
+    end
+  end # when subscribed to :Tick... messages
+
+  context 'when NOT subscribed to :Tick... messages', :slow => true do
+
+    before(:all) do
+      connect_and_receive :NextValidID
+
+      @ib.send_message :RequestMarketData, :id => 456,
+                       :contract => IB::Symbols::Forex[:eurusd]
+      wait_for(2)
+    end
+
+    after(:all) do
+      @ib.send_message :CancelMarketData, :id => 456
+      close_connection
+    end
+
+    it "logs warning about unhandled :OpenOrderEnd message" do
+      should_log /No subscribers for message .*:OpenOrderEnd/
+    end
+
+    it "logs warning about unhandled :Alert message" do
+      should_log /No subscribers for message .*:Alert/
+    end
+
+    it "logs warning about unhandled :Tick... messages" do
+      should_log /No subscribers for message .*:TickPrice/
+    end
+
+    it "logs warning about unhandled :Tick... messages", :if => :forex_trading_hours do
+      should_log /No subscribers for message .*:TickSize/
+    end
+
+  end # NOT subscribed to :Tick... messages
+
+end # Request Market Data