betfair_api_ng_rails 1.1.0 → 2.1.0

data/spec/lib/betfair_api_ng_rails/api/caching/response_cache_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Caching::ResponseCache do
+
+  let(:method) { :method }
+  let(:params) { :params }
+
+  subject(:cache) { described_class.new(method, params) }
+
+  before { allow_any_instance_of(described_class).to receive(:createsig).with(:params).and_return :sig_params }
+
+  describe ".redis_connection" do
+    
+    it "initializes connection to redis" do
+      expect(Redis).to receive :new
+      described_class.redis_connection
+    end
+
+  end
+
+  describe "#is_cached?" do
+    
+    before { expect(cache).to receive(:cache_result).and_return(cache_result) }
+
+    context 'when cache result returns item' do
+      
+      let(:cache_result) { double }
+
+      its(:is_cached?) { is_expected.to be_truthy }
+
+    end
+
+    context 'when cache result returns no item' do
+      
+      let(:cache_result) { nil }
+
+      its(:is_cached?) { is_expected.to be_falsey }
+
+    end
+
+  end
+
+  describe "#responser" do
+    
+    before { expect(cache).to receive(:prepare_response).and_return :response }
+
+    it "returns http responser with cached info" do
+      expect(BetfairApiNgRails::Api::Http::Responser).to receive(:new).with(:response)
+      cache.responser
+    end
+
+  end
+
+  describe "#cache!" do
+    
+    let(:response) { { some: :key } }
+    let(:cache_adapter) { double(:cache_adapter) }
+
+    before do
+      allow(cache).to receive(:cache_adapter).and_return cache_adapter
+      expect(cache).to receive(:expire_time).and_return 5
+    end
+
+    it "saves response in cache" do
+      expect(cache_adapter).to receive(:set).with("betfair_api_ng_rails:method:sig_params", "{\"some\":\"key\"}")
+      expect(cache_adapter).to receive(:expire).with("betfair_api_ng_rails:method:sig_params", 5)
+      cache.cache! response
+    end
+
+  end
+
+  context 'private method' do
+    
+    describe "#cache_result" do
+
+      let(:cache_adapter) { double(:cache_adapter) }
+
+      before { expect(cache).to receive(:cache_adapter).and_return cache_adapter }
+
+      it "returns result from cache" do
+        expect(cache_adapter).to receive(:get).with("betfair_api_ng_rails:method:sig_params")
+        cache.send :cache_result
+      end
+
+    end
+
+    describe "#prepare_response" do
+      
+      before { allow(cache).to receive(:cache_result).and_return :result }
+
+      subject(:response) { cache.send(:prepare_response) }
+
+      it { is_expected.to respond_to(:body) }
+
+      it { is_expected.to respond_to(:code) }
+
+      its(:body) { is_expected.to eq :result }
+
+      its(:code) { is_expected.to eq '200' }
+
+    end
+
+    describe "#expire_time" do
+      
+      it "returns time from config" do
+        expect(BetfairApiNgRails).to receive_message_chain(:config, :cache_expire).and_return 4
+        expect(cache.send(:expire_time)).to eq 4
+      end
+
+    end
+
+    describe "#cache_adapter" do
+      
+      #it "returns redis connection" do
+        #expect(cache).to receive_message_chain(:class, :redis_connection)
+        #cache.send :cache_adapter
+      #end
+
+    end
+
+    describe "#cache_key" do
+      
+      it "returns proper key for cache" do
+        expect(cache.send(:cache_key)).to eq "betfair_api_ng_rails:method:sig_params"
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Config do
+  subject(:config) { described_class }
+
+  it { is_expected.to have_attr_accessor :application_key }
+  it { is_expected.to have_attr_accessor :ssl_key_filepath }
+  it { is_expected.to have_attr_accessor :ssl_crt_filepath }
+  it { is_expected.to have_attr_accessor :username }
+  it { is_expected.to have_attr_accessor :password }
+  it { is_expected.to have_attr_accessor :locale }
+  it { is_expected.to have_attr_accessor :formatter }
+  it { is_expected.to have_attr_accessor :keep_alive_session }
+  it { is_expected.to have_attr_accessor :use_cache }
+  it { is_expected.to have_attr_accessor :cache_expire }
+  it { is_expected.to have_attr_accessor :proxy_url }
+  it { is_expected.to have_attr_accessor :proxy_enable }
+  it { is_expected.to have_attr_accessor :go_localuser }
+  it { is_expected.to have_attr_accessor :go_filename }
+  it { is_expected.to have_attr_accessor :endpoint }
+
+  describe ".load_for_environment" do
+    let(:path)   { "path" }
+    let(:opts)   { [:opt1] }
+    let(:config_hash) { {'env' => { 'opt1' => :val1 }} }
+
+    before do
+      stub_const("BetfairApiNgRails::Api::Constants::LOADABLE_CONFIG_OPTIONS", opts)
+      allow(YAML).to receive(:load_file).with(path).and_return config_hash
+    end
+
+    it "loads config from file and apply it" do
+      expect(config).to receive('opt1=').with(:val1)
+      config.load_for_environment path, 'env'
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Connection do
+  subject(:connection) { described_class.new(acc_name) }
+
+  let(:acc_name) { 'user001' }
+  let(:asm) { double(:account_session_manager) }
+  let(:account) { BetfairApiNgRails::Account.new(acc_name, 'pass', 'nfl43n7fg834', 'crt', 'key') }
+  let(:logger)   { double(:logger) }
+
+  before do
+    allow(BetfairApiNgRails).to receive(:account_session_manager).and_return asm
+    BetfairApiNgRails.log = logger
+    allow(logger).to receive(:write)
+  end
+
+  describe "#request" do
+    let(:provider) { double(:provider) }
+    let(:parser)   { double(:parser, process: true) }
+    let(:response) { double(:response, result: "") }
+
+    before(:each) do
+      expect(subject).to receive(:init_parser).and_return parser
+    end
+
+    it "calls provider's fetch method" do
+      expect(subject).to receive(:provider).and_return provider
+      expect(provider).to receive(:fetch).and_return response
+      expect(response).to receive(:has_error?).and_return false
+      allow(subject).to receive(:hashing).with({}).and_return({})
+      subject.request 'method'
+    end
+  end
+
+  context "protected methods" do
+    describe "#expire_provider" do
+      it "resets account's ssoid" do
+        allow(connection).to receive(:account).and_return account
+        expect(connection.session_manager).to receive(:expire_ssoid).with(account)
+        connection.send :expire_provider
+      end
+    end
+
+    describe "#provider" do
+      let(:ssoid) { double(:ssoid) }
+      let(:app_key) { 'af2f23f23' }
+
+      before do
+        allow(subject).to receive(:app_key).and_return app_key
+      end
+
+      it "inits new provider" do
+        expect(BetfairApiNgRails::Api::Provider).to receive(:new).with ssoid, app_key
+        expect(subject).to receive(:request_ssoid).and_return ssoid
+        subject.send(:provider)
+      end
+    end
+
+    describe "#request_ssoid" do
+      before do
+        allow(connection).to receive(:account).and_return account
+      end
+
+      it "requests new ssoid for new connection" do
+        expect(connection.session_manager).to receive(:get_ssoid).with(account)
+        subject.send(:request_ssoid)
+      end
+    end
+
+    describe "#hashing" do
+      let(:hashalator) { double(:hashalator) }
+      let(:params) { double(:params) }
+
+      it "hashalators params" do
+        expect(BetfairApiNgRails::Api::Hashalator).to receive(:new).with(params).and_return hashalator
+        expect(hashalator).to receive(:to_hash)
+        subject.send :hashing, params
+      end
+    end
+
+    describe '#account' do
+      context 'when it is found' do
+        it 'returns this one' do
+          expect(BetfairApiNgRails).to receive_message_chain(:account_manager, :get).and_return double(:acc, username: :user001)
+          connection.send :account
+        end
+      end
+
+      context 'when it is not found' do
+        it 'raises error' do
+          expect{
+            expect(BetfairApiNgRails).to receive_message_chain(:account_manager, :get).and_return(nil)
+            connection.send :account
+          }.to raise_error(BetfairApiNgRails::NoAccountProvided)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::AccountStatementReport do
+  include_examples 'data model', DataModelsYamlLoader.new.fetch('accountStatementReport') do
+
+    describe "account statements association" do
+      its(:account_statement) { is_expected.to be_kind_of Array }
+    end
+  end
+end
+

