backpack_tf 0.2.1 → 0.5.0

data/spec/backpack_tf/client_spec.rb

@@ -2,74 +2,125 @@ require 'spec_helper'
 
 module BackpackTF
   describe 'Client' do
-    context 'The Client class' do
-  
-      it 'has these default options' do
-        ans = { base_uri: 'http://backpack.tf/api', timeout: 5 }
-        ans[:default_params] = { key: ENV[Client.env_var] }
-        expect(Client.default_options).to eq ans
+    let(:bp) { Client.new }
+
+    it 'has these default options' do
+      ans = { base_uri: 'http://backpack.tf/api', timeout: 5 }
+      ans[:default_params] = { key: ENV[Client.env_var] }
+      expect(Client.default_options).to eq ans
+    end
+
+    describe '::api_key' do
+      it 'Raises ArgumentError, if key is not a hexadecimal string' do
+        fake_key = 'abcdefghijklmnopqrstuvwx'
+        expect{Client.api_key(fake_key)}.to raise_error ArgumentError
+      end
+      it 'Raises ArgumentError, if key is not 24 digits long' do
+        fake_key = 'abcdef0987654321'
+        expect{Client.api_key(fake_key)}.to raise_error ArgumentError
+      end
+      it 'lets an otherwise theoretically-valid key, pass through' do
+        key = generate_fake_api_key
+        expect(Client.api_key(key)).to eq key
       end
+    end
 
-      describe '::api_key' do
-        it 'Raises ArgumentError, if key is not a hexadecimal string' do
-          fake_key = 'abcdefghijklmnopqrstuvwx'
-          expect{Client.api_key(fake_key)}.to raise_error ArgumentError
-        end
-        it 'Raises ArgumentError, if key is not 24 digits long' do
-          fake_key = 'abcdef0987654321'
-          expect{Client.api_key(fake_key)}.to raise_error ArgumentError
-        end
-        it 'lets an otherwise theoretically-valid key, pass through' do
-          key = generate_fake_api_key
-          expect(Client.api_key(key)).to eq key
-        end
+    describe '::extract_query_string' do
+      it 'produces a query parameter string' do
+        opts = {:key => Client.api_key, :appid => 440, :format => 'json', :compress => 1, :raw => 2}
+        ans = "key=#{Client.api_key}&appid=440&format=json&compress=1&raw=2"
+        expect(Client.extract_query_string(opts)).to eq ans
       end
+    end
 
-      describe '::extract_query_string' do
-        it 'produces a query parameter string' do
-          opts = {:key => Client.api_key, :appid => 440, :format => 'json', :compress => 1, :raw => 2}
-          ans = "key=#{Client.api_key}&appid=440&format=json&compress=1&raw=2"
-          expect(Client.extract_query_string(opts)).to eq ans
-        end
+    describe '::build_url_via' do
+      it 'returns correct destination url when asking for pricing data' do
+        opts = {:key => Client.api_key, :compress => 1}
+        expect(Client.build_url_via(:get_prices, opts)).to eq "http://backpack.tf/api/IGetPrices/v4/?key=#{Client.api_key}&compress=1"
+      end
+      it 'raises an error when asking for any unexpected interface' do
+        expect{Client.build_url_via(:foo)}.to raise_error ArgumentError
+      end
+    end  
+
+    describe '#fetch' do
+
+      before :each do
+        stub_http_response_with('currencies.json')
+      end
+
+      let(:fetched_currencies) {
+        bp.fetch(:currencies, {:compress => 1, :appid => 440})
+      }
+
+      it 'fetches JSON from an interface and returns as a Hash object' do
+        expect(fetched_currencies).to be_instance_of Hash
+      end
+      it 'fetched response has these keys' do
+        expected_keys = %w(currencies current_time name success url)
+        expect(fetched_currencies.keys).to match_array expected_keys
       end
 
