ib-ruby 0.7.4 → 0.7.6

data/spec/ib-ruby/messages/outgoing/market_data_type_spec.rb

@@ -0,0 +1,44 @@
+require 'message_helper'
+
+# The API can receive frozen market data from Trader Workstation. Frozen market
+# data is the last data recorded in our system. During normal trading hours,
+# the API receives real-time market data. If you use this function, you are
+# telling TWS to automatically switch to frozen market data AFTER the close.
+# Then, before the opening of the next trading day, market data will automatically
+# switch back to real-time market data.
+# :market_data_type = 1 for real-time streaming, 2 for frozen market data
+
+describe "Request Market Data Type", :connected => true, :integration => true do
+
+  before(:all) do
+    verify_account
+    @ib = IB::Connection.new OPTS[:connection].merge(:logger => mock_logger)
+  end
+
+  after(:all) { close_connection }
+
+  context "switching to real_time streaming after-hours" do
+    before(:all) do
+      @ib.send_message :RequestMarketDataType, :market_data_type => :real_time
+      @ib.wait_for 2 # sec
+    end
+
+    after(:all) { clean_connection }
+
+    it 'just works' do
+    end
+  end
+
+  context "switching to frozen market data after-hours" do
+    before(:all) do
+      @ib.send_message :RequestMarketDataType, :market_data_type => :frozen
+      @ib.wait_for 2 # sec
+    end
+
+    after(:all) { clean_connection }
+
+    it 'just works' do
+    end
+  end
+
+end # Request Market Data Type

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

@@ -0,0 +1,97 @@
+require 'model_helper'
+
+describe IB::Models::Contracts::Bag do # AKA IB::Bag
+
+  let(:props) do
+    {:symbol => 'GOOG',
+     :exchange => 'SMART',
+     :currency => 'USD',
+     :legs => [IB::ComboLeg.new(:con_id => 81032967, :weight => 1),
+               IB::ComboLeg.new(:con_id => 81032968, :weight => -2),
+               IB::ComboLeg.new(:con_id => 81032973, :weight => 1)]
+    }
+  end
+
+  let(:human) do
+    "<Bag: GOOG SMART USD legs: 81032967|1,81032968|-2,81032973|1 >"
+  end
+
+  let(:defaults) do
+    {:sec_type => :bag,
+     :con_id => 0,
+     :strike => 0,
+     :min_tick => 0,
+     :include_expired => false,
+     :created_at => Time,
+    }
+  end
+
+  let(:errors) do
+    {:legs => ["legs cannot be empty"],
+    }
+  end
+
+  let(:assigns) do
+    {:expiry =>
+         {[nil, ''] => '',
+          [20060913, '20060913', 200609, '200609', :foo, 2006, 42, 'bar'] =>
+              /should be blank/},
+
+     :sec_type =>
+         {['BAG', :bag] => :bag,
+          IB::CODES[:sec_type].reject { |k, v,| k == :bag }.to_a =>
+              /should be a bag/},
+
+     :right =>
+         {['?', :none, '', '0'] => :none,
+          ["PUT", :put, "CALL", "C", :call, :foo, 'BAR', 42] =>
+              /should be none/},
+
+     :exchange =>
+         {[:cboe, 'cboE', 'CBOE'] => 'CBOE',
+          [:smart, 'SMART', 'smArt'] => 'SMART'},
+
+     :primary_exchange =>
+         {[:cboe, 'cboE', 'CBOE'] => 'CBOE',
+          [:SMART, 'SMART'] => /should not be SMART/},
+
+     [:symbol, :local_symbol] =>
+         {['AAPL', :AAPL] => 'AAPL'},
+
+     :multiplier => {['123', 123] => 123},
+
+     [:under_con_id, :min_tick, :coupon] => {123 => 123}
+    }
+  end
+
+  context 'using shortest class name without properties' do
+    subject { IB::Bag.new }
+    it_behaves_like 'Model instantiated empty'
+  end
+
+  it_behaves_like 'Model'
+  it_behaves_like 'Self-equal Model'
+
+  context 'properly initiated' do
+    subject { IB::Bag.new props }
+
+    it_behaves_like 'Contract'
+
+    it 'has extra legs_description accessor' do
+      subject.legs_description.should == "81032967|1,81032968|-2,81032973|1"
+    end
+  end
+
+  it 'correctly defines Contract type (sec_type) for Bag contract' do
+    [IB::Contract.new(:sec_type => :bag),
+     IB::Contract.new(:sec_type => 'BAG'),
+     IB::Bag.new
+    ].each do |contract|
+      contract.should be_bag
+      contract.should_not be_bond
+      contract.should_not be_stock
+      contract.should_not be_option
+    end
+  end
+
+end # describe IB::Bag

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

