ig_markets 0.1

data/spec/ig_markets/dealing_platform/market_methods_spec.rb

@@ -0,0 +1,80 @@
+describe IGMarkets::DealingPlatform::MarketMethods do
+  let(:session) { IGMarkets::Session.new }
+  let(:platform) do
+    IGMarkets::DealingPlatform.new.tap do |platform|
+      platform.instance_variable_set :@session, session
+    end
+  end
+
+  it 'can retrieve the market hierarchy root' do
+    result = build :market_hierarchy_result
+
+    expect(session).to receive(:get).with('marketnavigation', IGMarkets::API_V1).and_return(result)
+    expect(platform.markets.hierarchy).to eq(result)
+  end
+
+  it 'can retrieve a market hierarchy node' do
+    result = build :market_hierarchy_result
+
+    expect(session).to receive(:get).with('marketnavigation/1', IGMarkets::API_V1).and_return(result)
+    expect(platform.markets.hierarchy(1)).to eq(result)
+  end
+
+  it 'can retrieve a market from an EPIC' do
+    get_result = {
+      market_details: [{
+        dealing_rules: build(:market_dealing_rules),
+        instrument: build(:instrument),
+        snapshot: build(:market_snapshot)
+      }]
+    }
+
+    expect(session).to receive(:get).with('markets?epics=ABCDEF', IGMarkets::API_V2).and_return(get_result)
+    expect(platform.markets['ABCDEF']).to eq(IGMarkets::Market.from(get_result[:market_details])[0])
+  end
+
+  it 'can search for markets' do
+    markets = [build(:market_overview)]
+
+    expect(session).to receive(:get).with('markets?searchTerm=USD', IGMarkets::API_V1).and_return(markets: markets)
+    expect(platform.markets.search('USD')).to eq(markets)
+  end
+
+  it 'can retrieve a specified number of historical prices for a market' do
+    markets_get_result = {
+      market_details: [{
+        dealing_rules: build(:market_dealing_rules),
+        instrument: build(:instrument),
+        snapshot: build(:market_snapshot)
+      }]
+    }
+
+    historical_price_result = build :historical_price_result
+
+    expect(session).to receive(:get).with('markets?epics=ABCDEF', IGMarkets::API_V2).and_return(markets_get_result)
+    expect(session).to receive(:get).with('prices/ABCDEF/DAY/5', IGMarkets::API_V2).and_return(historical_price_result)
+    expect(platform.markets['ABCDEF'].recent_prices(:day, 5)).to eq(historical_price_result)
+  end
+
+  it 'can retrieve a date range of historical prices for a market' do
+    from_date = DateTime.new 2014, 1, 2, 3, 4, 5
+    to_date = DateTime.new 2014, 2, 3, 4, 5, 6
+
+    markets_get_result = {
+      market_details: [{
+        dealing_rules: build(:market_dealing_rules),
+        instrument: build(:instrument),
+        snapshot: build(:market_snapshot)
+      }]
+    }
+
+    historical_price_result = build :historical_price_result
+
+    expect(session).to receive(:get).with('markets?epics=ABCDEF', IGMarkets::API_V2).and_return(markets_get_result)
+    expect(session).to receive(:get)
+      .with('prices/ABCDEF/DAY/2014-01-02T03:04:05/2014-02-03T04:05:06', IGMarkets::API_V2)
+      .and_return(historical_price_result)
+
+    expect(platform.markets['ABCDEF'].prices_in_date_range(:day, from_date, to_date)).to eq(historical_price_result)
+  end
+end

data/spec/ig_markets/dealing_platform/position_methods_spec.rb

