backpack_tf 0.8.1 → 0.8.4

data/spec/backpack_tf/inherited_class_methods_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module BackpackTF
+
+  shared_examples 'a class inheriting methods from Response' do |file|
+    let(:bp) { Client.new }
+    let(:json_obj) {
+      fixture = file_fixture(file)
+      fixture = JSON.parse(fixture)['response']
+      Response.hash_keys_to_sym(fixture)
+    }
+
+    before :all do
+      mock_alias
+    end
+
+    it 'should respond to these inherited methods' do
+      expect(described_class).to respond_to :responses, :interface, :to_sym, :hash_keys_to_sym
+    end
+
+    it 'should respond to this aliased method (for testing only)' do
+      expect(described_class).to respond_to :data_storage
+    end
+
+    describe '::to_sym' do
+      it 'returns a Symbol of the name of the name of the class' do
+        expect(described_class.to_sym).to eq described_class.to_s.to_sym
+      end
+    end
+
+    describe '::responses' do
+      before :all do
+        expect(Response.responses).to be_empty
+      end
+
+      after :all do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+        expect(described_class.response).to be_nil
+      end
+
+      it "Response class can access response for #{described_class} by calling the key #{described_class}" do
+        stub_http_response_with(file)
+        fetched_data = bp.fetch(make_fetch_sym)
+        bp.update(described_class, fetched_data)
+        expect(Response.responses[described_class.to_sym]).to eq json_obj
+      end
+    end
+
+    describe '::response' do
+      before :all do
+        expect(described_class.response).to be_nil
+      end
+
+      before :each do
+        stub_http_response_with(file)
+        fetched_data = bp.fetch(make_fetch_sym)
+        bp.update(described_class, fetched_data)
+      end
+
+      after :all do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+        expect(described_class.response).to be_nil
+        expect(described_class.data_storage).to be_nil
+      end
+
+      it 'can access response information' do
+        expect(described_class.response).to eq json_obj
+      end
+
+      it "returns same info as the Response class calling Price key" do
+        result = Response.responses[described_class.to_sym]
+        expect(described_class.response).to eq result
+      end
+    end
+
+  end
+
+  describe Price do
+    it_behaves_like('a class inheriting methods from Response', 'prices.json')
+  end
+
+  describe Currency do
+    it_behaves_like('a class inheriting methods from Response', 'currencies.json')
+  end
+
+  describe SpecialItem do
+    it_behaves_like('a class inheriting methods from Response', 'special_items.json')
+  end
+
+  describe User do
+    it_behaves_like('a class inheriting methods from Response', 'users.json')
+  end
+
+  describe UserListing do
+    it_behaves_like('a class inheriting methods from Response', 'user_listing.json')
+  end
+
+end

data/spec/backpack_tf/item_price_spec.rb

@@ -1,53 +1,117 @@
 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) }
+  describe ItemPrice do
 
-        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
+    describe '::quality_name_to_index' do
+      it 'returns Quality Index of the name of Quality' do
+        expect(described_class.quality_name_to_index('Strange')).to eq 11
+      end
+      it 'returns nil when you ask for index of `nil`' do
+        expect(described_class.quality_name_to_index(nil)).to be_nil
+      end
+    end
+    
+    describe '::hash_particle_effects' do
+      it 'creates a key value pair for each id & name' do
+        expect(described_class.hash_particle_effects[17]).to eq 'Sunbeams'
+        expect(described_class.hash_particle_effects[5]).to eq 'Holy Glow'
+      end
+      it 'is nil if it cannot find that key' do
+        expect(described_class.hash_particle_effects[nil]).to be_nil
+      end
+
+      context '@@particle_effects' do
+        it 'same thing can be accessed through class variable' do
+          expect(described_class.particle_effects[17]).to eq 'Sunbeams'
+          expect(described_class.particle_effects[5]).to eq 'Holy Glow'
+        end
+        it 'is nil if it cannot find that key' do
+          expect(described_class.particle_effects[nil]).to be_nil
+        end
+      end
+    end
+
+    describe '#initialize' do
+      base_json = JSON.parse(file_fixture('item_typical.json'))['Kritzkrieg']
+      ok_json = base_json['prices']['6']['Tradable']['Craftable'][0]
+      wrong_level = base_json['prices']['6']['Tradable']
+
+      context 'validating first parameter' do
+
+        it 'will raise ArgumentError if there is not enough information' do
+          expect{described_class.new('Unique_Tradable', ok_json)}.to raise_error ArgumentError
+        end
+        it 'will raise NameError if any one of the info bits is incorrect' do
+          expect{described_class.new('xx_Tradable_Craftable', ok_json)}.to raise_error NameError
+        end
+        it 'will raise a NameError if name has correct info but is out of order' do
+          expect{described_class.new('Craftable_Tradable_Strange', ok_json)}.to raise_error NameError
+        end
+      end
+      context 'validating 2nd parameter' do
+        it 'will raise a KeyError if JSON does not have required keys' do
+          expect{described_class.new('Unique_Tradable_Craftable', wrong_level)}.to raise_error KeyError
         end