@@ -0,0 +1,45 @@
+require 'model_helper'
+
+describe IB::Models::Bar do # AKA IB::Bar
+
+  let(:props) do
+    {:open => 1.31,
+     :high => 1.35,
+     :low => 1.30,
+     :close => 1.33,
+     :wap => 1.32,
+     :volume => 20000,
+     :has_gaps => true,
+     :trades => 50,
+     :time => "20120312  15:41:09",
+    }
+  end
+
+  let(:defaults) do
+    {:created_at => Time,
+    }
+  end
+
+  let(:errors) do
+    {:close => ["is not a number"],
+     :high => ["is not a number"],
+     :low => ["is not a number"],
+     :open => ["is not a number"],
+     :volume => ["is not a number"]}
+  end
+
+  let(:assigns) do
+    {:has_gaps => {[1, true] => true, [0, false] => false},
+
+     [:open, :high, :low, :close, :volume] =>
+         {[:foo, 'BAR', nil] => /is not a number/}
+    }
+  end
+
+  let(:human) do
+    "<Bar: 20120312  15:41:09 wap 1.32 OHLC 1.31 1.35 1.3 1.33 trades 50 vol 20000 gaps true>"
+  end
+
+  it_behaves_like 'Model'
+
+end # describe IB::Bar

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

@@ -1,55 +1,71 @@
-require 'spec_helper'
+require 'model_helper'
 
 describe IB::Models::ComboLeg do
 
-  let(:properties) do
-    {:con_id => 123,
-     :ratio=> 1234,
-     :action => 'BUY',
-     :exchange => 'BLAH',
-     :open_close => IB::ComboLeg::OPEN,
-     :short_sale_slot => 1,
-     :designated_location => 'BLEH',
-     :exempt_code => 12}
+  let(:props) do
+    {:con_id => 81032967,
+     :ratio => 2,
+     :action => :buy,
+     :exchange => 'CBOE',
+     :open_close => :open,
+     :short_sale_slot => :broker,
+     :designated_location => nil,
+     :exempt_code => -1}
   end
 
-  context "instantiation" do
-    context 'empty without properties' do
-      subject { IB::ComboLeg.new }
+  let(:human) do
+    "<ComboLeg: buy 2 con_id 81032967 at CBOE>"
+  end
 
-      it { should_not be_nil }
-      its(:con_id) {should == 0}
-      its(:open_close) {should == 0}
-      its(:short_sale_slot) {should == 0}
-      its(:designated_location) {should == ''}
-      its(:exempt_code) {should == -1}
+  let(:defaults) do
+    {:con_id => 0,
+     :open_close => :same,
+     :designated_location => '',
+     :exempt_code => -1,
+     :exchange => 'SMART', # Unless SMART, Order modification fails
+     :created_at => Time,
+ }
+  end
 
-      its(:created_at) {should be_a Time}
-    end
+  let(:errors) do
+    {:ratio => ["is not a number"],
+     :side => ["should be buy/sell/short"]}
+  end
+
+  let(:assigns) do
+    {:open_close =>
+         {['SAME', 'same', 'S', 's', :same, 0, '0'] => :same,
+          ['OPEN', 'open', 'O', 'o', :open, 1, '1'] => :open,
+          ['CLOSE', 'close', 'C', 'c', :close, 2, '2'] => :close,
+          ['UNKNOWN', 'unknown', 'U', 'u', :unknown, 3, '3'] => :unknown,
+          [42, nil, 'Foo', :bar] => /should be same.open.close.unknown/},
+
+     :side =>
+         {['BOT', 'BUY', 'Buy', 'buy', :BUY, :BOT, :Buy, :buy, 'B', :b] => :buy,
+          ['SELL', 'SLD', 'Sel', 'sell', :SELL, :SLD, :Sell, :sell, 'S', :S] => :sell,
+          ['SSHORT', 'Short', 'short', :SHORT, :short, 'T', :T] => :short,
+          ['SSHORTX', 'Shortextemt', 'shortx', :short_exempt, 'X', :X] => :short_exempt,
+          [42, nil, 'ASK', :foo] => /should be buy.sell.short/},
+
+     :designated_location =>
+         {[42, 'FOO', :bar] => /should be blank or orders will be rejected/},
+    }
+  end
 