data/spec/{betfair_api_ng_rails → lib/betfair_api_ng_rails}/api/data/concerns/hashable_spec.rb

@@ -16,85 +16,72 @@ class TestClass
 end
 
 describe BetfairApiNgRails::Api::Data::Concerns::Hashable do
-  
   subject { TestClass.new }
 
   describe "#to_hash" do
-    
     let(:attributes) { double(:attributes) }
     let(:hashalator) { double(:hashalator) }
 
     it "returns Hashalator's to_hash result" do
       expect(subject).to receive(:attributes_hash).and_return attributes
-      expect(BetfairApiNgRails::Api::Hashalator).to receive(:new).with(attributes).and_return hashalator
+      expect(BetfairApiNgRails::Api::Hashalator).to receive(:new).with(attributes, false).and_return hashalator
       expect(hashalator).to receive(:to_hash)
       subject.to_hash
     end
+  end
+
+  describe "#to_param" do
+    let(:attributes) { double(:attributes) }
+    let(:hashalator) { double(:hashalator) }
 
+    it "returns Hashalator's to_hash result" do
+      expect(subject).to receive(:attributes_hash).and_return attributes
+      expect(BetfairApiNgRails::Api::Hashalator).to receive(:new).with(attributes, true).and_return hashalator
+      expect(hashalator).to receive(:to_hash)
+      subject.to_param
+    end
   end
 
   describe "private method" do