-      describe '::build_url_via' do
-        it 'returns correct destination url when asking for pricing data' do
-          opts = {:key => Client.api_key, :compress => 1}
-          expect(Client.build_url_via(:get_prices, opts)).to eq "http://backpack.tf/api/IGetPrices/v4/?key=#{Client.api_key}&compress=1"
-        end
-        it 'raises an error when asking for any unexpected interface' do
-          expect{Client.build_url_via(:foo)}.to raise_error ArgumentError
-        end
-      end  
     end
-  
-    context 'Instances of Client' do
-      let(:bp) { Client.new }
-
-      describe '#get_data' do
-
-        it 'returns results from archived json file' do
-          stub_http_response_with('currencies.json')
-          opts = { :key => Client.api_key, :compress => 1, :appid => 440 }
-          currencies = bp.get_data(:get_currencies, opts)
-
-          expect(currencies['response']).to have_key('success')
-          expect(currencies['response']).to have_key('currencies')
-          expect(currencies['response']).to have_key('name')
-          expect(currencies['response']).to have_key('url')
-          expect(currencies['response']).to have_key('current_time')
-        end
 
-        it 'client requests are returned as ruby Hash objects' do
-          stub_http_response_with('prices.json')
-          opts = {:app_id => 440, :compress => 1}
-          expect(bp.get_data(:get_prices, opts)).to be_instance_of Hash
-        end
+    describe '#update' do
+      #context "USING rspec/mock, updating another another class' class variable" do
+      #  before :each do
+      #    MockResponse = class_double(Response)
+      #    MockCurrencies = class_double(Currencies)
+
+      #    allow(MockResponse).to receive(:responses) { 
+      #      { MockCurrencies => fetched_currencies }
+      #    }
+      #    expect(MockResponse.responses.keys).to eq [MockCurrencies]
+
+      #    allow(MockCurrencies).to receive(:response) {
+      #      Response.hash_keys_to_sym(MockResponse.responses[MockCurrencies])
+      #    }
+      #    expect(MockCurrencies.response.keys).to eq [:success, :currencies, :name, :url, :current_time]
+
+      #    allow(MockCurrencies).to receive(:currencies)
+      #    #expect(MockCurrencies.response).to be_nil
+      #  end
 
+      #  it 'the client passes its fetched data to Response.response class method' do
+      #  end
+      #  it 'the client can pass fetched data to another class so the class can update one of its own class variables' do
+      #    MockResponse.responses(MockCurrencies => fetched_currencies)
+      #    MockCurrencies.response
+      #    expect(MockCurrencies.currencies).not_to be_nil
+      #  end
+      #end
+
+      before :each do
+        stub_http_response_with('currencies.json')
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+        expect(Currencies.response).to be_nil
+        expect(Currencies.currencies).to be_nil
+      end
+
+      let(:fetched_currencies) {
+        bp.fetch(:currencies, {:compress => 1, :appid => 440})
+      }
+
+      context 'results on the Currencies.response method' do
+        it 'returns this Hash object' do
+          bp.update(Currencies, fetched_currencies)
+          processed_json = Response.hash_keys_to_sym(fetched_currencies)
+          expect(Currencies.response).to eq processed_json
+        end
       end
 
+      context 'results on the Currencies.currencies method' do
+        it 'returns this Hash object' do
+          bp.update(Currencies, fetched_currencies)
+          processed_json = Response.hash_keys_to_sym(fetched_currencies['currencies'])
+          expect(Currencies.currencies).to eq processed_json
+        end
+      end
 
     end
+
   end
 end

data/spec/backpack_tf/currencies_spec.rb

@@ -4,42 +4,96 @@ module BackpackTF
   describe 'Currencies' do
     let(:bp) { Client.new }
 
-    describe 'the class' do
+    let(:json_obj) {
+      fixture = file_fixture('currencies.json')
+      fixture = JSON.parse(fixture)['response']
+      Response.hash_keys_to_sym(fixture)
+    }
 