+      end
+    end
+
+    shared_examples 'an ItemPrice object' do
+      it 'should respond to these methods' do
+        expect(subject).to respond_to :quality, :tradability, :craftability, :priceindex, :currency, :value, :value_high, :value_raw, :value_high_raw, :last_update, :difference
+      end
+    end
+
+    describe 'A price for a typical item' do
+      item_price_attr = JSON.parse(file_fixture('item_typical.json'))['Kritzkrieg']['prices']['6']['Tradable']['Craftable'][0]
+
+      subject {
+        described_class.new('Unique_Tradable_Craftable', item_price_attr)
+      }
+
+      it_behaves_like('an ItemPrice object')
+
+      context 'item-specific tests' do
         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
+          expect(subject.quality).to eq :Unique
+          expect(subject.tradability).to eq :Tradable
+          expect(subject.craftability).to eq :Craftable
+          expect(subject.currency).to eq :metal
+          expect(subject.value).to eq 0.05
+          expect(subject.value_high).to be_nil
+          expect(subject.value_raw).to be_nil
+          expect(subject.value_high_raw).to be_nil
+          expect(subject.last_update).to eq 1336410088
+          expect(subject.difference).to eq 0
+          expect(subject.priceindex).to be_nil
+          expect(subject.effect).to be_nil
         end
+      end
+    end
+
+    describe "A price for an item with 'Unusual' quality" do
+      item_price_attr = JSON.parse(file_fixture('item_unusual.json'))['Barnstormer']['prices']['5']['Tradable']['Craftable']['6']
+
+      subject { 
+        described_class.new('Unusual_Tradable_Craftable', item_price_attr, 6)
+      }
+
+      it_behaves_like('an ItemPrice object')
+
+      context 'item-specific tests' do
         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
+          expect(subject.quality).to eq :Unusual
+          expect(subject.tradability).to eq :Tradable
+          expect(subject.craftability).to eq :Craftable
+          expect(subject.currency).to eq :keys
+          expect(subject.value).to eq 18
+          expect(subject.value_high).to eq 22
+          expect(subject.value_raw).to be_nil
+          expect(subject.value_high_raw).to be_nil
+          expect(subject.last_update).to eq 1418795322
+          expect(subject.difference).to eq 280
+          expect(subject.priceindex).to eq 6
+          expect(subject.effect).to eq 'Green Confetti'
         end
       end
     end

data/spec/backpack_tf/item_spec.rb

@@ -1,165 +1,126 @@
 require 'spec_helper'
 
 module BackpackTF
-  describe 'Item' do
-    let(:expected_keys) do
-      ["Strange_Tradable_Craftable", "Collector's_Tradable_Craftable", "Vintage_Tradable_Craftable", "Unique_Tradable_Craftable", "Unique_Tradable_Non-Craftable"]
-    end
+  describe Item do
+    shared_examples 'a common item' do |passed_item_attr|
+      it 'should respond to these methods' do
+        expect(subject).to respond_to :item_name, :defindex, :prices, :generate_prices_hash
+      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) }
+      describe '#generate_prices_hash' do
+        let(:prices_hash) { subject.generate_prices_hash(passed_item_attr) }
 
-        it 'should respond to these methods' do
-          expect(item).to respond_to :item_name, :defindex, :prices, :gen_prices_hash
+        it 'generates a Hash' do
+          expect(prices_hash).to be_instance_of Hash
         end
-
-        it 'should have these values' do
-          expect(item.item_name).to eq 'Kritzkrieg'
-          expect(item.defindex).to eq 35
+        it 'each key is a String' do
+          expect(prices_hash.keys).to all be_a String
         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
+        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
+      describe 'the @prices instance variable' do
+        it 'is a Hash' do
+          expect(subject.prices).to be_a Hash
+        end
+        it 'each value is an ItemPrice object' do
+          expect(subject.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) }
+    describe 'A typical item' do
+      item_attr = JSON.parse(file_fixture('item_typical.json'))['Kritzkrieg']
+      item = described_class.new('Kritzkrieg', item_attr)
+      subject { item }
+      it_behaves_like('a common item', item_attr)
 
