ig_markets 0.1 → 0.2

data/spec/ig_markets/dealing_platform/working_order_methods_spec.rb

@@ -1,120 +0,0 @@
-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

data/spec/ig_markets/dealing_platform_spec.rb

@@ -1,40 +0,0 @@
-describe IGMarkets::DealingPlatform do
-  let(:session) { IGMarkets::Session.new }
-  let(:platform) do
-    IGMarkets::DealingPlatform.new.tap do |platform|
-      platform.instance_variable_set :@session, session
-    end
-  end
-
-  it 'has a valid session' do
-    expect(IGMarkets::DealingPlatform.new.session).to be_an_instance_of(IGMarkets::Session)
-  end
-
-  it 'can sign in' do
-    expect(session).to receive(:sign_in).and_return({})
-    expect(platform.sign_in('username', 'password', 'api_key', :production)).to eq({})
-    expect(session.username).to eq('username')
-    expect(session.password).to eq('password')
-    expect(session.api_key).to eq('api_key')
-    expect(session.platform).to eq(:production)
-  end
-
-  it 'can sign out' do
-    expect(session).to receive(:sign_out).and_return(nil)
-    expect(platform.sign_out).to eq(nil)
-  end
-
-  it 'can retrieve a deal confirmation' do
-    deal_confirmation = build :deal_confirmation
-
-    expect(session).to receive(:get).with('confirms/deal_id', IGMarkets::API_V1).and_return(deal_confirmation)
-    expect(platform.deal_confirmation('deal_id')).to eq(deal_confirmation)
-  end
-
-  it 'can retrieve the current applications' do
-    applications = [build(:application)]
-
-    expect(session).to receive(:get).with('operations/application', IGMarkets::API_V1).and_return(applications)
-    expect(platform.applications).to eq(applications)
-  end
-end

data/spec/ig_markets/model_spec.rb