-      it 'has these default attributes' do
-        expect(Currencies.interface).to eq :IGetCurrencies
+    let(:more_json) {
+      fixture = file_fixture('currencies_updated.json')
+      fixture = JSON.parse(fixture)['response']
+      Response.hash_keys_to_sym(fixture)
+    }
+
+    it 'responds to these methods' do
+      expect(Currencies).to respond_to :responses, :response, :currencies, :interface, :hash_keys_to_sym
+    end
+
+    it 'has these default attributes' do
+      expect(Currencies.interface).to eq :IGetCurrencies
+    end
+
+    describe '::responses' do
+
+      before :each do
+        stub_http_response_with('currencies.json')
+        opts = { :app_id => 440, :compress => 1 }
+        fetched_currencies = bp.fetch(:currencies, opts)
+        Response.responses(Currencies.to_sym => fetched_currencies)
       end
 
-      describe 'accessing the IGetCurrencies interface' do
-        it 'returns the fixture and sets to @@currencies variable' do
-          stub_http_response_with('currencies.json')
-          opts = { :app_id => 440, :compress => 1 }
-          Currencies.fetch(bp.get_data(:get_currencies, opts)['response'])
-          expect(Currencies.currencies).not_to be_nil
+      context 'access from Response class' do
+        it 'Currencies can be accessed by calling the key, Currencies' do
+          expect(Response.responses[:'BackpackTF::Currencies']).to eq json_obj
         end
+      end
 
-        it 'the response attribute should have these keys' do
-          expect(Currencies.response.keys).to match_array [:success, :current_time, :currencies, :name, :url]
+      context 'access from Currencies class' do
+        it 'can access response information via the class method, ::response' do
+          expect(Currencies.response).to eq json_obj
         end
+      end
 
-        it 'the keys of the response attribute should have these values' do
-          expect(Currencies.response[:success]).to eq 1
-          expect(Currencies.response[:message]).to eq nil
-          expect(Currencies.response[:current_time]).to eq 1430784460
-          expect(Currencies.response[:name]).to eq 'Team Fortress 2'
-          expect(Currencies.response[:url]).to eq 'http://backpack.tf'
-        end
+      it 'is the same as calling Currencies.response' do
+        expect(Response.responses[:'BackpackTF::Currencies']).to eq Currencies.response
+      end
+    end
 
-        it '@@currencies attribute should be a Hash object' do
-          expect(Currencies.currencies).to be_instance_of Hash
-        end
+    describe '::response' do
+      before :each do
+        stub_http_response_with('currencies.json')
+        opts = { :app_id => 440, :compress => 1 }
+        fetched_currencies = bp.fetch(:currencies, opts)
+        Response.responses(':BackpackTF::Currencies' => fetched_currencies)
+      end
+      it 'the response attribute should have these keys' do
+        expect(Currencies.response.keys).to match_array [:success, :current_time, :currencies, :name, :url]
+      end
 
-        it '@@currencies should have these keys' do
-          expected_keys = [:metal, :keys, :earbuds, :hat]
-          expect(Currencies.currencies.keys).to match_array expected_keys
-        end
+      it 'the keys of the response attribute should have these values' do
+        expect(Currencies.response[:success]).to eq 1
+        expect(Currencies.response[:message]).to eq nil
+        expect(Currencies.response[:current_time]).to eq 1430784460
+        expect(Currencies.response[:name]).to eq 'Team Fortress 2'
+        expect(Currencies.response[:url]).to eq 'http://backpack.tf'
+      end
+
+    end
+
+    describe '::currencies' do
+      before :each do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+
+        stub_http_response_with('currencies.json')
+        opts = { :app_id => 440, :compress => 1 }
+        fetched_currencies = bp.fetch(:currencies, opts)
+        Response.responses(:'BackpackTF::Currencies' => fetched_currencies)
+      end
+
+      it 'returns the fixture and sets to @@currencies variable' do
+        expect(Currencies.currencies).not_to be_nil
       end
 