@@ -0,0 +1,137 @@
+describe IGMarkets::DealingPlatform::PositionMethods do
+  let(:session) { IGMarkets::Session.new }
+  let(:platform) do
+    IGMarkets::DealingPlatform.new.tap do |platform|
+      platform.instance_variable_set :@session, session
+    end
+  end
+
+  it 'can retrieve the current positions' do
+    positions = [build(:position)]
+
+    get_result = {
+      positions: positions.map(&:attributes).map do |a|
+        { market: a[:market], position: a }
+      end
+    }
+
+    expect(session).to receive(:get).with('positions', IGMarkets::API_V2).and_return(get_result)
+    expect(platform.positions.all).to eq(positions)
+  end
+
+  it 'can retrieve a single position' do
+    position = build :position
+
+    expect(session).to receive(:get)
+      .with("positions/#{position.deal_id}", IGMarkets::API_V2)
+      .and_return(position: position.attributes, market: position.market)
+
+    expect(platform.positions[position.deal_id]).to eq(position)
+  end
+
+  it 'can create a position' do
+    attributes = {
+      currency_code: 'USD',
+      direction: :buy,
+      epic: 'CS.D.EURUSD.CFD.IP',
+      size: 2.0
+    }
+
+    payload = {
+      currencyCode: 'USD',
+      direction: 'BUY',
+      epic: 'CS.D.EURUSD.CFD.IP',
+      expiry: '-',
+      forceOpen: false,
+      guaranteedStop: false,
+      orderType: 'MARKET',
+      size: 2.0,
+      timeInForce: 'EXECUTE_AND_ELIMINATE'
+    }
+
+    result = { deal_reference: 'reference' }
+
+    expect(session).to receive(:post).with('positions/otc', payload, IGMarkets::API_V2).and_return(result)
+    expect(platform.positions.create(attributes)).to eq(result.fetch(:deal_reference))
+  end
+
+  it 'validates position creation attributes correctly' do
+    attributes = {
+      currency_code: 'USD',
+      direction: :buy,
+      epic: 'CS.D.EURUSD.CFD.IP',
+      size: 2.0,
+      time_in_force: :execute_and_eliminate
+    }
+
+    create_position = proc do |override_attributes = {}|
+      platform.positions.create attributes.merge override_attributes
+    end
+
+    expect(session).to receive(:post).exactly(10).times.and_return(deal_reference: 'reference')
+
+    expect { create_position.call }.to_not raise_error
+    expect { create_position.call order_type: :quote }.to raise_error(ArgumentError)
+    expect { create_position.call order_type: :quote, quote_id: 'a' }.to raise_error(ArgumentError)
+    expect { create_position.call order_type: :quote, level: 1 }.to raise_error(ArgumentError)
+    expect { create_position.call order_type: :quote, quote_id: 'a', level: 1 }.to_not raise_error
+    expect { create_position.call order_type: :limit }.to raise_error(ArgumentError)
+    expect { create_position.call order_type: :limit, level: 1 }.to_not raise_error
+    expect { create_position.call trailing_stop: true, stop_distance: 1 }.to raise_error(ArgumentError)
+    expect { create_position.call trailing_stop: true, stop_distance: 1, trailing_stop_increment: 1 }.not_to raise_error
+    expect { create_position.call limit_distance: 1 }.not_to raise_error
+    expect { create_position.call limit_level: 1 }.not_to raise_error
+    expect { create_position.call limit_distance: 1, limit_level: 1 }.to raise_error(ArgumentError)
+    expect { create_position.call stop_distance: 1 }.not_to raise_error
+    expect { create_position.call stop_level: 1 }.not_to raise_error
+    expect { create_position.call stop_distance: 1, stop_level: 1 }.to raise_error(ArgumentError)
+    expect { create_position.call guaranteed_stop: true }.to raise_error(ArgumentError)
+    expect { create_position.call guaranteed_stop: true, stop_distance: 1 }.not_to raise_error
+    expect { create_position.call guaranteed_stop: true, stop_level: 1 }.not_to raise_error
+  end
+
+  it 'can update a position' do
+    position = build :position, deal_id: '1'
+
+    get_result = { position: position.attributes, market: position.market }
+    payload = { limitLevel: 2.0, stopLevel: 1.0, trailingStop: false }
+    put_result = { deal_reference: 'reference' }
+
+    expect(session).to receive(:get).with('positions/1', IGMarkets::API_V2).and_return(get_result)
+    expect(session).to receive(:put).with('positions/otc/1', payload, IGMarkets::API_V2).and_return(put_result)
+    expect(platform.positions['1'].update(stop_level: 1, limit_level: 2)).to eq('reference')
+  end
+
+  it 'can close a position' do
+    position = build :position, deal_id: '1', size: 5
+
+    get_result = { position: position.attributes, market: position.market }
+    payload = { dealId: '1', direction: 'SELL', orderType: 'MARKET', size: 5.0, timeInForce: 'EXECUTE_AND_ELIMINATE' }
+    delete_result = { deal_reference: 'reference' }
+
+    expect(session).to receive(:get).with('positions/1', IGMarkets::API_V2).and_return(get_result)
+    expect(session).to receive(:delete).with('positions/otc', payload, IGMarkets::API_V1).and_return(delete_result)
+    expect(platform.positions['1'].close).to eq('reference')
+  end
+
+  it 'validates position close attributes correctly' do
+    position = build :position, deal_id: '1'
+    position.instance_variable_set :@dealing_platform, platform
+
+    attributes = { time_in_force: :execute_and_eliminate }
+
+    close_position = proc do |override_attributes = {}|
+      position.close attributes.merge override_attributes
+    end
+
+    expect(session).to receive(:delete).exactly(3).times.and_return(deal_reference: 'reference')
+
+    expect { close_position.call }.to_not raise_error
+    expect { close_position.call order_type: :quote }.to raise_error(ArgumentError)
+    expect { close_position.call order_type: :quote, quote_id: 'a' }.to raise_error(ArgumentError)
+    expect { close_position.call order_type: :quote, level: 1 }.to raise_error(ArgumentError)
+    expect { close_position.call order_type: :quote, quote_id: 'a', level: 1 }.to_not raise_error
+    expect { close_position.call order_type: :limit }.to raise_error(ArgumentError)
+    expect { close_position.call order_type: :limit, level: 1 }.to_not raise_error
+  end
+end

