betfair_api_ng_rails 0.0.8 → 1.0.0

data/lib/betfair_api_ng_rails/api/session_manager.rb

@@ -0,0 +1,54 @@
+require 'betfair_api_ng_rails/api/concerns/errorable'
+
+module BetfairApiNgRails
+  module Api
+    class SessionManager
+      class << self
+        include Api::Concerns::Errorable
+        include Api::Constants
+
+        def ssoid
+          @ssoid ||= fetch_ssoid
+        end
+
+        def request_ssoid
+          ssoid
+          !has_errors?
+        end
+
+        def expire_ssoid
+          @ssoid = nil
+        end
+
+        def new_ssoid
+          expire_ssoid
+          ssoid
+        end
+
+      private
+
+        def fetch_ssoid
+          get_login_response.session_token.tap { |sid| send_keep_alive(sid) }
+        end
+
+        def get_login_response
+          http_requester.do_request
+        end
+
+        def send_keep_alive(sid)
+          return unless Api::Config.keep_alive_session
+          keep_alive_requester(sid).do_request
+        end
+
+        def http_requester
+          @_http_requester ||= Api::Http::Factory.session_requester
+        end
+
+        def keep_alive_requester(sid)
+          Api::Http::Factory.keep_alive_requester sid
+        end
+
+      end
+    end
+  end
+end

data/lib/betfair_api_ng_rails/errors.rb

@@ -0,0 +1,6 @@
+module BetfairApiNgRails
+  
+  class NoConnectionError < ::StandardError
+  end
+
+end

data/lib/betfair_api_ng_rails/railtie.rb

@@ -0,0 +1,7 @@
+module BetfairApiNgRails
+  class Railtie < Rails::Railtie
+    config.after_initialize do
+      BetfairApiNgRails.connection = BetfairApiNgRails::Api::Connection.new
+    end
+  end
+end

data/lib/betfair_api_ng_rails/version.rb

@@ -1,3 +1,3 @@
 module BetfairApiNgRails
-  VERSION = "0.0.8"
+  VERSION = "1.0.0"
 end

data/lib/generators/betfair_api_ng_rails/install/templates/betfair_api_ng_rails.rb

@@ -3,14 +3,16 @@ BetfairApiNgRails.config do |config|
 
   load_config = YAML.load_file("#{Rails.root}/config/betfair_api_ng_rails.yml")[Rails.env]
 
-  config.application_key  = load_config['application_key']
-  config.ssl_key_filepath = "#{Rails.root}/public/client-2048.key"
-  config.ssl_crt_filepath = "#{Rails.root}/public/client-2048.crt"
-  config.login_url        = load_config['login_url']
-  config.api_url          = load_config['api_url']
-  config.username         = load_config['username']
-  config.password         = load_config['password']
-  config.locale           = :ru
-  config.formatter        = nil #out of box available formatter for JsTree
+  config.application_key    = load_config['application_key']
+  config.ssl_key_filepath   = "#{Rails.root}/public/client-2048.key"
+  config.ssl_crt_filepath   = "#{Rails.root}/public/client-2048.crt"
+  config.login_url          = load_config['login_url']
+  config.api_url            = load_config['api_url']
+  config.keep_alive_url     = load_config['keep_alive_url']
+  config.username           = load_config['username']
+  config.password           = load_config['password']
+  config.locale             = :ru
+  config.formatter          = nil #out of box available formatter for JsTree
+  config.keep_alive_session = true
 
 end

data/lib/generators/betfair_api_ng_rails/install/templates/betfair_api_ng_rails.yml

@@ -2,6 +2,7 @@ development:
   application_key: YOUR_APP_KEY
   login_url: https://identitysso.betfair.com/api/certlogin
   api_url: https://api-ng.betstores.com/betting/betfair/services/api.betfair.com/exchange/betting/json-rpc/v1
+  keep_alive_url: https://identitysso.betfair.com/api/keepAlive
   username: YOUR_ACCOUNT_USERNAME
   password: YOUR_ACCOUNT_PASSWORD
 
@@ -9,5 +10,6 @@ production:
   application_key: YOUR_APP_KEY
   login_url: https://identitysso.betfair.com/api/certlogin
   api_url: https://api-ng.betstores.com/betting/betfair/services/api.betfair.com/exchange/betting/json-rpc/v1
+  keep_alive_url: https://identitysso.betfair.com/api/keepAlive
   username: YOUR_ACCOUNT_USERNAME
   password: YOUR_ACCOUNT_PASSWORD