+      it '@@currencies attribute should be a Hash object' do
+        expect(Currencies.currencies).to be_instance_of Hash
+      end
+
+      it '@@currencies should have these keys' do
+        expected_keys = [:metal, :keys, :earbuds, :hat]
+        expect(Currencies.currencies.keys).to match_array expected_keys
+      end
     end
 
     describe 'instance of Currencies' do
@@ -47,7 +101,7 @@ module BackpackTF
       let (:metal) { Currencies.new(:metal, Currencies.currencies[:metal]) }
 
       it 'should respond to these methods' do
-        expect(metal).to respond_to :quality, :priceindex, :single, :plural, :round, :craftable, :tradable, :defindex, :blanket
+        expect(metal).to respond_to(:quality, :priceindex, :single, :plural, :round, :craftable, :tradable, :defindex, :blanket)
       end
 
       it 'should have these values' do

data/spec/backpack_tf/finder_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module BackpackTF
+
+  class Dummy
+    include BackpackTF::Finder
+  end
+
+  shared_examples 'Finder' do
+    let(:dummy) { Dummy.new }
+
+    it 'responds to these inherited class methods' do
+      expect(Dummy).to respond_to(:get_item_price, :defindex_to_item_name, :find_item_by_name, :is_item_of_type?, :get_name_of_random_item)
+    end
+
+  end
+
+  describe Prices do
+    it_behaves_like 'Finder'
+  end
+
+  describe Item do
+    it_behaves_like 'Finder'
+  end
+
+  describe ItemPrice do
+    it_behaves_like 'Finder'
+  end
+
+end

data/spec/backpack_tf/item_price_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module BackpackTF
+  describe 'ItemPrice' do
+    describe 'instance of ItemPrice' do
+      context "A typical item that does NOT have the quality 'Unusual'" do
+        let(:item_price_key) { 'Unique_Tradable_Craftable' }
+        let(:item_price_attr) { '{"currency":"metal","value":0.05,"last_update":1336410088,"difference":0}' }
+        let (:item_price) { ItemPrice.new(item_price_key, item_price_attr) }
+
+        it 'should respond to these methods' do
+          expect(item_price).to respond_to :quality, :tradability, :craftability, :priceindex, :currency, :value, :value_high, :value_raw, :value_high_raw, :last_update, :difference
+        end
+        it 'should have these values' do
+          expect(item_price.quality).to eq :Unique
+          expect(item_price.tradability).to eq :Tradable
+          expect(item_price.craftability).to eq :Craftable
+          expect(item_price.currency).to eq :metal
+          expect(item_price.value).to eq 0.05
+          expect(item_price.value_high).to be_nil
+          expect(item_price.value_raw).to be_nil
+          expect(item_price.value_high_raw).to be_nil
+          expect(item_price.last_update).to eq 1336410088
+          expect(item_price.difference).to eq 0
+          expect(item_price.priceindex).to be_nil
+        end
+      end
+
+      context "An item with the quality 'Unusual'" do
+        # the Unusual item being tested is the 'Barnstormer'
+        let(:item_price_key) { 'Unusual_Tradable_Craftable' }
+        #let(:item_price_attr) {'{"6":{"currency":"keys","value":18,"last_update":1418795322,"difference":280,"value_high":22}}'}
+        let(:item_price_attr) {'{"currency":"keys","value":18,"last_update":1418795322,"difference":280,"value_high":22}'}
+        let(:item_price) { ItemPrice.new(item_price_key, item_price_attr, 6) }
+
+        it 'should respond to these methods' do
+          expect(item_price).to respond_to :quality, :tradability, :craftability, :priceindex, :currency, :value, :value_high, :value_raw, :value_high_raw, :last_update, :difference
+        end
+        it 'should have these values' do
+          expect(item_price.quality).to eq :Unusual
+          expect(item_price.tradability).to eq :Tradable
+          expect(item_price.craftability).to eq :Craftable
+          expect(item_price.currency).to eq :keys
+          expect(item_price.value).to eq 18
+          expect(item_price.value_high).to eq 22
+          expect(item_price.value_raw).to be_nil
+          expect(item_price.value_high_raw).to be_nil
+          expect(item_price.last_update).to eq 1418795322
+          expect(item_price.difference).to eq 280
+          expect(item_price.priceindex).to eq 6
+        end
+      end
+    end
+  end
+end