@@ -1,127 +0,0 @@
-describe IGMarkets::Model do
-  class TestModel < IGMarkets::Model
-    attribute :id
-    attribute :bool, IGMarkets::Boolean
-    attribute :string, String, regex: /\A[A-Z]{3}\Z/, nil_if: '-'
-    attribute :date, DateTime, format: '%Y-%m-%d'
-    attribute :float, Float
-    attribute :symbol, Symbol, allowed_values: [:a, :b]
-  end
-
-  let(:model) { TestModel.new }
-
-  it 'initializes with specified attribute values' do
-    expect(TestModel.new(id: 'test', bool: true).attributes).to eq(
-      id: 'test', bool: true, string: nil, date: nil, float: nil, symbol: nil)
-  end
-
-  it 'fails when initialized with an unknown attribute' do
-    expect { TestModel.new id: 'test', unknown: '' }.to raise_error(ArgumentError)
-  end
-
-  it 'has the correct getter and setter methods' do
-    [:id, :id=, :bool, :bool=, :string, :string=, :date, :date=, :float, :float=, :symbol, :symbol=].each do |id|
-      expect(model.respond_to?(id)).to eq(true)
-    end
-  end
-
-  it 'has the correct attributes hash' do
-    expect(model.attributes).to eq(id: nil, bool: nil, string: nil, date: nil, float: nil, symbol: nil)
-  end
-
-  it 'inspects attributes' do
-    expect(model.inspect).to eq('#<TestModel id: nil, bool: nil, string: nil, date: nil, float: nil, symbol: nil>')
-  end
-
-  it 'inspects attributes in nested models' do
-    class TestModel2 < IGMarkets::Model
-      attribute :test, TestModel
-    end
-
-    model = TestModel2.new test: TestModel.new
-
-    expect(model.inspect).to eq(
-      '#<TestModel2 test: #<TestModel id: nil, bool: nil, string: nil, date: nil, float: nil, symbol: nil>>')
-  end
-
-  it '#from accepts nil' do
-    expect(TestModel.from(nil)).to eq(nil)
-  end
-
-  it '#from accepts an attributes hash' do
-    expect(TestModel.from(id: 'test').attributes).to eq(
-      id: 'test', bool: nil, string: nil, date: nil, float: nil, symbol: nil)
-  end
-
-  it '#from accepts an instance and creates a copy' do
-    instance = TestModel.new(id: 'test')
-
-    expect(TestModel.from(instance)).to eq(instance)
-    expect(TestModel.from(instance)).not_to eql(instance)
-  end
-
-  it '#from accepts an Array of attributes hashes' do
-    expect(TestModel.from([{ id: 'a' }, { id: 'b' }])).to eq([TestModel.new(id: 'a'), TestModel.new(id: 'b')])
-  end
-
-  it '#from raises on invalid inputs' do
-    ['', DateTime.new, IGMarkets::Model.new].each do |invalid_input|
-      expect { TestModel.from(invalid_input) }.to raise_error(ArgumentError)
-    end
-  end
-
-  it 'raises ArgumentError for an invalid boolean' do
-    expect { model.bool = '' }.to raise_error(ArgumentError)
-  end
-
-  it 'raises ArgumentError when string value does not match the regex' do
-    expect { model.string = 'abc' }.to raise_error(ArgumentError)
-  end
-
-  it 'raises ArgumentError for an invalid date' do
-    expect { model.date = '2015-29-01' }.to raise_error(ArgumentError)
-  end
-
-  it 'raises ArgumentError for an invalid float' do
-    expect { model.float = 'a' }.to raise_error(ArgumentError)
-  end
-
-  it 'raises ArgumentError for an invalid symbol' do
-    expect { model.symbol = :invalid }.to raise_error(ArgumentError)
-  end
-
-  it 'returns the correct set of allowed values for an attribute' do
-    expect(TestModel.allowed_values(:symbol)).to eq([:a, :b])
-  end
-
-  it 'sets attribute to nil when value matches a nil_if' do
-    model.string = '-'
-    expect(model.string).to eq(nil)
-  end
-
-  it 'correctly parses a date in the expected format' do
-    model.date = '2015-01-10'
-    expect(model.date).to eq(DateTime.new(2015, 1, 10))
-  end
-
-  context 'with all attributes set' do
-    before do
-      model.id = 'id'
-      model.bool = true
-      model.string = 'ABC'
-      model.date = '2015-01-10'
-      model.float = '1.0'
-      model.symbol = 'a'
-    end
-
-    it 'has the correct attributes hash' do
-      expect(model.attributes).to eq(
-        id: 'id', bool: true, string: 'ABC', date: DateTime.new(2015, 1, 10), float: 1.0, symbol: :a)
-    end
-
-    it 'inspects attributes' do
-      expect(model.inspect).to eq(
-        '#<TestModel id: "id", bool: true, string: "ABC", date: 2015-01-10T00:00:00+00:00, float: 1.0, symbol: :a>')
-    end
-  end
-end

data/spec/ig_markets/password_encryptor_spec.rb

@@ -1,23 +0,0 @@
-describe IGMarkets::PasswordEncryptor do
-  let(:encryptor) { IGMarkets::PasswordEncryptor.new }
-  let(:rsa_key_pair) { OpenSSL::PKey::RSA.new 2048 }
-
-  it 'can set its public key from an encoded public key' do
-    expect { encryptor.encoded_public_key = Base64.strict_encode64 rsa_key_pair.to_pem }.not_to raise_error
-  end
-
-  it 'can encrypt a password' do
-    password = 'test'
-
-    encryptor.time_stamp = '1000'
-    encryptor.public_key = rsa_key_pair
-
-    encoded_encrypted_password = encryptor.encrypt password
-
-    decoded_encrypted_password = Base64.strict_decode64 encoded_encrypted_password
-    encoded_decrypted_password = rsa_key_pair.private_decrypt decoded_encrypted_password
-    decoded_decrypted_password = Base64.strict_decode64 encoded_decrypted_password
-
-    expect(decoded_decrypted_password).to eq("#{password}|#{encryptor.time_stamp}")
-  end
-end

data/spec/ig_markets/payload_formatter_spec.rb

@@ -1,19 +0,0 @@
-describe IGMarkets::PayloadFormatter do
-  class PayloadModel < IGMarkets::Model
-    attribute :the_string
-    attribute :the_symbol, Symbol, allowed_values: [:two_three]
-    attribute :the_date, DateTime, format: '%Y/%m/%d'
-  end
-
-  it 'formats payloads correctly' do
-    model = PayloadModel.new the_string: 'string', the_symbol: :two_three, the_date: '2010/10/20'
-
-    expect(IGMarkets::PayloadFormatter.format(model)).to eq(
-      theString: 'string', theSymbol: 'TWO_THREE', theDate: '2010/10/20')
-  end
-
-  it 'camel cases snake case strings' do
-    expect(IGMarkets::PayloadFormatter.snake_case_to_camel_case('one')).to eq(:one)
-    expect(IGMarkets::PayloadFormatter.snake_case_to_camel_case('one_two_three')).to eq(:oneTwoThree)
-  end
-end