-    
     describe "#attributes_hash" do
-      
       context "returns hash represantation of attributes and its values" do
-
         its(:attributes_hash) { is_expected.to eq({:name => 'Walli'}) }
-
       end
-
     end
 
     describe "#get_attr_value" do
-      
       it "returns attribute value by its name" do
         expect(subject.send(:get_attr_value, :name)).to eq 'Walli'
       end
-
     end
 
     describe "#get_attr_key" do
-      
       subject { TestClass.new.send :get_attr_key, attrib }
 
       context 'when passed Hash' do
-      
         let(:attrib) { {some_attr: { type: String }} }
 
         context 'returns first key' do
-          
           it { is_expected.to eq :some_attr }
-
         end
-
-      end 
+      end
 
       context 'when passed single value' do
-        
         let(:attrib) { :some_attr }
 
         context 'returns it' do
-          
           it { is_expected.to eq :some_attr }
-
         end
-
       end
-
     end
-
   end
 
   describe "integration tests" do
-    
     context "returns hash represention of TestClass instance" do
-
       its(:to_hash) { is_expected.to eq({'name' => 'Walli'}) }
-
     end
 
     context 'dont include nil attributes in resulting hash' do
-      
       before(:each) do
         subject.class.send :instance_eval, <<-CODE
           attr_accessor :second_name
@@ -103,11 +90,10 @@ describe BetfairApiNgRails::Api::Data::Concerns::Hashable do
       end
 
       its(:to_hash) { is_expected.to eq({'name' => 'Walli'}) }
-
+      its(:to_param) { is_expected.to eq({name: 'Walli'}) }
     end
 
     context 'when exists attr with additional options' do
-      
       before(:each) do
         subject.class.send :instance_eval, <<-CODE
           attr_accessor :second_name
@@ -117,9 +103,7 @@ describe BetfairApiNgRails::Api::Data::Concerns::Hashable do
       end
 
       its(:to_hash) { is_expected.to eq({'name' => 'Walli', 'secondName' => 'Black'}) }
-
+      its(:to_param) { is_expected.to eq({name: 'Walli', second_name: 'Black'}) }
     end
-
   end
-
-end
+end

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

@@ -1,15 +1,10 @@
 require 'spec_helper'
 
 describe BetfairApiNgRails::MarketBook do
-  
   include_examples 'data model', DataModelsYamlLoader.new.fetch('marketBook') do
 
     describe "runners association" do
-      
       its(:runners) { is_expected.to be_kind_of Array }
-
     end
-
   end
-
-end
+end