betfair_api_ng_rails 1.1.0 → 2.1.0

data/spec/lib/betfair_api_ng_rails/api/data/statement_item_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::StatementItem do
+  include_examples 'data model', DataModelsYamlLoader.new.fetch('statementItem') do
+    describe 'legacy data association' do
+      its(:legacy_data) { is_expected.to be_kind_of BetfairApiNgRails::StatementLegacyData }
+    end
+  end
+end

data/spec/lib/betfair_api_ng_rails/api/data/statement_legacy_data_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::StatementLegacyData do
+  include_examples 'data model', DataModelsYamlLoader.new.fetch('statementLegacyData')
+end
+

data/spec/{betfair_api_ng_rails → lib/betfair_api_ng_rails}/api/data/time_range_spec.rb

@@ -1,7 +1,5 @@
 require 'spec_helper'
 
 describe BetfairApiNgRails::TimeRange do
-  
   include_examples 'data model', DataModelsYamlLoader.new.fetch('timeRange')
-
-end
+end

data/spec/lib/betfair_api_ng_rails/api/endpoint_factory_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::EndpointFactory do
+  subject(:factory) { described_class }
+
+  context 'when passed value associated with existing endpoint' do
+    context 'when symbol is passed' do
+      subject(:endpoint) { factory.call(:uk) }
+
+      it { is_expected.to be_kind_of(BetfairApiNgRails::Api::Endpoints::Uk) }
+    end
+
+    context 'when class is passed' do
+      subject(:endpoint) { factory.call(BetfairApiNgRails::Api::Endpoints::Italian) }
+
+      it { is_expected.to be_kind_of(BetfairApiNgRails::Api::Endpoints::Italian) }
+    end
+  end
+
+  context 'when passed value associated with unexisting endpoint' do
+    it 'raises InvalidEndpointError' do
+      expect{
+        factory.call(:unxisted_endpoint)
+      }.to raise_error(BetfairApiNgRails::Api::InvalidEndpointError)
+    end
+  end
+end

data/spec/lib/betfair_api_ng_rails/api/endpoints/australian_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Endpoints::Australian do
+  include_examples 'base endpoint'
+  include_examples 'concrete endpoint', 'api-au.betfair.com', 'identitysso.betfair.com'
+end

data/spec/lib/betfair_api_ng_rails/api/endpoints/base_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Endpoints::Base do
+  include_examples 'base endpoint'
+end

data/spec/lib/betfair_api_ng_rails/api/endpoints/italian_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Endpoints::Italian do
+  include_examples 'base endpoint'
+  include_examples 'concrete endpoint', 'api.betfair.com', 'identitysso.betfair.it'
+end

data/spec/lib/betfair_api_ng_rails/api/endpoints/spanish_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Endpoints::Spanish do
+  include_examples 'base endpoint'
+  include_examples 'concrete endpoint', 'api.betfair.com', 'identitysso.betfair.es'
+end
+

data/spec/lib/betfair_api_ng_rails/api/endpoints/uk_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Endpoints::Uk do
+  include_examples 'base endpoint'
+  include_examples 'concrete endpoint', "api.betfair.com", "identitysso.betfair.com"
+end

data/spec/{betfair_api_ng_rails → lib/betfair_api_ng_rails}/api/hashalator_spec.rb

@@ -1,17 +1,16 @@
 require 'spec_helper'
 
 describe BetfairApiNgRails::Api::Hashalator do
-  
   let(:hashable) { { some_key: :some_value } }
 
-  subject { described_class.new(hashable) }
+  subject { described_class.new(hashable, for_param) }
+
+  let(:for_param) { false }
 
   its(:hashable) { is_expected.to eq hashable }
 
   describe "#to_hash" do
-
     context 'when value isn\'t blank or nil' do
-    
       it "iterates though elements and process they" do
         expect(subject).to receive(:hash_key).at_least(:once)
         expect(subject).to receive(:hash_value).at_least(:once).and_return double
@@ -19,158 +18,140 @@ describe BetfairApiNgRails::Api::Hashalator do
       end
 
     end
-    
-    context 'when else' do
 