data/spec/ig_markets/position_spec.rb

@@ -1,37 +0,0 @@
-describe IGMarkets::Position do
-  let(:profitable_position) do
-    market = build :market_overview, bid: 4.0, lot_size: 3, scaling_factor: 5
-    build :position, currency: 'USD', level: 1.0, direction: :buy, size: 2, market: market
-  end
-  let(:unprofitable_position) do
-    market = build :market_overview, offer: 4.0, lot_size: 3, scaling_factor: 5
-    build :position, currency: 'USD', level: 1.0, direction: :sell, size: 2, market: market
-  end
-
-  it 'knows if it has a trailing stop' do
-    expect(build(:position).trailing_stop?).to be false
-    expect(build(:position, trailing_step: 1, trailing_stop_distance: 10).trailing_stop?).to be true
-  end
-
-  it 'calculates correct price deltas' do
-    expect(profitable_position.price_delta).to eq(3.0)
-    expect(unprofitable_position.price_delta).to eq(-3.0)
-    expect(profitable_position.profitable?).to be true
-    expect(unprofitable_position.profitable?).to be false
-  end
-
-  it 'calculates correct profit/loss amounts' do
-    expect(profitable_position.profit_loss).to eq(90)
-    expect(unprofitable_position.profit_loss).to eq(-90)
-  end
-
-  it 'correctly formats profit/loss amounts' do
-    expect(profitable_position.formatted_profit_loss).to eq('USD 90.00')
-    expect(unprofitable_position.formatted_profit_loss).to eq('USD -90.00')
-  end
-
-  it 'correctly formats position size' do
-    expect(profitable_position.formatted_size).to eq('+2')
-    expect(unprofitable_position.formatted_size).to eq('-2')
-  end
-end

data/spec/ig_markets/response_parser_spec.rb

@@ -1,13 +0,0 @@
-describe IGMarkets::ResponseParser do
-  it 'snake cases camel case keys' do
-    parsed = IGMarkets::ResponseParser.parse(update: 1, updateTime: 1, updateTimeUTC: 1, updateUTCTime: 1)
-
-    expect(parsed).to eq(update: 1, update_time: 1, update_time_utc: 1, update_utc_time: 1)
-  end
-
-  it 'parses arrays' do
-    parsed = IGMarkets::ResponseParser.parse([{ aB: 1 }, { cD: 2 }])
-
-    expect(parsed).to eq([{ a_b: 1 }, { c_d: 2 }])
-  end
-end

data/spec/ig_markets/session_spec.rb

