ib-ruby 0.7.4 → 0.7.6

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

@@ -1,73 +1,58 @@
-require 'spec_helper'
+require 'model_helper'
 
 describe IB::Models::Execution do # AKA IB::Execution
 
-  let(:properties) do
+  let(:props) do
     {:account_name => "DU111110",
-     :average_price => 1.31075,
      :client_id => 1111,
-     :cumulative_quantity => 20000,
      :exchange => "IDEALPRO",
      :exec_id => "0001f4e8.4f5d48f1.01.01",
-     :liquidation => 0,
+     :liquidation => true,
      :order_id => 373,
-     :perm_id => 1695693613,
+     :perm_id => 1695693619,
      :price => 1.31075,
+     :average_price => 1.31075,
      :shares => 20000,
+     :cumulative_quantity => 20000,
      :side => :buy,
      :time => "20120312  15:41:09"
     }
   end
 
-  context "instantiation" do
-    context 'empty without properties' do
-      subject { IB::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
+  let(:human) do
+    "<Execution: 20120312  15:41:09 buy 20000 at 1.31075 on IDEALPRO, " +
+        "cumulative 20000 at 1.31075, ids 373/1695693619/0001f4e8.4f5d48f1.01.01>"
+  end
 
-    context 'with properties' do
-      subject { IB::Execution.new properties }
+  let(:defaults) do
+    {:order_id => 0,
+     :client_id => 0,
+     :perm_id => 0,
+     :shares=> 0,
+     :price => 0,
+     :liquidation => false,
+     :created_at => Time,
+    }
+  end
 
-      it 'sets properties right' do
-        properties.each do |name, value|
-          subject.send(name).should == value
-        end
-      end
-    end
-  end #instantiation
+  let(:errors) do
+    {:side=>["should be buy/sell/short"],
+     :cumulative_quantity=>["is not a number"],
+     :average_price=>["is not a number"]}
+  end
 
-  context "properties" do
+  let(:assigns) do
+    {:side =>
+         {['BOT', 'BUY', 'Buy', 'buy', :BUY, :BOT, :Buy, :buy, 'B', :b] => :buy,
+          ['SELL', 'SLD', 'Sel', 'sell', :SELL, :SLD, :Sell, :sell, 'S', :S] => :sell},
 
-    it 'allows setting properties' do
-      expect {
-        x = IB::Execution.new
-        properties.each do |name, value|
-          subject.send("#{name}=", value)
-          subject.send(name).should == value
-        end
-      }.to_not raise_error
-    end
+     [:shares, :cumulative_quantity, :price, :average_price] =>
+         {[:foo, 'BAR', nil] => /is not a number/},
 
-    it 'sets side as directed by its setter' do
-      @x = IB::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
+     :liquidation => {[1, true] => true, [0, false] => false},
+    }
+  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
+  it_behaves_like 'Model'
 
 end # describe IB::Models::Contract

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

@@ -0,0 +1,127 @@
+require 'model_helper'
+
+describe IB::Models::Contracts::Option do # AKA IB::Option
+
+  let(:props) do
+    {:symbol => 'AAPL',
+     :expiry => '201301',
+     :strike => 600,
+     :right => :put,
+    }
+  end
+
+  let(:human) do
+    "<Option: AAPL 201301 put 600 SMART >"
+  end
+
+  let(:defaults) do
+    {:sec_type => :option,
+     :con_id => 0,
+     :strike => 0,
+     :min_tick => 0,
+     :include_expired => false,
+     :created_at => Time,
+    }
+  end
+
+  let(:errors) do
+    {:right => ["should be put or call"],
+     :strike => ["must be greater than 0"],
+    }
+  end
+
+  let(:assigns) do
+    {:expiry =>
+         {[200609, '200609'] => '200609',
+          [20060913, '20060913'] => '20060913',
+          [:foo, 2006, 42, 'bar'] => /should be YYYYMM or YYYYMMDD/},
+
+     :sec_type =>
+         {['OPT', :option] => :option,
+          IB::CODES[:sec_type].reject { |k, v,| k == :option }.to_a =>
+              /should be an option/},
+
+     :right =>
+         {["PUT", "put", "P", "p", :put] => :put,
+          ["CALL", "call", "C", "c", :call] => :call,
+          ['', '0', '?', :none, :foo, 'BAR', 42] => /should be put or call/},
+
+     :exchange =>
+         {[:cboe, 'cboE', 'CBOE'] => 'CBOE',
+          [:smart, 'SMART', 'smArt'] => 'SMART'},
+
+     :primary_exchange =>
+         {[:cboe, 'cboE', 'CBOE'] => 'CBOE',
+          [:SMART, 'SMART'] => /should not be SMART/},
+
+     :symbol =>
+         {['AAPL', :AAPL] => 'AAPL'},
+
+     :local_symbol =>
+         {['AAPL  130119C00500000', :'AAPL  130119C00500000'] =>
+              'AAPL  130119C00500000',
+          'BAR'=> /invalid OSI code/},
+
+     :strike => {[0, -30.0] => /must be greater than 0/},
+
+     :multiplier => {['123', 123] => 123},
+
+     [:under_con_id, :min_tick, :coupon] => {123 => 123}
+
+    }
+  end
+
+  context 'using shorter class name without properties' do
+    subject { IB::Models::Option.new }
+    it_behaves_like 'Model instantiated empty'
+  end
+
+  context 'using shortest class name without properties' do
+    subject { IB::Option.new }
+    it_behaves_like 'Model instantiated empty'
+  end
+
+  it_behaves_like 'Model'
+  it_behaves_like 'Self-equal Model'
+
+  context 'properly initiated' do
+    subject { IB::Option.new props }
+    it_behaves_like 'Contract'
+
+    it 'has extra osi accessor, aliasing :local_symbol' do
+      subject.osi = 'FOO'
+      subject.local_symbol.should == 'FOO'
+      subject.local_symbol = 'bar'
+      subject.osi.should == 'bar'
+    end
+  end
+
+  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
+
+  context '.from_osi class builder' do
+    subject { IB::Option.from_osi 'AAPL130119C00500000' }
+
+    it 'builds a valid Option contract from OSI code' do
+      subject.should be_an IB::Option
+      subject.should be_valid
+      subject.symbol.should == 'AAPL'
+      subject.expiry.should == '130118' # <- NB: Change in date!
+      subject.right.should == :call
+      subject.strike.should == 500
+      #subject.osi.should == 'AAPL  130119C00500000'
+    end
+
+    it_behaves_like 'Contract'
+  end
+
+end # describe IB::Contract

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

@@ -1,116 +1,137 @@
-require 'spec_helper'
+require 'model_helper'
 
 describe IB::Models::Order do
 
-  let(:properties) do
-    {:outside_rth => true,
-     :open_close => 'C',
-     :origin => IB::Order::Origin_Firm,
-     :transmit => false,
+  let(:props) do
+    {:order_id => 23,
+     :order_ref => 'Test',
+     :client_id => 1111,
+     :perm_id => 173276893,
+     :parent_id => 0,
+     :side => :buy,
+     :order_type => :market_if_touched,
+     :limit_price => 0.01,
+     :total_quantity => 100,
+     :tif => :good_till_cancelled,
+     :open_close => :close,
+     :oca_group => '',
+     :oca_type => :reduce_no_block,
+     :origin => :firm,
      :designated_location => "WHATEVER",
      :exempt_code => 123,
-     :delta_neutral_order_type => "HACK",
+     :delta_neutral_order_type => :market,
+     #:commission_currency => "USD",
+     #:status => 'PreSubmitted',
+     :transmit => false,
+     :outside_rth => true,
      :what_if => true,
      :not_held => true}
   end
 
-  context "instantiation" do
-    context 'empty without properties' do
-      subject { IB::Order.new }
-
-      it { should_not be_nil }
-      its(:outside_rth) { should == false }
-      its(:open_close) { should == "O" }
-      its(:origin) { should == IB::Order::Origin_Customer }
-      its(:transmit) { should == true }
-      its(:designated_location) { should == '' }
-      its(:exempt_code) { should == -1 }
-      its(:delta_neutral_order_type) { should == '' }
-      its(:what_if) { should == false }
-      its(:not_held) { should == false }
-      its(:created_at) { should be_a Time }
-    end
+  # TODO: :presents => { Object => "Formatted"}
+  let(:human) do
+    "<Order: Test MIT GTC buy 100 New 0.01 #23/173276893 from 1111>"
+  end
 
-    context 'with properties' do
-      subject { IB::Order.new properties }
+  let(:defaults) do
+    {:outside_rth => false,
+     :open_close => :open,
+     :short_sale_slot => :default,
+     :tif => :day,
+     :order_type => :limit,
+     :origin => :customer,
+     :transmit => true,
+     :designated_location => '',
+     :exempt_code => -1,
+     :what_if => false,
+     :not_held => false,
+     :status => 'New',
+     :created_at => Time,
+    }
+  end
 
-      it 'sets properties right' do
-        properties.each do |name, value|
-          subject.send(name).should == value
-        end
-      end
+  let(:errors) do
+    {:side =>["should be buy/sell/short"],
+     :order_id => ["is not a number"], }
+  end
 
-      context 'essential properties are still set, even if not given explicitely' do
-        its(:created_at) { should be_a Time }
-      end
-    end
+  let(:assigns) do
+    {[:order_type, :delta_neutral_order_type] => codes_and_values_for(:order_type),
+     :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,
+          [1, nil, 'ASK', :foo] => /should be buy.sell.short/, },
+
+     [:what_if, :not_held, :outside_rth, :hidden, :transmit, :block_order, :sweep_to_fill,
+      :override_percentage_constraints, :all_or_none, :etrade_only, :firm_quote_only,
+      :opt_out_smart_routing, :scale_auto_reset, :scale_random_percent
+     ] => {[1, true] => true, [0, false] => false},
+    }
+  end
 
-    it 'allows setting attributes' do
-      x = IB::Order.new
-      properties.each do |name, value|
-        subject.send("#{name}=", value)
-        subject.send(name).should == value
-      end
-    end
-  end #instantiation
+  it_behaves_like 'Model'
+  it_behaves_like 'Self-equal Model'
 
   context 'equality' do
-    subject { IB::Order.new properties }
+    subject { IB::Order.new props }
 
-    it 'is  self-equal ' do
-      should == subject
-    end
-
-    it 'is equal to Order with the same properties' do
-      should == IB::Order.new(properties)
-    end
+    it_behaves_like 'Self-equal Model'
 
     it 'is not equal for Orders with different limit price' do
       order1 = IB::Order.new :total_quantity => 100,
-                                     :limit_price => 1,
-                                     :action => 'BUY'
+                             :limit_price => 1,
+                             :action => 'BUY'
 
       order2 = IB::Order.new :total_quantity => 100,
-                                     :limit_price => 2,
-                                     :action => 'BUY'
+                             :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::Order.new :total_quantity => 20000,
-                                     :limit_price => 1,
-                                     :action => 'BUY'
+                             :limit_price => 1,
+                             :action => 'BUY'
 
       order2 = IB::Order.new :total_quantity => 100,
-                                     :action => 'BUY',
-                                     :limit_price => 1
+                             :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::Order.new :total_quantity => 100,
-                                     :limit_price => 1,
-                                     :action => 'SELL'
+                             :limit_price => 1,
+                             :action => 'SELL'
 
       order2 = IB::Order.new :total_quantity => 100,
-                                     :action => 'BUY',
-                                     :limit_price => 1
+                             :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::Order.new :total_quantity => 100,
-                                     :limit_price => 1,
-                                     :action => 'BUY',
-                                     :order_type => 'LMT'
+                             :limit_price => 1,
+                             :action => 'BUY',
+                             :order_type => 'LMT'
 
       order2 = IB::Order.new :total_quantity => 100,
-                                     :action => 'BUY',
-                                     :limit_price => 1,
-                                     :order_type => 'MKT'
+                             :action => 'BUY',
+                             :limit_price => 1,
+                             :order_type => 'MKT'
       order1.should_not == order2
       order2.should_not == order1
     end

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

@@ -0,0 +1,55 @@
+require 'model_helper'
+
+describe IB::Models::OrderState do
+
+  let(:props) do
+    {:order_id => 23,
+     :perm_id => 173276893,
+     :client_id => 1111,
+     :parent_id => 0,
+     :filled => 3,
+     :remaining => 2,
+     :last_fill_price => 0.5,
+     :average_fill_price => 0.55,
+     :why_held => 'child',
+
+     :init_margin => 500.0,
+     :maint_margin => 500.0,
+     :equity_with_loan => 750.0,
+     :commission_currency => 'USD',
+     :commission => 1.2,
+     :min_commission => 1,
+     :max_commission => 1.5,
+     :status => 'PreSubmitted',
+     :warning_text => 'Oh noes!',
+    }
+  end
+
+  # TODO: :presents => { Object => "Formatted"}
+  let(:human) do
+    "<OrderState: PreSubmitted #23/173276893 from 1111 filled 3/2 at 0.5/0.55 margin 500.0/500.0 equity 750.0 fee 1.2 why_held child warning Oh noes!>"
+  end
+
+  let(:defaults) do
+    {:created_at => Time,
+    }
+  end
+
+  let(:errors) do
+    {:order_id => ["is not a number"],
+     :client_id => ["is not a number"],
+     :perm_id => ["is not a number"], }
+  end
+
+  let(:assigns) do
+    {   :tester => {1 => 1},
+        [:order_id, :perm_id, :client_id] =>
+         {[:foo, 'bar'] => /is not a number/,
+          [5.0, 2006.17] => /must be an integer/, }
+    }
+  end
+
+  it_behaves_like 'Model'
+  it_behaves_like 'Self-equal Model'
+
+end # describe IB::Order