data/spec/ig_markets/dealing_platform/sprint_market_position_methods_spec.rb

@@ -0,0 +1,39 @@
+describe IGMarkets::DealingPlatform::SprintMarketPositionMethods do
+  let(:session) { IGMarkets::Session.new }
+  let(:platform) do
+    IGMarkets::DealingPlatform.new.tap do |platform|
+      platform.instance_variable_set :@session, session
+    end
+  end
+
+  it 'can retrieve the current sprint market positions' do
+    positions = [build(:sprint_market_position)]
+
+    expect(session).to receive(:get)
+      .with('positions/sprintmarkets', IGMarkets::API_V1)
+      .and_return(sprint_market_positions: positions)
+
+    expect(platform.sprint_market_positions.all).to eq(positions)
+  end
+
+  it 'can create a sprint market position' do
+    attributes = {
+      direction: :buy,
+      epic: 'CS.D.EURUSD.CFD.IP',
+      expiry_period: :five_minutes,
+      size: 2.0
+    }
+
+    payload = {
+      direction: 'BUY',
+      epic: 'CS.D.EURUSD.CFD.IP',
+      expiryPeriod: 'FIVE_MINUTES',
+      size: 2.0
+    }
+
+    result = { deal_reference: 'reference' }
+
+    expect(session).to receive(:post).with('positions/sprintmarkets', payload, IGMarkets::API_V1).and_return(result)
+    expect(platform.sprint_market_positions.create(attributes)).to eq(result.fetch(:deal_reference))
+  end
+end

data/spec/ig_markets/dealing_platform/watchlist_methods_spec.rb