-    context 'with properties' do
-      subject { IB::ComboLeg.new properties }
+  it_behaves_like 'Model'
+  it_behaves_like 'Self-equal Model'
 
-      it 'sets properties right' do
-        properties.each do |name, value|
-          subject.send(name).should == value
-        end
-      end
+  context "serialization" do
+    subject { IB::ComboLeg.new props }
 
-      context 'essential properties are still set, even if not given explicitely' do
-        its(:created_at) {should be_a Time}
-      end
+    it "serializes short" do
+      subject.serialize.should == [81032967, 2, "BUY", "CBOE"]
     end
 
-    it 'allows setting attributes' do
-      expect {
-        x = IB::ComboLeg.new
-        properties.each do |name, value|
-          subject.send("#{name}=", value)
-          subject.send(name).should == value
-        end
-      }.to_not raise_error
+    it "serializes extended" do
+      subject.serialize(:extended).should ==
+          [81032967, 2, "BUY", "CBOE", 1, 1, nil, -1]
     end
-  end #instantiation
+  end #serialization
 
 end # describe IB::Models::Contract::ComboLeg

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

@@ -1,216 +1,180 @@
-require 'spec_helper'
+require 'model_helper'
+require 'combo_helper'
 
 describe IB::Models::Contracts::Contract do # AKA IB::Contract
 
-  let(:properties) do
-    {:symbol => "TEST",
-     :sec_type => IB::SECURITY_TYPES[:stock],
-     :expiry => '200609',
-     :strike => 1234,
-     :right => "PUT",
-     :multiplier => 123,
-     :exchange => "SMART",
-     :currency => "USD",
-     :local_symbol => "baz"}
+  let(:props) do
+    {:symbol => 'AAPL',
+     :sec_type => :option,
+     :expiry => '201301',
+     :strike => 600,
+     :right => :put,
+     :multiplier => 10,
+     :exchange => 'SMART',
+     :currency => 'USD',
+     :local_symbol => 'AAPL  130119C00500000'}
   end
 
-  context "instantiation" do
-    context 'using fully qualified class name without properties' do
-      subject { IB::Models::Contract.new }
-
-      it { should_not be_nil }
-      its(:con_id) { should == 0 }
-      its(:strike) { should == 0 }
-      its(:sec_type) { should be_nil }
-      its(:created_at) { should be_a Time }
-      its(:include_expired) { should == false }
-    end
-
-    context 'using short class name without properties' do
-      subject { IB::Contract.new }
-
-      it { should_not be_nil }
-      its(:con_id) { should == 0 }
-      its(:strike) { should == 0 }
-      its(:sec_type) { should be_nil }
-      its(:created_at) { should be_a Time }
-      its(:include_expired) { should == false }
-    end
-
-    context 'with properties' do
-      subject { IB::Contract.new properties }
+  let(:human) do
+    "<Contract: AAPL option 201301 put 600 SMART USD>"
+  end
 
-      it 'sets properties right' do
-        properties.each do |name, value|
-          subject.send(name).should == value
-        end
-      end
+  let(:defaults) do
+    {:con_id => 0,
+     :strike => 0,
+     :min_tick => 0,
+     :coupon => 0,
+     :callable => false,
+     :puttable => false,
+     :convertible => false,
+     :next_option_partial => false,
+     :include_expired => false,
+     :created_at => Time,
+    }
+  end
 
-      context 'essential properties are still set, even if not given explicitely' do
-        its(:con_id) { should == 0 }
-        its(:created_at) { should be_a Time }
-        its(:include_expired) { should == false }
-      end
-    end
+  let(:errors) do
+    {:sec_type => ["should be valid security type"],
+    }
+  end
 