+    context 'when else' do
       it "does include it result hash" do
         expect(subject).to receive(:hash_key).exactly(0).times
         expect(subject).to receive(:hash_value).at_least(:once)
         subject.to_hash
       end
-      
     end
-
   end
 
   describe "private method" do
-    
     describe "#hashing_val" do
-      
       let(:el) { double(:el) }
 
       context 'when array passed' do
-
         let(:array) { [el] }
 
         it "calls hash_value on each element" do
           expect(subject).to receive(:hash_value).with(el)
           subject.send :hashing_val, array
         end
-
       end
 
       context 'when single value passed' do
-        
         it "calls to_hash on it" do
           expect(el).to receive(:to_hash)
           subject.send :hashing_val, el
         end
-
       end
-
     end
 
     describe "#hash_key" do
-      
-      it "returns key for api request hash" do
-        expect(subject.send(:hash_key, :some_key)).to eq 'someKey'
+      context 'when not for param' do
+        it "returns key for api request hash" do
+          expect(subject.send(:hash_key, :some_key)).to eq 'someKey'
+        end
       end
 
+      context 'when for param' do
+        let(:for_param) { true }
+
+        it "returns key for api request hash" do
+          expect(subject.send(:hash_key, :some_key)).to eq :some_key
+        end
+      end
     end
 
     describe "#need_to_hash?" do
-    
       before { stub_const("BetfairApiNgRails::Api::Data::Constants::ATTRS_AS_IS", classes) }
 
       context 'when ATTRS_AS_IS include value class' do
-        
         let(:classes) { [String] }
 
         it "returns false" do
           expect(subject.send(:need_to_hash?, 'value')).to eq false
         end
-
       end
 
       context 'when ATTRS_AS_IS not include value class' do
-        
         let(:classes) { [String] }
 
         it "returns true" do
           expect(subject.send(:need_to_hash?, 1)).to eq true
         end
-
       end
-
     end
 
     describe "#hash_value" do
-      
       let(:value) { double(:value) }
 
       context 'when need to hashing value' do
-        
         before { expect(subject).to receive(:need_to_hash?).with(value).and_return(true) }
 
         it "calls to_hash on value" do
           expect(subject).to receive(:hashing_val).with(value)
           subject.send :hash_value, value
         end
-
       end
 
       context 'when dont need to hashing value' do
-        
         before { expect(subject).to receive(:need_to_hash?).with(value).and_return(false) }
 
         it "returns value" do
           expect(subject).to receive(:hashing_val).with(value).exactly(0).times
           subject.send :hash_value, value
         end
-
       end
-
     end
-
   end
 
   context 'integration tests' do
-    
-    subject { described_class.new(hashable).to_hash }
+    subject { described_class.new(hashable, for_param).to_hash }
+
+    let(:for_param) { false }
 
     context 'when only simple values passed' do
-      
       let(:hashable) { { some_key: :some_value } }
 
-      it { is_expected.to eq({'someKey' => :some_value}) }
+      context 'when not for param' do
+        it { is_expected.to eq({'someKey' => :some_value}) }
+      end
+
+      context 'when for param' do
+        let(:for_param) { true }
 
+        it { is_expected.to eq({:some_key => :some_value}) }
+      end
     end
 
     context 'when array with simple values passes' do
-      
       let(:hashable) { {some_key: [1, 2, 3]} }
 
       it { is_expected.to eq({'someKey' => [1, 2, 3]}) }
-
     end
 
     context 'when array with at least one complex value passes' do
-      
       let(:el) { double(:el) }
       let(:hashable) { {some_key: [el]} }
 
       before { expect(el).to receive(:to_hash).and_return(el) }
 
       it { is_expected.to eq({'someKey' => [el]}) }
-
     end
 
     context 'when one of values is blank' do
-      
       let(:hashable) { {some_key: ""} }
 
       it { is_expected.to eq({}) }
-
     end
 
     context 'when one of values is nil' do
-      
       let(:hashable) { {some_key: nil} }
 
       it { is_expected.to eq({}) }
-
     end
-
   end
-
-end
+end