-        it 'should respond to these methods' do
-          expect(item).to respond_to :item_name, :defindex, :prices, :gen_prices_hash
+      context 'item-specific tests' do
+        it 'should have these values' do
+          expect(subject.item_name).to eq 'Kritzkrieg'
+          expect(subject.defindex).to eq 35
         end
+        xit '@prices should have these keys' do
+          ans = ['Strange_Tradable_Craftable',
+                 "Collector's_Tradable_Craftable",
+                 'Vintage_Tradable_Craftable',
+                 'Unique_Tradable_Craftable',
+                 'Unique_Tradable_Non-Craftable']
+          expect(subject.prices.keys).to match_array ans
+        end
+      end
+    end
+
+    describe "An item with the quality of 'Unusual'" do
+      item_attr = JSON.parse(file_fixture('item_unusual.json'))['Barnstormer']
+      item = described_class.new('Barnstormer', item_attr)
+      subject { item }
+      it_behaves_like('a common item', item_attr)
+
+      context 'item-specific tests' do
         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
+        it '@prices should have these keys' do
+          priceindex_vals = ["Aces High", "Anti-Freeze", "Blizzardy Storm", "Bubbling", "Burning Flames", "Circling Heart", "Circling TF Logo", "Cloud 9", "Dead Presidents", "Death at Dusk", "Disco Beat Down", "Electrostatic", "Green Black Hole", "Green Confetti", "Green Energy", "Haunted Ghosts", "Kill-a-Watt", "Memory Leak", "Miami Nights", "Morning Glory", "Nuts n' Bolts", "Orbiting Fire", "Orbiting Planets", "Overclocked", "Phosphorous", "Power Surge", "Purple Confetti", "Purple Energy", "Roboactive", "Scorching Flames", "Smoking", "Steaming", "Stormy Storm", "Sulphurous", "Terror-Watt", "Time Warp", "Unique_Tradable_Craftable"]
+          expect(subject.prices.keys).to match_array priceindex_vals
         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) }
+    describe 'An item with many priceindex values (Crate or Unusual)' do
+      item_attr = JSON.parse(file_fixture('item_crate.json'))['Mann Co. Supply Munition']
+      item = described_class.new('Mann Co. Supply Munition', item_attr)
+      subject { item }
+      it_behaves_like('a common item', item_attr)
 
-        it 'should respond to these methods' do
-          expect(item).to respond_to :item_name, :defindex, :prices, :gen_prices_hash
-        end
+      context 'item-specific tests' do
         it 'should have these values' do
-          expect(item.item_name).to eq 'Aqua Summer 2013 Coolor'
-          expect(item.defindex).to eq 5650
+          expect(subject.item_name).to eq 'Mann Co. Supply Munition'
+          expect(subject.defindex).to match_array [5734, 5735, 5742, 5752, 5781, 5802, 5803]
+        end
+        it 'prices array should have these keys' do
+          ans = ['Unique_Tradable_Craftable_#82',
+                 'Unique_Tradable_Craftable_#83',
+                 'Unique_Tradable_Craftable_#84',
+                 'Unique_Tradable_Craftable_#85',
+                 'Unique_Tradable_Craftable_#90',
+                 'Unique_Tradable_Craftable_#91',
+                 'Unique_Tradable_Craftable_#92']
+          expect(subject.prices.keys).to match_array ans
         end
+      end
+    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
+    describe 'An item with an unconventional structure' do
+      item_attr = JSON.parse(file_fixture('item_with_unconventional_structure.json'))['Aqua Summer 2013 Cooler']
+      item = described_class.new('Aqua Summer 2013 Cooler', item_attr)
+      subject { item }
+      it_behaves_like('a common item', item_attr)
+
+      context 'item-specific tests' do
+        it 'should have these values' do
+          expect(item.item_name).to eq 'Aqua Summer 2013 Cooler'
+          expect(item.defindex).to eq 5650
         end
       end
+    end
 
-      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) }
+    describe "An item that has a negative 'defindex' or no 'defindex' at all" do
+      item_attr = JSON.parse(file_fixture('item_without_defindex.json'))['Strange Part: Fires Survived']
+      item = described_class.new('Strange Part: Fires Survived', item_attr)
+      subject { item }
+      it_behaves_like('a common item', item_attr)
 
-        it 'should respond to these methods' do
-          expect(item).to respond_to :item_name, :defindex, :prices, :gen_prices_hash
-        end
+      context 'item-specific tests' do
         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
   end
 end