-    context "ContractDetails properties" do
-      let(:detailed_properties) do
-        {:under_con_id => 123,
-         :min_tick=> 1234,
-         :callable => true,
-         :puttable => true,
-         :coupon => 12345,
-         :convertible => true,
-         :next_option_partial => true}
-      end
+  let(:assigns) do
+    {:expiry =>
+         {[200609, '200609'] => '200609',
+          [20060913, '20060913'] => '20060913',
+          [:foo, 2006, 42, 'bar'] => /should be YYYYMM or YYYYMMDD/},
 
-      context 'empty without properties' do
-        subject { IB::Contract.new }
-
-        its(:summary) { should == subject }
-        its(:under_con_id) { should == 0 }
-        its(:min_tick) { should == 0 }
-        its(:callable) { should == false }
-        its(:puttable) { should == false }
-        its(:coupon) { should == 0 }
-        its(:convertible) { should == false }
-        its(:next_option_partial) { should == false }
-        its(:created_at) { should be_a Time }
-      end
+     :sec_type => codes_and_values_for(:sec_type).
+         merge([:foo, 'BAR', 42] => /should be valid security type/),
 
-      context 'with properties' do
-        subject { IB::Contract.new detailed_properties }
+     :right =>
+         {["PUT", "put", "P", "p", :put] => :put,
+          ["CALL", "call", "C", "c", :call] => :call,
+          ['', '0', '?', :none] => :none,
+          [:foo, 'BAR', 42] => /should be put, call or none/},
 
-        its(:summary) { should == subject }
-        its(:created_at) { should be_a Time }
+     :exchange =>
+         {[:cboe, 'cboE', 'CBOE'] => 'CBOE',
+          [:smart, 'SMART', 'smArt'] => 'SMART'},
 
-        it 'sets properties right' do
-          detailed_properties.each do |name, value|
-            subject.send(name).should == value
-          end
-        end
-      end
-    end #instantiation
-
-    it 'allows setting attributes' do
-      expect {
-        x = IB::Contract.new
-        properties.each do |name, value|
-          subject.send("#{name}=", value)
-          subject.send(name).should == value
-        end
-        x.expiry = 200609
-        x.expiry.should == '200609'
-      }.to_not raise_error
-    end
+     :primary_exchange =>
+         {[:cboe, 'cboE', 'CBOE'] => 'CBOE',
+          [:SMART, 'SMART'] => /should not be SMART/},
 
-    it 'allows setting ContractDetails attributes' do
-      x = IB::Contract.new
-      expect {
-        x.callable = true
-        x.puttable = true
-        x.convertible = true
-        x.under_con_id = 321
-        x.min_tick = 123
-        x.next_option_partial = true
-      }.to_not raise_error
-
-      x.callable.should == true
-      x.puttable.should == true
-      x.convertible.should == true
-      x.under_con_id.should == 321
-      x.min_tick.should == 123
-      x.next_option_partial.should == true
-    end
+     :multiplier => {['123', 123] => 123},
 
-    it 'converts multiplier to int' do
-      expect { @contract = IB::Contract.new(:multiplier => '123') }.to_not raise_error
-      expect { @contract.multiplier = '123' }.to_not raise_error
-      @contract.multiplier.should == 123
-    end
+     [:under_con_id, :min_tick, :coupon] => {123 => 123},
 
-    it 'raises on wrong security type' do
-      expect { IB::Contract.new(:sec_type => "asdf") }.to raise_error ArgumentError
+     [:callable, :puttable, :convertible, :next_option_partial] =>
+         {[1, true] => true, [0, false] => false},
+    }
+  end
 
-      expect { IB::Contract.new.sec_type = "asdf" }.to raise_error ArgumentError
-    end
+  it_behaves_like 'Model'
+  it_behaves_like 'Self-equal Model'
 
-    it 'accepts pre-determined security types' do
-      IB::SECURITY_TYPES.values.each do |type|
-        expect { IB::Contract.new(:sec_type => type) }.to_not raise_error
+  context 'testing for Contract type (sec_type)' do
 
-        expect { IB::Contract.new.sec_type = type }.to_not raise_error
+    it 'correctly defines Contract type (sec_type) for Option contract' do
+      [IB::Contract.new(:sec_type => :option),
+       IB::Contract.new(:sec_type => 'OPT'),
+       IB::Option.new
+      ].each do |contract|
+        contract.should_not be_bag
+        contract.should_not be_bond
+        contract.should_not be_stock
+        contract.should be_option
       end
     end
 
-    it 'raises on wrong expiry' do
-      expect { IB::Contract.new(:expiry => "foo") }.to raise_error ArgumentError
-
-      expect { IB::Contract.new.expiry = "foo" }.to raise_error ArgumentError
+    it 'correctly defines Contract type for Bag Contracts' do
+      [IB::Contract.new(:sec_type => :bag),
+       IB::Contract.new(:sec_type => 'BAG'),
+       IB::Bag.new
+      ].each do |contract|
+        contract.should be_bag
+        contract.should_not be_bond
+        contract.should_not be_stock
+        contract.should_not be_option
+      end
     end
 
