backpack_tf 0.8.4 → 1.0.0.rc1

data/spec/backpack_tf/inherited_class_methods_spec.rb

@@ -1,100 +0,0 @@
-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,119 +0,0 @@
-require 'spec_helper'
-
-module BackpackTF
-  describe ItemPrice do
-
-    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(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(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
-  end
-end

data/spec/backpack_tf/item_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-
-module BackpackTF
-  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 '#generate_prices_hash' do
-        let(:prices_hash) { subject.generate_prices_hash(passed_item_attr) }
-
-        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(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
-
-    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)
-
-      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
-        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
-
-    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)
-
-      context 'item-specific tests' do
-        it 'should have these values' do
-          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 '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
-
-    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)
-
-      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
-      end
-    end
-  end
-end

data/spec/backpack_tf/price_spec.rb

@@ -1,184 +0,0 @@
-require 'spec_helper'
-
-module BackpackTF
-  describe Price do
-
-    let(:bp) { Client.new }
-
-    let(:json_obj) {
-      fixture = file_fixture('prices.json')
-      fixture = JSON.parse(fixture)['response']
-      Response.hash_keys_to_sym(fixture)
-    }
-
-    it 'has these default attributes' do
-      expect(described_class.interface).to eq :IGetPrices
-    end
-
-    it 'raises an error when trying to instantiate this class' do
-      expect{described_class.new}.to raise_error RuntimeError
-    end
-
-    describe '::response' do
-      before :all do
-        expect(described_class.response).to be_nil
-      end
-
-      before :each do
-        stub_http_response_with('prices.json')
-        fetched_prices = bp.fetch(:prices)
-        bp.update(described_class, fetched_prices)
-      end
-
-      after :all do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        expect(described_class.response).to be_nil
-        expect(described_class.items).to be_nil
-      end
-
-      it 'the keys of the response attribute should have these values' do
-        response = described_class.response
-        expect(response[:success]).to eq 1
-        expect(response[:message]).to eq nil
-        expect(response[:current_time]).to eq 1430785805
-        expect(response[:raw_usd_value]).to eq 0.115
-        expect(response[:usd_currency]).to eq 'metal'
-        expect(response[:usd_currency_index]).to eq 5002
-      end
-    end
-
-    describe '::generate_items' do
-      before :each do
-        stub_http_response_with('prices.json')
-        fetched_prices = bp.fetch(:prices)
-        bp.update(described_class, fetched_prices)
-      end
-
-      after :all do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        described_class.class_eval { @items = nil }
-      end
-
-      it 'each key of hash is a String' do
-        expect(described_class.generate_items.keys).to all be_a String
-      end
-      it 'each value of hash is an Item object' do
-        expect(described_class.generate_items.values).to all be_an Item
-      end
-      it 'if an item does not have a valid `defindex`, then it is ignored' do
-        expect(described_class.generate_items['Random Craft Hat']).to be_nil
-        expect(described_class.generate_items[':weed:']).to be_nil
-      end
-    end
-
-    describe '::items' do
-      before :each do
-        stub_http_response_with('prices.json')
-        fetched_prices = bp.fetch(:prices)
-        bp.update(described_class, fetched_prices)
-      end
-
-      after :all do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        described_class.class_eval { @items = nil }
-      end
-
-      it 'returns the fixture and sets to @@items variable' do
-        expect(described_class.items).not_to be_nil
-      end
-
-      context '@@items attribute' do
-        it 'should be a Hash object' do
-          expect(described_class.items).to be_instance_of Hash
-        end
-        xit 'should have this many keys' do
-          expect(described_class.items.keys.length).to be 1661
-        end
-        it 'each key should be a String' do
-          expect(described_class.items.keys).to all be_a String
-        end
-        it 'each value should be an Item' do
-          expect(described_class.items.values).to all be_an Item
-        end
-      end
-
-      context 'using keys to generate Item objects' do
-        let(:random_key) { described_class.items.keys.sample }
-        let(:item) { described_class.items[random_key] }
-
-        it 'generates an Item object' do
-          expect(item).to be_instance_of Item
-        end
-        it 'the Item object responds to these methods' do
-          expect(item).to respond_to :item_name, :defindex, :prices
-        end
-        it 'uses the key to assign a value to the @item_name property of the Item' do
-          expect(random_key).to eq item.item_name
-        end
-        it 'passes itself to be stored in the @prices attribute of the Item object' do
-          expect(described_class.items[random_key].prices).to eq item.prices
-        end
-      end
-    end
-
-    describe '::find_item_by_name' do
-      let(:item) { described_class.items['Kritzkrieg'] }
-
-      before :each do
-        stub_http_response_with('prices.json')
-        fetched_prices = bp.fetch(:prices)
-        bp.update(described_class, fetched_prices)
-      end
-
-      after :each do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        described_class.class_eval { @items = nil }
-      end
-
-      it 'returns Item object for the item matching the name' do
-        expect(described_class.find_item_by_name('Kritzkrieg')).to eq item
-      end
-      it 'can return picked attributes' do
-        expect(described_class.find_item_by_name('Kritzkrieg', :defindex)).to eq 35
-      end
-      it 'raises a KeyError if you ask for attribute it does not have' do
-        expect{described_class.find_item_by_name('Kritzkrieg', :foo)}.to raise_error KeyError
-      end
-    end
-
-    describe '::random_item' do
-      before :each do
-        stub_http_response_with('prices.json')
-        fetched_prices = bp.fetch(:prices)
-        bp.update(described_class, fetched_prices)
-      end
-
-      after :each do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        described_class.class_eval { @items = nil }
-      end
-
-      it 'returns a name of an Item object' do
-        item = described_class.random_item
-        expect(described_class.items.keys.include? item).to be_truthy
-      end
-
-      context 'asking for prices property' do
-        let(:item_prices) { described_class.random_item :price }
-
-        it 'returns a Hash object where keys are String objects' do
-          expect(item_prices.keys).to all be_a String
-        end
-        it 'returns a Hash object where values are ItemPrice objects' do
-          expect(item_prices.values).to all be_an ItemPrice
-        end
-      end
-    end
-
-  end
-end

data/spec/fixtures/item_without_defindex.json

@@ -1 +0,0 @@
-{"Strange Part: Fires Survived":{"defindex":[],"prices":{"6":{"Tradable":{"Craftable":[{"currency":"metal","value":0.66,"last_update":1393622359,"difference":-0.17}]}}}}}