data/spec/backpack_tf/item_spec.rb

@@ -2,24 +2,173 @@ require 'spec_helper'
 
 module BackpackTF
   describe 'Item' do
-    it 'The Prices class returns the fixture and sets to its @@items variable' do
-      stub_http_response_with('prices.json')
-      opts = { :app_id => 440, :compress => 1 }
-      Prices.fetch(Client.new.get_data(:get_prices, opts)['response'])
-      expect(Prices.items).not_to be_nil
+    let(:expected_keys) do
+      ["Strange_Tradable_Craftable", "Collector's_Tradable_Craftable", "Vintage_Tradable_Craftable", "Unique_Tradable_Craftable", "Unique_Tradable_Non-Craftable"]
+    end
+
+    xdescribe '::generate_price_keys'  do
+      it 'includes these keys' do
+        keys = Item.generate_price_keys(stub)
+        keys.each{ |key| expect(expected_keys).to include(key) }
+      end
+      it 'produces all of these keys' do
+        keys = Item.generate_price_keys(stub['prices'])
+        expect(keys).to match_array expected_keys
+      end
     end
 
     describe 'instance of Item' do
+      context 'a typical game item, which does not have any item qualities of Unusual' do
+        let(:item_name) { 'Kritzkrieg' }
+        let(:stub) do
+          JSON.parse '{"defindex":[35],"prices":{"11":{"Tradable":{"Craftable":[{"currency":"keys","value":18,"last_update":1430665867,"difference":-18.495}]}},"14":{"Tradable":{"Craftable":[{"currency":"keys","value":9,"last_update":1416841372,"difference":11.385}]}},"3":{"Tradable":{"Craftable":[{"currency":"metal","value":0.66,"last_update":1426439779,"difference":0.33}]}},"6":{"Tradable":{"Craftable":[{"currency":"metal","value":0.05,"last_update":1336410088,"difference":0}],"Non-Craftable":[{"currency":"metal","value":0.05,"last_update":1362791812,"difference":0.03}]}}}}'
+        end
+        let(:item) { Item.new(item_name, stub) }
+        let(:prices_hash) { item.gen_prices_hash(stub) }
+
+        it 'should respond to these methods' do
+          expect(item).to respond_to :item_name, :defindex, :prices, :gen_prices_hash
+        end
+
+        it 'should have these values' do
+          expect(item.item_name).to eq 'Kritzkrieg'
+          expect(item.defindex).to eq 35
+        end
+
+        describe '#gen_prices_hash' do
+          it 'generates a Hash' do
+            expect(prices_hash).to be_instance_of Hash
+          end
+          it 'each key is a String' do
+            expect(prices_hash.keys).to all be_a String
+          end
+          it 'includes these keys' do
+            prices_hash.keys.each{ |key| expect(expected_keys).to include(key) }
+          end
+          it 'value of each key is an ItemPrice object' do
+            expect(prices_hash.values).to all be_an ItemPrice
+          end
+        end
+
+        describe 'the @prices instance variable' do
+          it 'is a Hash' do
+            expect(item.prices).to be_a Hash
+          end
+          it 'include these keys' do
+            item.prices.keys.each{|key| expect(expected_keys).to include(key)}
+          end
+          xit 'has all of these keys' do
+            expect(item.prices.keys).to eq expected_keys
+          end
+          it 'each value is an ItemPrice object' do
+            expect(item.prices.values).to all be_an ItemPrice
+          end
+        end
+      end
+
+      context 'an item with a quality of Unusual' do
+        let(:item_name) { 'Barnstormer' }
+        let(:stub) { JSON.parse(file_fixture('item_unusual.json')) }
+        let(:item) { Item.new(item_name, stub) }
+        let(:prices_hash) { item.gen_prices_hash(stub) }
+
+        it 'should respond to these methods' do
+          expect(item).to respond_to :item_name, :defindex, :prices, :gen_prices_hash
+        end
+        it 'should have these values' do
+          expect(item.item_name).to eq 'Barnstormer'
+          expect(item.defindex).to eq 988
+        end
+
+        describe '#gen_prices_hash' do
+          it 'generates a Hash' do
+            expect(prices_hash).to be_instance_of Hash
+          end
+          it 'each key is a String' do
+            expect(prices_hash.keys).to all be_a String
+          end
+          it 'value of each key is an ItemPrice object' do
+            expect(prices_hash.values).to all be_an ItemPrice
+          end
+        end
+        describe 'the @prices instance variable' do
+          it 'is a Hash' do
+            expect(item.prices).to be_a Hash
+          end
+          it 'each value is an ItemPrice object' do
+            expect(item.prices.values).to all be_an ItemPrice
+          end
+        end
+      end
+
+      context 'an item with an unconventional structure' do
+        let(:item_name) { 'Aqua Summer 2013 Coolor' }
+        let(:stub) { JSON.parse(file_fixture('item_with_unconventional_structure.json')) }
+        let(:item) { Item.new(item_name, stub) }
+        let(:prices_hash) { item.gen_prices_hash(stub) }
 
