ib-ruby 0.5.21 → 0.6.1

data/lib/ib-ruby/symbols/stocks.rb

@@ -13,11 +13,17 @@ module IB
                                       :currency => "USD",
                                       :sec_type => SECURITY_TYPES[:stock],
                                       :description => "Wells Fargo"),
-        :wrong => Models::Contract.new(:symbol => "QEEUUE",
-                                      :exchange => "NYSE",
-                                      :currency => "USD",
-                                      :sec_type => SECURITY_TYPES[:stock],
-                                      :description => "Non-existent stock"),
+
+         :aapl => Models::Contract.new(:symbol => "AAPL",
+                                       :currency => "USD",
+                                       :sec_type => SECURITY_TYPES[:stock],
+                                       :description => "Apple Inc."),
+
+         :wrong => Models::Contract.new(:symbol => "QEEUUE",
+                                        :exchange => "NYSE",
+                                        :currency => "USD",
+                                        :sec_type => SECURITY_TYPES[:stock],
+                                        :description => "Non-existent stock"),
         }
   end
 end

data/spec/account_helper.rb

@@ -0,0 +1,80 @@
+# Make sure integration tests are only run against the pre-configured PAPER ACCOUNT
+def verify_account
+  return OPTS[:account_verified] if OPTS[:account_verified]
+
+  puts
+  puts 'WARNING: MAKE SURE TO RUN INTEGRATION TESTS AGAINST IB PAPER ACCOUNT ONLY!'
+  puts 'WARNING: FINANCIAL LOSSES MAY RESULT IF YOU RUN TESTS WITH REAL IB ACCOUNT!'
+  puts 'WARNING: YOU HAVE BEEN WARNED!'
+  puts
+  puts 'Configure your connection to IB PAPER ACCOUNT in spec/spec_helper.rb'
+  puts
+
+  account = OPTS[:connection][:account] || OPTS[:connection][:account_name]
+  raise "Please configure IB PAPER ACCOUNT in spec/spec_helper.rb" unless account
+
+  @ib = IB::Connection.new OPTS[:connection].merge(:logger => mock_logger)
+  @ib.send_message :RequestAccountData, :subscribe => true
+
+  @ib.wait_for 3, :AccountValue
+  raise "Unable to verify IB PAPER ACCOUNT" unless @ib.received?(:AccountValue)
+
+  received = @ib.received[:AccountValue].first.account_name
+  raise "Connected to wrong account #{received}, expected #{account}" if account != received
+
+  close_connection
+  OPTS[:account_verified] = true
+end
+
+### Helpers for placing and verifying orders
+
+shared_examples_for 'Valid account data request' do
+
+  context "received :AccountUpdateTime message" do
+    subject { @ib.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 { @ib.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 { @ib.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 { @ib.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
+

data/spec/ib-ruby/connection_spec.rb

@@ -1,94 +1,237 @@
 require 'message_helper'
+require 'account_helper'
+
+shared_examples_for 'Connected Connection' do
+
+  subject { @ib }
+
+  it_behaves_like 'Connected Connection without receiver'
+
+  it 'keeps received messages in Hash by default' do
+    subject.received.should be_a Hash
+    subject.received[:NextValidId].should_not be_empty
+    subject.received[:NextValidId].should have_exactly(1).message
+  end
+end
+
+shared_examples_for 'Connected Connection without receiver' do
+
+  it { should_not be_nil }
+  it { should be_connected }
+  its(:server) { should be_a Hash }
+  its(:server) { should have_key :reader }
+  its(:subscribers) { should have_at_least(1).item } # :NextValidId and empty Hashes
+  its(:next_order_id) { should be_a Fixnum } # Not before :NextValidId arrives
+end
+
+# Need top level method to access instance var (@received) in nested context
+def create_connection opts={}
+  # Start disconnected (we need to set up catch-all subscriber first)
+  @ib = IB::Connection.new OPTS[:connection].merge(:logger => mock_logger).merge(opts)
+
+  # Hash of received messages, keyed by message type
+  @received = Hash.new { |hash, key| hash[key] = Array.new }
+
+  @subscriber = proc { |msg| @received[msg.message_type] << msg }
+end
 
 describe IB::Connection do
 
-  context 'when connected to IB Gateway', :connected => true do
-    # THIS depends on TWS|Gateway connectivity
+  context 'instantiated with default options', :connected => true do
     before(:all) do
-      @ib = IB::Connection.new OPTS[:connection].merge(:logger => mock_logger)
-      @ib.subscribe(:OpenOrderEnd) {}
+      create_connection
+      @ib.wait_for :NextValidId
     end
 
     after(:all) { close_connection }
 
-    context 'instantiation with default options' do
-      subject { @ib }
-
-      it { should_not be_nil }
-      it { should be_connected }
-      its(:server) { should be_a Hash }
-      its(:server) { should have_key :reader }
-      its(:subscribers) { should have_at_least(1).item } # :NextValidID and empty Hashes
-      its(:next_order_id) { should be_a Fixnum } # Not before :NextValidID arrives
-    end
+    it_behaves_like 'Connected Connection'
 
     describe '#send_message', 'sending messages' do
       it 'allows 3 signatures representing IB::Messages::Outgoing' do
-        expect {
-          @ib.send_message :RequestOpenOrders, :subscribe => true
-        }.to_not raise_error
+        expect { @ib.send_message :RequestOpenOrders }.to_not raise_error
 
-        expect {
-          @ib.send_message IB::Messages::Outgoing::RequestOpenOrders, :subscribe => true
+        expect { @ib.send_message IB::Messages::Outgoing::RequestOpenOrders
         }.to_not raise_error
 
-        expect {
-          @ib.send_message IB::Messages::Outgoing::RequestOpenOrders.new :subscribe => true
+        expect { @ib.send_message IB::Messages::Outgoing::RequestOpenOrders.new
         }.to_not raise_error
       end
 
       it 'has legacy #dispatch alias' do
-        expect { @ib.dispatch :RequestOpenOrders, :subscribe => true
-        }.to_not raise_error
+        expect { @ib.dispatch :RequestOpenOrders }.to_not raise_error
       end
     end
 
     context "subscriptions" do
+      before(:all) do
+        @id = {} # Moving id between contexts. Feels dirty.
+      end
+
+      describe '#subscribe' do
+        after(:all) { clean_connection }
+
+        it 'adds (multiple) subscribers, returning subscription id' do
+          @id[:first] = @ib.subscribe(IB::Messages::Incoming::OrderStatus) do |msg|
+            log msg.to_human
+          end
+
+          @id[:second] = @ib.subscribe /Value/, :OpenOrder, @subscriber
+
+          @id[:third] = @ib.subscribe /Account/, &@subscriber
+
+          [[@id[:first], IB::Messages::Incoming::OrderStatus],
+           [@id[:second], IB::Messages::Incoming::OpenOrder],
+           [@id[:second], IB::Messages::Incoming::PortfolioValue],
+           [@id[:second], IB::Messages::Incoming::AccountValue], # as /Value/
+           [@id[:third], IB::Messages::Incoming::AccountValue], #  as /Account/
+           [@id[:third], IB::Messages::Incoming::AccountDownloadEnd],
+           [@id[:third], IB::Messages::Incoming::AccountUpdateTime],
+          ].each do |(subscriber_id, message_class)|
+            @ib.subscribers.should have_key(message_class)
+            @ib.subscribers[message_class].should have_key(subscriber_id)
+          end
+        end
 
-      it '#subscribe, adds(multiple) subscribers' do
-        @subscriber_id = @ib.subscribe(IB::Messages::Incoming::Alert, :OpenOrder, /Value/) do
+        it 'returns Integer subscription id' do
+          @id[:first].should be_an Integer
+          @id[:second].should be_an Integer
+          @id[:third].should be_an Integer
         end
 
-        @subscriber_id.should be_a Fixnum
+        context 'when subscribed' do
 
-        [IB::Messages::Incoming::Alert,
-         IB::Messages::Incoming::OpenOrder,
-         IB::Messages::Incoming::AccountValue,
-         IB::Messages::Incoming::PortfolioValue
-        ].each do |message_class|
-          @ib.subscribers.should have_key(message_class)
-          @ib.subscribers[message_class].should have_key(@subscriber_id)
+          before(:all) do
+            @ib.send_message :RequestAccountData
+            @ib.wait_for :AccountDownloadEnd
+          end
+
+          after(:all) { @ib.send_message :RequestAccountData, :subscribe => false }
+
+          it 'receives subscribed message types and processes them in subscriber callback' do
+            @received[:AccountValue].should_not be_empty
+            @received[:PortfolioValue].should_not be_empty
+            @received[:AccountDownloadEnd].should_not be_empty
+            @received[:AccountUpdateTime].should_not be_empty
+          end
+
+          it_behaves_like 'Valid account data request'
+        end
+      end # subscribe
+
+      describe '#unsubscribe' do
+        before(:all) { @result = @ib.unsubscribe @id[:first], @id[:second] }
+
+        it 'removes all subscribers at given id or ids' do
+          [IB::Messages::Incoming::OrderStatus,
+           IB::Messages::Incoming::OpenOrder,
+           IB::Messages::Incoming::PortfolioValue,
+           IB::Messages::Incoming::AccountValue,
+          ].each do |message_class|
+            @ib.subscribers[message_class].should_not have_key(@id[:first])
+            @ib.subscribers[message_class].should_not have_key(@id[:second])
+          end
         end
-      end
 
-      it '#unsubscribe, removes all subscribers at this id' do
-        @ib.unsubscribe(@subscriber_id)
+        it 'does not remove subscribers at other ids' do
+          @ib.subscribers[IB::Messages::Incoming::AccountValue].should have_key(@id[:third])
+          @ib.subscribers[IB::Messages::Incoming::AccountDownloadEnd].should have_key(@id[:third])
+          @ib.subscribers[IB::Messages::Incoming::AccountUpdateTime].should have_key(@id[:third])
+        end
+
+        it 'returns an Array of removed subscribers' do
+          @result.should be_an Array
+          @result.should have_exactly(4).deleted_subscribers
+        end
 
-        [IB::Messages::Incoming::Alert,
-         IB::Messages::Incoming::OpenOrder,
-         IB::Messages::Incoming::AccountValue,
-         IB::Messages::Incoming::PortfolioValue
-        ].each do |message_class|
-          @ib.subscribers[message_class].should_not have_key(@subscriber_id)
+        it 'raises on nosense id given' do
+          expect { @ib.unsubscribe 'nonsense' }.to raise_error /No subscribers with id/
+          expect { @ib.unsubscribe rand(9999999) }.to raise_error /No subscribers with id/
         end
       end
 
+      context 'when unsubscribed' do
+
+        before(:all) do
+          @ib.send_message :RequestAccountData
+          @ib.wait_for { !@received[:AccountDownloadEnd].empty? }
+        end
+
+        after(:all) { @ib.send_message :RequestAccountData, :subscribe => false }
+
+        it 'receives subscribed message types still subscribed' do
+          @received[:AccountValue].should_not be_empty
+          @received[:AccountUpdateTime].should_not be_empty
+          @received[:AccountDownloadEnd].should_not be_empty
+        end
+
+        it 'does not receive unsubscribed message types' do
+          @received[:PortfolioValue].should be_empty
+        end
+
+        it { should_log /No subscribers for message .*:PortfolioValue/ }
+        it { should_not_log /No subscribers for message .*:AccountValue/ }
+      end # when subscribed
     end # subscriptions
+
+    describe '#connect' do
+      it 'raises on another connection attempt' do
+        expect { @ib.connect }.to raise_error /Already connected/
+      end
+    end
   end # connected
 
-  context 'when not connected to IB Gateway' do
-    before(:all) { @ib = IB::Connection.new :connect => false, :reader => false }
+  context 'instantiated passing :connect => false' do
+    before(:all) { create_connection :connect => false,
+                                     :reader => false }
+    subject { @ib }
+
+    it { should_not be_nil }
+    it { should_not be_connected }
+    its(:server) { should be_a Hash }
+    its(:server) { should_not have_key :reader }
+    its(:received) { should be_empty }
+    its(:subscribers) { should be_empty }
+    its(:next_order_id) { should be_nil }
+
+    describe 'connecting idle conection' do
+      before(:all) do
+        @ib.connect
+        @ib.start_reader
+        @ib.wait_for :NextValidId
+      end
+      after(:all) { close_connection }
+
+      it_behaves_like 'Connected Connection'
+    end
 
-    context 'instantiation passing :connect => false' do
-      subject { @ib }
+  end # not connected
 
-      it { should_not be_nil }
-      it { should_not be_connected }
-      its(:server) { should be_a Hash }
-      its(:server) { should_not have_key :reader }
-      its(:subscribers) { should be_empty }
-      its(:next_order_id) { should be_nil }
+  context 'instantiated passing :received => false' do
+    before(:all) { create_connection :connect => false,
+                                     :reader => false,
+                                     :received => false }
+    subject { @ib }
+
+    it { should_not be_nil }
+    it { should_not be_connected }
+    its(:server) { should be_a Hash }
+    its(:server) { should_not have_key :reader }
+    its(:received) { should be_empty }
+    its(:subscribers) { should be_empty }
+    its(:next_order_id) { should be_nil }
+
+    describe 'connecting idle conection' do
+      before(:all) do
+        @ib.connect
+        @ib.start_reader
+        @ib.wait_for 1 # ib.received not supposed to work!
+      end
+      after(:all) { close_connection }
+
+      it_behaves_like 'Connected Connection without receiver'
     end
 
   end # not connected
+
 end # describe IB::Connection

data/spec/ib-ruby/messages/incoming_spec.rb

@@ -7,7 +7,7 @@ shared_examples_for 'Alert message' do
   its(:message_type) { should == :Alert }
   its(:message_id) { should == 4 }
   its(:version) { should == 2 }
-  its(:data) { should == {:version=>2, :error_id=>-1, :code=>2104, :message=>"Market data farm connection is OK:cashfarm"}}
+  its(:data) { should == {:version=>2, :error_id=>-1, :code=>2104, :message=>"Market data farm connection is OK:cashfarm"} }
   its(:error_id) { should == -1 }
   its(:code) { should == 2104 }
   its(:message) { should =~ /Market data farm connection is OK/ }
@@ -37,13 +37,13 @@ describe IB::Messages::Incoming do
   context 'Message received from IB', :connected => true do
 
     before(:all) do
-      connect_and_receive :Alert
-      wait_for(2) { received? :Alert }
+      @ib = IB::Connection.new OPTS[:connection].merge(:logger => mock_logger)
+      @ib.wait_for :Alert
     end
 
     after(:all) { close_connection }
 
-    subject { @received[:Alert].first }
+    subject { @ib.received[:Alert].first }
 
     it_behaves_like 'Alert message'
   end #

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

@@ -22,6 +22,7 @@ describe IB::Models::ComboLeg do
       its(:ratio) {should == 0}
       its(:open_close) {should == 0}
       its(:short_sale_slot) {should == 0}
+      its(:designated_location) {should == ''}
       its(:exempt_code) {should == -1}
 
       its(:created_at) {should be_a Time}

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

@@ -21,7 +21,7 @@ describe IB::Models::Contract do
       it { should_not be_nil }
       its(:con_id) { should == 0 }
       its(:strike) { should == 0 }
-      its(:sec_type) { should == '' }
+      its(:sec_type) { should be_nil }
       its(:created_at) { should be_a Time }
       its(:include_expired) { should == false }
     end

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

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe IB::Models::Execution do
+
+  let(:properties) do
+    {:account_name => "DU111110",
+     :average_price => 1.31075,
+     :client_id => 1111,
+     :cumulative_quantity => 20000,
+     :exchange => "IDEALPRO",
+     :exec_id => "0001f4e8.4f5d48f1.01.01",
+     :liquidation => 0,
+     :order_id => 373,
+     :perm_id => 1695693613,
+     :price => 1.31075,
+     :shares => 20000,
+     :side => :buy,
+     :time => "20120312  15:41:09"
+    }
+  end
+
+  context "instantiation" do
+    context 'empty without properties' do
+      subject { IB::Models::Execution.new }
+
+      it { should_not be_nil }
+      its(:order_id) { should == 0 }
+      its(:client_id) { should == 0 }
+      its(:perm_id) { should == 0 }
+      its(:shares) { should == 0 }
+      its(:price) { should == 0 }
+      its(:liquidation) { should == 0 }
+      its(:created_at) { should be_a Time }
+    end
+
+    context 'with properties' do
+      subject { IB::Models::Execution.new properties }
+
+      it 'sets properties right' do
+        properties.each do |name, value|
+          subject.send(name).should == value
+        end
+      end
+    end
+  end #instantiation
+
+  context "properties" do
+
+    it 'allows setting properties' do
+      expect {
+        x = IB::Models::Execution.new
+        properties.each do |name, value|
+          subject.send("#{name}=", value)
+          subject.send(name).should == value
+        end
+      }.to_not raise_error
+    end
+
+    it 'sets side as directed by its setter' do
+      @x = IB::Models::Execution.new
+      ['BOT', 'BUY', 'Buy', 'buy', :BUY, :BOT, :Buy, :buy, 'B', :b].each do |val|
+        expect { @x.side = val }.to_not raise_error
+        @x.side.should == :buy
+      end
+
+      ['SELL', 'SLD', 'Sel', 'sell', :SELL, :SLD, :Sell, :sell, 'S', :S].each do |val|
+        expect { @x.side = val }.to_not raise_error
+        @x.side.should == :sell
+      end
+    end
+  end # properties
+
+end # describe IB::Models::Contract

data/spec/integration/account_info_spec.rb

@@ -1,66 +1,10 @@
 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)
+    @ib = IB::Connection.new OPTS[:connection].merge(:logger => mock_logger)
   end
 
   after(:all) { close_connection }
@@ -68,7 +12,11 @@ describe "Request Account Data", :connected => true, :integration => true do
   context "with subscribe option set" do
     before(:all) do
       @ib.send_message :RequestAccountData, :subscribe => true
-      wait_for(5) { received? :AccountDownloadEnd }
+      @ib.wait_for 5, :AccountDownloadEnd
+    end
+    after(:all) do
+      @ib.send_message :RequestAccountData, :subscribe => false
+      clean_connection
     end
 
     it_behaves_like 'Valid account data request'
@@ -77,7 +25,12 @@ describe "Request Account Data", :connected => true, :integration => true do
   context "without subscribe option" do
     before(:all) do
       @ib.send_message :RequestAccountData
-      wait_for(5) { received? :AccountDownloadEnd }
+      @ib.wait_for 5, :AccountDownloadEnd
+    end
+
+    after(:all) do
+      @ib.send_message :RequestAccountData, :subscribe => false
+      clean_connection
     end
 
     it_behaves_like 'Valid account data request'