@@ -0,0 +1,89 @@
+describe IGMarkets::DealingPlatform::WatchlistMethods do
+  let(:session) { IGMarkets::Session.new }
+  let(:platform) do
+    IGMarkets::DealingPlatform.new.tap do |platform|
+      platform.instance_variable_set :@session, session
+    end
+  end
+
+  it 'can retrieve the watchlists' do
+    watchlists = [build(:watchlist)]
+
+    expect(session).to receive(:get).with('watchlists', IGMarkets::API_V1).and_return(watchlists: watchlists)
+    expect(platform.watchlists.all).to eq(watchlists)
+  end
+
+  it 'can retrieve the markets for a watchlist' do
+    markets = [build(:market_overview)]
+
+    expect(session).to receive(:get).with('watchlists', IGMarkets::API_V1).and_return(watchlists: [{ id: 1 }])
+    expect(session).to receive(:get).with('watchlists/1', IGMarkets::API_V1).and_return(markets: markets)
+    expect(platform.watchlists['1'].markets).to eq(markets)
+  end
+
+  it 'can create a watchlist' do
+    watchlist_id = '1000'
+    name = 'New Watchlist'
+    epics = ['ABCDEF']
+
+    expect(session).to receive(:post)
+      .with('watchlists', { name: name, epics: epics }, IGMarkets::API_V1)
+      .and_return(watchlist_id: watchlist_id, status: 'SUCCESS')
+
+    expect(session).to receive(:get)
+      .with('watchlists', IGMarkets::API_V1)
+      .and_return(watchlists: [{ id: watchlist_id }])
+
+    expect(platform.watchlists.create(name, epics)).to eq(IGMarkets::Watchlist.new(id: watchlist_id))
+  end
+
+  it 'can delete a watchlist' do
+    watchlist_id = '1000'
+
+    result = { status: 'SUCCESS' }
+
+    expect(session).to receive(:get)
+      .with('watchlists', IGMarkets::API_V1)
+      .and_return(watchlists: [{ id: watchlist_id }])
+
+    expect(session).to receive(:delete)
+      .with("watchlists/#{watchlist_id}", nil, IGMarkets::API_V1)
+      .and_return(result)
+
+    expect(platform.watchlists[watchlist_id].delete).to eq(result)
+  end
+
+  it 'can add a market to a watchlist' do
+    watchlist_id = '1000'
+    epic = 'ABCDEF'
+
+    result = { status: 'SUCCESS' }
+
+    expect(session).to receive(:get)
+      .with('watchlists', IGMarkets::API_V1)
+      .and_return(watchlists: [{ id: watchlist_id }])
+
+    expect(session).to receive(:put)
+      .with("watchlists/#{watchlist_id}", { epic: epic }, IGMarkets::API_V1)
+      .and_return(result)
+
+    expect(platform.watchlists[watchlist_id].add_market(epic)).to eq(result)
+  end
+
+  it 'can remove a market from a watchlist' do
+    watchlist_id = '1000'
+    epic = 'ABCDEF'
+
+    result = { status: 'SUCCESS' }
+
+    expect(session).to receive(:get)
+      .with('watchlists', IGMarkets::API_V1)
+      .and_return(watchlists: [{ id: watchlist_id }])
+
+    expect(session).to receive(:delete)
+      .with("watchlists/#{watchlist_id}/#{epic}", nil, IGMarkets::API_V1)
+      .and_return(result)
+
+    expect(platform.watchlists[watchlist_id].remove_market(epic)).to eq(result)
+  end
+end

data/spec/ig_markets/dealing_platform/working_order_methods_spec.rb