-      let (:item) { Item.new('Kritzkrieg', Prices.items['Kritzkrieg']) }
+        it 'should respond to these methods' do
+          expect(item).to respond_to :item_name, :defindex, :prices, :gen_prices_hash
+        end
+        it 'should have these values' do
+          expect(item.item_name).to eq 'Aqua Summer 2013 Coolor'
+          expect(item.defindex).to eq 5650
+        end
 
-      it 'should respond to these methods' do
-        expect(item).to respond_to :item_name, :defindex, :prices
+        describe '#gen_prices_hash' do
+          it 'generates a Hash' do
+            expect(prices_hash).to be_instance_of Hash
+          end
+          it 'each key is a String' do
+            expect(prices_hash.keys).to all be_a String
+          end
+          it 'value of each key is an ItemPrice object' do
+            expect(prices_hash.values).to all be_an ItemPrice
+          end
+        end
+        describe 'the @prices instance variable' do
+          it 'is a Hash' do
+            expect(item.prices).to be_a Hash
+          end
+          it 'each value is an ItemPrice object' do
+            expect(item.prices.values).to all be_an ItemPrice
+          end
+        end
       end
 
-      it 'should have these values' do
-        expect(item.item_name).to eq 'Kritzkrieg'
-        expect(item.defindex).to eq 35
+      context 'an item that has no `defindex` or has a negative `defindex`' do
+        let(:item_name) { 'Strange Part: Fires Survived' }
+        let(:stub) { JSON.parse(file_fixture('item_without_defindex.json')) }
+        let(:item) { Item.new(item_name, stub) }
+        let(:prices_hash) { item.gen_prices_hash(stub) }
+
+        it 'should respond to these methods' do
+          expect(item).to respond_to :item_name, :defindex, :prices, :gen_prices_hash
+        end
+        it 'should have these values' do
+          expect(item.item_name).to eq 'Strange Part: Fires Survived'
+          expect(item.defindex).to eq nil
+        end
+
+        describe '#gen_prices_hash' do
+          it 'generates a Hash' do
+            expect(prices_hash).to be_instance_of Hash
+          end
+          it 'each key is a String' do
+            expect(prices_hash.keys).to all be_a String
+          end
+          it 'value of each key is an ItemPrice object' do
+            expect(prices_hash.values).to all be_an ItemPrice
+          end
+        end
+        describe 'the @prices instance variable' do
+          it 'is a Hash' do
+            expect(item.prices).to be_a Hash
+          end
+          it 'each value is an ItemPrice object' do
+            expect(item.prices.values).to all be_an ItemPrice
+          end
+        end
       end
 
     end