@@ -1,134 +0,0 @@
-describe IGMarkets::Session do
-  let(:response) { instance_double 'RestClient::Response' }
-  let(:rest_client) { RestClient::Request }
-
-  context 'a non-signed in session' do
-    let(:session) do
-      IGMarkets::Session.new.tap do |session|
-        session.username = 'username'
-        session.password = 'password'
-        session.api_key = 'api_key'
-        session.platform = :production
-      end
-    end
-
-    it 'is not alive' do
-      expect(session.alive?).to eq(false)
-    end
-
-    it 'can sign in' do
-      expect(response).to receive(:code).exactly(4).times.and_return(200)
-      expect(response).to receive(:headers).and_return(cst: '1', x_security_token: '2')
-      expect(response).to receive(:body).twice.and_return(
-        { encryptionKey: Base64.strict_encode64(OpenSSL::PKey::RSA.new(256).to_pem), timeStamp: '1000' }.to_json,
-        {}.to_json
-      )
-      expect(rest_client).to receive(:execute).twice.and_return(response)
-
-      expect(session.sign_in).to eq(nil)
-
-      expect(session.cst).to eq('1')
-      expect(session.x_security_token).to match('2')
-      expect(session.alive?).to eq(true)
-    end
-
-    it 'fails to sign in when required attributes are missing' do
-      %i(username password api_key platform).each do |attribute|
-        session.send "#{attribute}=", nil
-        expect { session.sign_in }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  context 'a signed in session' do
-    let(:session) do
-      IGMarkets::Session.new.tap do |s|
-        s.instance_variable_set :@cst, 'cst'
-        s.instance_variable_set :@x_security_token, 'x_security_token'
-        s.instance_variable_set :@api_key, 'api_key'
-        s.instance_variable_set :@platform, :production
-      end
-    end
-
-    it 'is alive' do
-      expect(session.alive?).to eq(true)
-    end
-
-    it 'passes correct details for a post request' do
-      expect(response).to receive_messages(code: 200, body: { ids: [1, 2] }.to_json)
-      expect(rest_client).to receive(:execute).with(params(:post, 'url', id: 1)).and_return(response)
-      expect(session.post('url', { id: 1 }, IGMarkets::API_V1)).to eq(ids: [1, 2])
-    end
-
-    it 'can sign out' do
-      expect(response).to receive_messages(code: 200, body: {}.to_json)
-      expect(rest_client).to receive(:execute).with(params(:delete, 'session')).and_return(response)
-      expect(session.sign_out).to eq(nil)
-      expect(session.alive?).to eq(false)
-    end
-
-    it 'fails when the HTTP response is not 200' do
-      expect(response).to receive_messages(code: 404, body: { errorCode: '1' }.to_json)
-      expect(rest_client).to receive(:execute).with(params(:get, 'url')).and_raise(RestClient::Exception, response)
-      expect { session.get('url', IGMarkets::API_V1) }.to raise_error do |error|
-        expect(error).to be_a(IGMarkets::RequestFailedError)
-        expect(error.error).to eq('1')
-        expect(error.http_code).to eq(404)
-      end
-    end
-
-    it 'handles when the HTTP response is not JSON' do
-      expect(response).to receive_messages(code: 404, body: 'not_valid_json')
-      expect(rest_client).to receive(:execute).with(params(:get, 'url')).and_raise(RestClient::Exception, response)
-      expect { session.get('url', IGMarkets::API_V1) }.to raise_error(IGMarkets::RequestFailedError)
-    end
-
-    it 'converts a SocketError into a RequestFailedError' do
-      expect(rest_client).to receive(:execute).with(params(:get, 'url')).and_raise(SocketError)
-      expect { session.get('url', IGMarkets::API_V1) }.to raise_error(IGMarkets::RequestFailedError)
-    end
-
-    it 'converts a RestClient::Exception that has no response into a RequestFailedError' do
-      expect(rest_client).to receive(:execute).with(params(:get, 'url')).and_raise(RestClient::Exception)
-      expect { session.get('url', IGMarkets::API_V1) }.to raise_error(IGMarkets::RequestFailedError)
-    end
-
-    it 'can process a PUT request' do
-      expect(response).to receive_messages(code: 200, body: '')
-      expect(rest_client).to receive(:execute).with(params(:put, 'url', id: 1)).and_return(response)
-      expect(session.put('url', { id: 1 }, IGMarkets::API_V1)).to eq({})
-    end
-
-    it 'can process a DELETE request with a payload' do
-      execute_params = params :post, 'url', id: 1
-      execute_params[:headers]['_method'] = :delete
-
-      expect(response).to receive_messages(code: 204, body: '')
-      expect(rest_client).to receive(:execute).with(execute_params).and_return(response)
-      expect(session.delete('url', { id: 1 }, IGMarkets::API_V1)).to eq({})
-    end
-
-    it 'inspects correctly' do
-      expect(session.inspect).to eq('#<IGMarkets::Session cst, x_security_token>')
-    end
-
-    def headers
-      hash = {}
-      hash[:accept] = hash[:content_type] = 'application/json; charset=UTF-8'
-      hash[:version] = 1
-      hash[:cst] = 'cst'
-      hash[:x_security_token] = 'x_security_token'
-      hash[:'X-IG-API-KEY'] = 'api_key'
-      hash
-    end
-
-    def params(method, url, payload = nil)
-      hash = {}
-      hash[:method] = method
-      hash[:url] = "https://api.ig.com/gateway/deal/#{url}"
-      hash[:headers] = headers
-      hash[:payload] = payload && payload.to_json
-      hash
-    end
-  end
-end