-    it 'accepts correct expiry' do
-      expect { IB::Contract.new(:expiry => "200607") }.to_not raise_error
-
-      expect { IB::Contract.new.expiry = "200607" }.to_not raise_error
-
-      expect { IB::Contract.new(:expiry => 200607) }.to_not raise_error
-
-      expect {
-        x = IB::Contract.new
-        x.expiry = 200607
-        x.expiry.should == "200607" # converted to a string
-      }.to_not raise_error
+    it 'correctly defines Contract type for Bag Contracts' do
+      [IB::Contract.new(:sec_type => :stock),
+       IB::Contract.new(:sec_type => 'STK'),
+      ].each do |contract|
+        contract.should_not be_bag
+        contract.should_not be_bond
+        contract.should be_stock
+        contract.should_not be_option
+      end
     end
 
-    it 'raises on incorrect right (option type)' do
-      expect { IB::Contract.new(:right => "foo") }.to raise_error ArgumentError
-      expect { IB::Contract.new.right = "foo" }.to raise_error ArgumentError
+    it 'correctly defines Contract type for Bond Contracts' do
+      [IB::Contract.new(:sec_type => :bond),
+       IB::Contract.new(:sec_type => 'BOND'),
+      ].each do |contract|
+        contract.should_not be_bag
+        contract.should be_bond
+        contract.should_not be_stock
+        contract.should_not be_option
+      end
     end
 
-    it 'accepts all correct values for right (option type)' do
-      ["PUT", "put", "P", "p"].each do |right|
-        expect { @contract = IB::Contract.new(:right => right) }.to_not raise_error
-        @contract.right.should == "PUT"
+  end
 
-        expect { @contract.right = right }.to_not raise_error
-        @contract.right.should == "PUT"
-      end
+  context 'using shorter class name without properties' do
+    subject { IB::Models::Contract.new }
+    it_behaves_like 'Model instantiated empty'
+    it_behaves_like 'Self-equal Model'
+    it_behaves_like 'Contract'
+  end
 
-      ["CALL", "call", "C", "c"].each do |right|
-        expect { @contract = IB::Contract.new(:right => right) }.to_not raise_error
-        @contract.right.should == "CALL"
+  context 'using shortest class name without properties' do
+    subject { IB::Contract.new }
+    it_behaves_like 'Model instantiated empty'
+    it_behaves_like 'Self-equal Model'
+    it_behaves_like 'Contract'
+  end
 
-        expect { @contract.right = right }.to_not raise_error
-        @contract.right.should == "CALL"
-      end
+  context "serialization" do
+    before(:all) do
+      @ib = IB::Connection.new OPTS[:connection].merge(:logger => mock_logger)
+      @ib.wait_for :ManagedAccounts
+      @combo = butterfly 'GOOG', '201301', 'CALL', 500, 510, 520
+      close_connection
     end
-  end #instantiation
 
-  context "serialization" do
-    subject { IB::Contract.new properties }
+    subject { IB::Contract.new props }
 
     it "serializes long" do
       subject.serialize_long.should ==
-          ["TEST", IB::SECURITY_TYPES[:stock], "200609", 1234, "PUT", 123, "SMART", nil, "USD", "baz"]
+          ["AAPL", "OPT", "201301", 600, "P", 10, "SMART", nil, "USD", "AAPL  130119C00500000"]
     end
 
     it "serializes short" do
       subject.serialize_short.should ==
-          ["TEST", IB::SECURITY_TYPES[:stock], "200609", 1234, "PUT", 123, "SMART", "USD", "baz"]
+          ["AAPL", "OPT", "201301", 600, "P", 10, "SMART", "USD", "AAPL  130119C00500000"]
     end
-  end #serialization
-
-  context 'equality' do
-    subject { IB::Contract.new properties }
 
-    it 'be self-equal ' do
-      should == subject
+    it "serializes combo (BAG) contracts for Order placement" do
+      @combo.serialize_long(:con_id, :sec_id).should ==
+          [0, "GOOG", "BAG", nil, 0.0, "", nil, "SMART", nil, "USD", nil, nil, nil]
     end
 
-    it 'be equal to object with the same properties' do
-      should == IB::Contract.new(properties)
+    it 'also serializes attached combo legs' do
+      subject.serialize_legs.should == []
+      subject.serialize_legs(:extended).should == []
+
+      @combo.serialize_legs.should ==
+          [3, 81032967, 1, "BUY", "SMART", 81032968, 2, "SELL", "SMART", 81032973, 1, "BUY", "SMART"]
+
+      @combo.serialize_legs(:extended).should ==
+          [3, 81032967, 1, "BUY", "SMART", 0, 0, "", -1,
+           81032968, 2, "SELL", "SMART", 0, 0, "", -1,
+           81032973, 1, "BUY", "SMART", 0, 0, "", -1]
     end
-  end
+  end #serialization
+
 
 end # describe IB::Contract