@@ -0,0 +1,120 @@
+describe IGMarkets::DealingPlatform::WorkingOrderMethods do
+  let(:session) { IGMarkets::Session.new }
+  let(:platform) do
+    IGMarkets::DealingPlatform.new.tap do |platform|
+      platform.instance_variable_set :@session, session
+    end
+  end
+
+  it 'can retrieve the current working orders' do
+    orders = [build(:working_order)]
+
+    get_result = {
+      working_orders: orders.map(&:attributes).map do |a|
+        { market_data: a[:market], working_order_data: a }
+      end
+    }
+
+    expect(session).to receive(:get).with('workingorders', IGMarkets::API_V2).and_return(get_result)
+    expect(platform.working_orders.all).to eq(orders)
+  end
+
+  it 'can retrieve a single working order' do
+    orders = [build(:working_order, deal_id: 'id')]
+
+    get_result = {
+      working_orders: orders.map(&:attributes).map do |a|
+        { market_data: a[:market], working_order_data: a }
+      end
+    }
+
+    expect(session).to receive(:get).with('workingorders', IGMarkets::API_V2).and_return(get_result)
+    expect(platform.working_orders['id']).to eq(orders[0])
+  end
+
+  it 'can create a working order' do
+    attributes = {
+      currency_code: 'USD',
+      direction: :buy,
+      epic: 'CS.D.EURUSD.CFD.IP',
+      level: 1.0,
+      size: 2.0,
+      time_in_force: :good_till_cancelled,
+      type: :limit
+    }
+
+    payload = {
+      currencyCode: 'USD',
+      direction: 'BUY',
+      epic: 'CS.D.EURUSD.CFD.IP',
+      expiry: '-',
+      forceOpen: false,
+      guaranteedStop: false,
+      level: 1.0,
+      size: 2.0,
+      timeInForce: 'GOOD_TILL_CANCELLED',
+      type: 'LIMIT'
+    }
+
+    result = { deal_reference: 'reference' }
+
+    expect(session).to receive(:post).with('workingorders/otc', payload, IGMarkets::API_V2).and_return(result)
+    expect(platform.working_orders.create(attributes)).to eq(result.fetch(:deal_reference))
+  end
+
+  it 'requires good_till_date if time_in_force is :good_till_date' do
+    attributes = {
+      currency_code: 'USD',
+      direction: :buy,
+      epic: 'CS.D.EURUSD.CFD.IP',
+      level: 1.0,
+      size: 2.0,
+      time_in_force: :good_till_date,
+      type: :limit
+    }
+
+    expect { platform.working_orders.create attributes }.to raise_error(ArgumentError)
+  end
+
+  it 'can delete a working order' do
+    orders = [build(:working_order, deal_id: '1')]
+
+    get_result = {
+      working_orders: orders.map(&:attributes).map do |a|
+        { market_data: a[:market], working_order_data: a }
+      end
+    }
+
+    del_result = { deal_reference: 'reference' }
+
+    expect(session).to receive(:get).with('workingorders', IGMarkets::API_V2).and_return(get_result)
+    expect(session).to receive(:delete).with('workingorders/otc/1', {}, IGMarkets::API_V1).and_return(del_result)
+
+    expect(platform.working_orders['1'].delete).to eq('reference')
+  end
+
+  it 'can update a working order' do
+    orders = [build(:working_order, deal_id: '1')]
+
+    get_result = {
+      working_orders: orders.map(&:attributes).map do |a|
+        { market_data: a[:market], working_order_data: a }
+      end
+    }
+
+    payload = {
+      goodTillDate: '2015/10/20 10:45',
+      level: 1.03,
+      limitDistance: 20,
+      stopDistance: 30,
+      timeInForce: 'GOOD_TILL_DATE',
+      type: 'LIMIT'
+    }
+
+    put_result = { deal_reference: 'reference' }
+
+    expect(session).to receive(:get).with('workingorders', IGMarkets::API_V2).and_return(get_result)
+    expect(session).to receive(:put).with('workingorders/otc/1', payload, IGMarkets::API_V1).and_return(put_result)
+    expect(platform.working_orders['1'].update(level: 1.03, limit_distance: 20, stop_distance: 30)).to eq('reference')
+  end
+end