data/spec/lib/betfair_api_ng_rails/api/http/factory_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Http::Factory do
+  let(:account) do
+    BetfairApiNgRails::Account.new(
+      'user001',
+      'password',
+      'app_key',
+      'crt_filepath',
+      'key_filepath'
+    )
+  end
+  let(:requester) { double(:requester) }
+
+  subject(:factory) { described_class }
+
+  before do
+    expect(factory).to receive(:create_http_requester)
+      .and_return(requester)
+  end
+
+  describe '.session_requester' do
+    it 'settings up requester for session' do
+      expect(requester).to receive(:set_ssl_files).with 'crt_filepath', 'key_filepath'
+      expect(requester).to receive(:set_request_headers)
+      expect(requester).to receive(:set_auth_headers).with 'app_key'
+      expect(requester).to receive(:set_form_data)
+        .with('username' => 'user001', 'password' => 'password')
+      factory.session_requester "https://login.url.com", account
+    end
+  end
+
+  describe '.provider_requester' do
+    it 'settings up requester for provider' do
+      expect(requester).to receive(:set_request_headers)
+      expect(requester).to receive(:set_auth_headers).with('app_key', 'some_ssoid')
+      factory.provider_requester 'api_url', 'some_ssoid', 'app_key'
+    end
+  end
+end

data/spec/lib/betfair_api_ng_rails/api/logs/console_logger_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Logs::ConsoleLogger do
+  
+  subject(:object) { described_class.new }
+
+  describe "#write" do
+    
+    let(:string) { "some content" }
+
+    it "puts content to console" do
+      expect(object).to receive(:puts).with "\e[0;32;49msome content\e[0m"
+      object.write string
+    end
+
+  end
+
+end

data/spec/lib/betfair_api_ng_rails/api/logs/file_logger_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Logs::FileLogger do
+  subject(:logger) { described_class.new(root, env) }
+
+  let(:root) { 'root_path_of_rails_app' }
+  let(:env)  { 'some_env' }
+
+  describe "#write" do
+    let(:file)   { double(:file) }
+    let(:string) { "some text" }
+
+    before do
+      expect(File).to receive(:open).and_yield file
+      expect(logger).to receive(:now_date).and_return 'now_date'
+    end
+
+    it "writes passed string to log file" do
+      expect(file).to receive(:puts).with("[now_date] - #{string}")
+      logger.write string
+    end
+  end
+
+  describe "private method" do
+    describe "#file_path" do
+      subject { logger.send(:file_path) }
+
+      it { is_expected.to include root }
+      it { is_expected.to include env }
+      it { is_expected.to eq "#{root}/log/betfair_api_ng_rails.#{env}.log" }
+    end
+  end
+end

data/spec/lib/betfair_api_ng_rails/api/provider_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Provider do
+  let(:ssoid) { double(:ssoid) }
+  let(:application_key) { '2ef8783ofno34fn' }
+
+  subject { described_class.new(ssoid, application_key) }
+
+  its(:ssoid) { is_expected.to eq ssoid }
+
+  describe "#fetch" do
+    let(:method) { double(:method, allowed?: method_allowed, name: 'someMethod') }
+
+    context 'when method isn\'t allowed' do
+      let(:method_allowed) { false }
+
+      it "raises error" do
+        expect{ subject.fetch(method: method) }.to raise_error
+      end
+    end
+
+    context 'when requested method is allowed' do
+      let(:method_allowed) { true }
+
+      it "calls run_request" do
+        expect(subject).to receive(:run_request).with(for_method: method, params: {})
+        subject.fetch method: method
+      end
+    end
+  end
+
+  describe "private method" do
+    describe "#run_request" do
+      let(:http_requester) { double(:http_requester) }
+      let(:method) { double(:method, api_url: 'api_url') }
+
+      before { expect(subject).to receive(:http_requester).at_least(:once).and_return(http_requester) }
+
+      it "runs http requster" do
+        expect(http_requester).to receive(:set_api_req_body).with(method, {})
+        expect(http_requester).to receive(:do_request)
+        subject.send :run_request, for_method: method, params: {}
+      end
+    end
+
+    describe "#http_requester" do
+      it "initalizes provider http request" do
+        expect(BetfairApiNgRails::Api::Http::Factory).to receive(:provider_requester).with 'api_url', ssoid, application_key
+        subject.send :http_requester, 'api_url'
+      end
+    end
+  end
+end