data/spec/betfair_api_ng_rails/api/connection_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Connection do
+  
+  subject { described_class.new }
+
+  describe "#initialize" do
+    
+    it "requests session identifier" do
+      expect_any_instance_of(described_class).to receive(:request_ssoid)
+      described_class.new
+    end
+
+  end
+
+  describe "#request" do
+    
+    let(:provider) { double(:provider) }
+    let(:parser)   { double(:parser, process: true) }
+
+    before(:each) do 
+      expect_any_instance_of(described_class).to receive(:request_ssoid) 
+      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).with(method: 'method', params: {})
+      expect(subject).to receive(:hashing).with({}).and_return({})
+      subject.request 'method'
+    end
+
+  end
+
+  describe "private method" do
+
+    describe "#provider" do
+      
+      before(:each) { expect_any_instance_of(described_class).to receive(:request_ssoid) }
+
+      it "inits new provider" do
+        expect(BetfairApiNgRails::Api::Provider).to receive(:new)
+        subject.send(:provider)
+      end
+
+    end
+
+    describe "#request_ssoid" do
+      
+      it "requests new ssoid for new connection" do
+        expect(BetfairApiNgRails::Api::SessionManager).to receive(:new_ssoid).at_least(:once)
+        subject.send(:request_ssoid)
+      end
+
+    end
+
+    describe "#hashing" do
+      
+      let(:hashalator) { double(:hashalator) }
+      let(:params) { double(:params) }
+
+      before(:each) { expect_any_instance_of(described_class).to receive(:request_ssoid) }
+
+      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
+
+  end
+
+end

data/spec/betfair_api_ng_rails/api/data/concerns/hashable_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+class TestClass
+  include BetfairApiNgRails::Api::Data::Concerns::Hashable
+
+  attr_accessor :name
+
+  def initialize()
+    @name = 'Walli'
+  end
+
+  def self.to_hash_attrs
+    [:name]
+  end
+
+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(hashalator).to receive(:to_hash)
+      subject.to_hash
+    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
+
+  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
+          def self.to_hash_attrs; [:name, :second_name]; end
+        CODE
+      end
+
+      its(:to_hash) { is_expected.to eq({'name' => 'Walli'}) }
+
+    end
+
+  end
+
+end

data/spec/betfair_api_ng_rails/api/formatters/js_tree_formatter_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Formatters::JsTreeFormatter do
+  
+  subject { described_class.new }
+
+  describe "#process" do
+    
+    let(:record) { double(:record) }
+
+    it "formats each resource record" do
+      expect(subject).to receive(:format_record).with(record, :some_request)
+      subject.process([record], as: 'listSomeRequest')
+    end
+
+  end
+
+  describe "private method" do
+    
+    describe "#resource_from_method" do
+      
+      it "returns proper resource name" do
+        expect(subject.send(:resource_from_method, 'listEventTypes')).to eq :event_types
+      end
+
+    end
+
+    describe "#format_record" do
+      
+      context 'when passed nil record' do
+        
+        it "returns empty hash" do
+          expect(subject.send(:format_record, nil, 'resource')).to eq({})
+        end
+
+      end
+
+      context 'when passed valid params for formatting' do
+        
+        let(:resource) { double(:resource, id: 1, name: 'name', to_hash: true) }
+        let(:record) { double(:record, some_resource: resource) }
+
+        subject { described_class.new.send(:format_record, record, :some_resources) }
+
+        its([:id]) { is_expected.to eq(1) }
+        its([:text]) { is_expected.to eq('name') }
+
+        context 'and resource allow children' do
+          
+          before { stub_const("BetfairApiNgRails::Api::Formatters::JsTreeFormatter::ALLOW_CHILDREN", [:some_resources]) }
+
+          its([:children]) { is_expected.to eq(true) }
+
+        end
+
+        context 'and resource not allow children' do
+          
+          before { stub_const("BetfairApiNgRails::Api::Formatters::JsTreeFormatter::ALLOW_CHILDREN", []) }
+
+          its([:children]) { is_expected.to eq(false) }
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/betfair_api_ng_rails/api/hashalator_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe BetfairApiNgRails::Api::Hashalator do
+  
+  let(:hashable) { { some_key: :some_value } }
+
+  subject { described_class.new(hashable) }
+
+  its(:hashable) { is_expected.to eq hashable }
+
+  describe "#to_hash" 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)
+      subject.to_hash
+    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'
+      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 }
+
+    context 'when only simple values passed' do
+      
+      let(:hashable) { { some_key: :some_value } }
+
+      it { is_expected.to eq({'someKey' => :some_value}) }
+
+    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
+
+  end
+
+end