backpack_tf 0.8.4 → 1.0.0.rc1

data/spec/backpack_tf/price/item_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+
+describe BackpackTF::Price::Item do
+  let(:attr) do
+    { 'prices' => {}, 'defindex' => ['1'] }
+  end
+  let(:item) do
+    described_class.new('item', attr)
+  end
+  let(:item_price) do
+    BackpackTF::Price::ItemPrice.new('q_t_c', {})
+  end
+
+  describe '#process_defindex' do
+    after(:each) do
+      attr['defindex'] = nil
+    end
+
+    it 'returns nil when arr length is 0' do
+      attr['defindex'] = []
+      actual = item.send(:process_defindex, attr['defindex'])
+      expect(actual).to be_nil
+    end
+
+    it 'returns value when arr length is 1' do
+      attr['defindex'] = ['bar']
+      actual = item.send(:process_defindex, attr['defindex'])
+      expect(actual).to eq 'bar'
+    end
+
+    it 'otherwise returns array' do
+      attr['defindex'] = %w(bar quux)
+      actual = item.send(:process_defindex, attr['defindex'])
+      expect(actual).to eq %w(bar quux)
+    end
+  end
+
+  describe '#generate_prices_hash' do
+    context 'a typical item' do
+      it 'calls build_item_price' do
+        mock_input_hash = {
+          'prices' => {
+            '6' => {
+              'Tradable' => {
+                'Craftable' => {
+                  '0' => {}
+                }
+              }
+            }
+          }
+        }
+        expect(item).to receive(:build_item_price)
+        item.send(:generate_prices_hash, mock_input_hash)
+      end
+    end
+
+    context 'an item with "Unusual" quality' do
+      it 'calls build_unusual_item_price' do
+        mock_input_hash = {
+          'prices' => {
+            '5' => {
+              'Tradable' => {
+                'Craftable' => {
+                  '1' => {}
+                }
+              }
+            }
+          }
+        }
+        expect(item).to receive(:build_unusual_item_price)
+        item.send(:generate_prices_hash, mock_input_hash)
+      end
+    end
+
+    context 'a crate' do
+      it 'calls build_crate_price' do
+        mock_input_hash = {
+          'prices' => {
+            '6' => {
+              'Tradable' => {
+                'Craftable' => {
+                  '2' => {}
+                }
+              }
+            }
+          }
+        }
+        expect(item).to receive(:build_crate_price)
+        item.send(:generate_prices_hash, mock_input_hash)
+      end
+    end
+  end
+
+  describe '#quality_index_to_name' do
+    it 'calls ItemPrice.quality_index_to_name' do
+      expect(BackpackTF::Price::ItemPrice)
+        .to receive(:qualities)
+        .and_return([:foo, :bar])
+      item.send(:quality_index_to_name, '1')
+    end
+  end
+
+  describe '#keyname' do
+    before(:each) do
+      expect(item).to receive(:quality_index_to_name).and_return('Quality')
+    end
+    it 'returns a string delimited by underscore' do
+      actual = item.send(:keyname, 1, 'Tradability', 'Craftability')
+      expected = 'Quality_Tradability_Craftability'
+      expect(actual).to eq expected
+    end
+
+    it 'returns a string plus priceindex, delimited by underscore' do
+      actual = item.send(:keyname, 1, 'Tradability', 'Craftability', '5')
+      expected = 'Quality_Tradability_Craftability_#5'
+      expect(actual).to eq expected
+    end
+  end
+
+  describe '#build_item_price' do
+    before(:each) do
+      allow(BackpackTF::Price::ItemPrice)
+        .to receive(:new)
+        .and_return(item_price)
+    end
+
+    it 'calls for a new ItemPrice object' do
+      expect(BackpackTF::Price::ItemPrice).to receive(:new)
+      item.send(:build_item_price, {}, 'key_str', :attr)
+    end
+    it 'the new item is an ItemPrice object' do
+      actual = item.send(:build_item_price, {}, 'key_str', :attr)
+      expect(actual['key_str']).to be_a BackpackTF::Price::ItemPrice
+    end
+  end
+
+  describe '#build_unusual_item_price' do
+    before(:each) do
+      expect(BackpackTF::Price::ItemPrice)
+        .to receive(:new)
+        .and_return(item_price)
+      allow_any_instance_of(BackpackTF::Price::ItemPrice)
+        .to receive(:effect)
+        .and_return('effect')
+    end
+
+    it 'calls for a new ItemPrice object' do
+      item.send(:build_unusual_item_price, {}, 'q_t_c', :attr, :price_idx)
+    end
+    it 'the name of the new key is the effect name of item price object' do
+      actual = item.send(:build_unusual_item_price, {}, 'q_t_c', :attr, '5')
+      expect(actual['effect']).to be_a BackpackTF::Price::ItemPrice
+    end
+  end
+
+  describe '#build_crate_price' do
+    before(:each) do
+      allow(BackpackTF::Price::ItemPrice)
+        .to receive(:new)
+        .and_return(item_price)
+    end
+
+    it 'calls for a new ItemPrice object' do
+      expect(BackpackTF::Price::ItemPrice).to receive(:new)
+      item.send(:build_crate_price, {}, 'key_str', :attr, '85')
+    end
+    it 'the new item is an ItemPrice object' do
+      actual = item.send(:build_crate_price, {}, 'key_str', :attr, '85')
+      expect(actual['key_str']).to be_a BackpackTF::Price::ItemPrice
+    end
+  end
+
+  shared_examples 'a common item' do |passed_item_attr|
+    describe '#generate_prices_hash' do
+      let(:prices_hash) do
+        subject.send(:generate_prices_hash, passed_item_attr)
+      end
+
+      it 'each key is a String' do
+        expect(prices_hash.keys).to all be_a String
+      end
+      it 'value of each key is a BackpackTF::ItemPrice object' do
+        expect(prices_hash.values).to all be_an BackpackTF::Price::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 a BackpackTF::ItemPrice object' do
+        expect(subject.prices.values).to all be_an BackpackTF::Price::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
+      it '@prices should have these keys' do
+        expected = ['Strange_Tradable_Craftable',
+                    "Collector's_Tradable_Craftable",
+                    'Vintage_Tradable_Craftable',
+                    'Unique_Tradable_Craftable',
+                    'Unique_Tradable_Non-Craftable']
+        expect(subject.prices.keys).to match_array expected
+      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', 'Amaranthine', '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', 'Molten Mallard', 'Morning Glory', "Nuts n' Bolts", 'Orbiting Fire', 'Orbiting Planets', 'Overclocked', 'Phosphorous', 'Power Surge', 'Purple Confetti', 'Purple Energy', 'Roboactive', 'Scorching Flames', 'Smoking', 'Something Burning This Way Comes', 'Steaming', 'Stormy Storm', 'Sulphurous', 'Terror-Watt', 'The Ooze', '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'
+        expected_defindexes = [5734, 5735, 5742, 5752, 5781, 5802, 5803]
+        expect(subject.defindex).to match_array expected_defindexes
+      end
+      it 'prices array should have these keys' do
+        expected_keys = ['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 expected_keys
+      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 with Tradable, Non-Tradable & Craftable, Non-Craftable' do
+    item_attr = JSON.parse(file_fixture('item_with_dual_craftability_tradability.json'))['All-Father']
+    subject { described_class.new('All-Father', item_attr) }
+
+    context 'item-specific tests' do
+      it '@prices hash has these keys' do
+        expected = ['Strange_Tradable_Craftable',
+                    'Strange_Tradable_Non-Craftable',
+                    'Strange_Non-Tradable_Craftable',
+                    'Unique_Tradable_Craftable',
+                    'Unique_Tradable_Non-Craftable']
+        expect(subject.prices.keys).to match_array expected
+      end
+    end
+  end
+end

data/spec/backpack_tf/price/particle_effect_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe BackpackTF::Price::ParticleEffect do
+  describe '::read_stored_effects_info' do
+    it 'creates a key value pair for each id & name' do
+      expect(described_class.read_stored_effects_info[17]).to eq 'Sunbeams'
+      expect(described_class.read_stored_effects_info[5]).to eq 'Holy Glow'
+    end
+    it 'is nil if it cannot find that key' do
+      expect(described_class.read_stored_effects_info[nil]).to be_nil
+    end
+
+    context '@list' do
+      it 'same thing can be accessed through class variable' do
+        expect(described_class.list[17]).to eq 'Sunbeams'
+        expect(described_class.list[5]).to eq 'Holy Glow'
+      end
+      it 'is nil if it cannot find that key' do
+        expect(described_class.list[nil]).to be_nil
+      end
+    end
+  end
+end

data/spec/backpack_tf/price/response_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe BackpackTF::Price::Response do
+  let(:response) do
+    {
+      'raw_usd_value' => 'raw_usd_value',
+      'usd_currency' => 'usd_currency',
+      'usd_currency_index' => 'usd_currency_index'
+    }
+  end
+
+  context 'reader methods' do
+    before(:each) do
+      described_class.response = response
+    end
+    after(:each) do
+      described_class.response = nil
+    end
+
+    describe '::raw_usd_value' do
+      it 'returns the value' do
+        expect(described_class.raw_usd_value).to eq 'raw_usd_value'
+      end
+    end
+
+    describe '::usd_currency' do
+      it 'returns the value' do
+        expect(described_class.usd_currency).to eq 'usd_currency'
+      end
+    end
+
+    describe '::usd_currency_index' do
+      it 'returns the value' do
+        expect(described_class.usd_currency_index).to eq 'usd_currency_index'
+      end
+    end
+
+    describe '::items' do
+      after :each do
+        described_class.class_eval { @items = nil }
+      end
+      context 'when @items is not nil' do
+        before :each do
+          described_class.class_eval { @items = { foo: 'bar' } }
+        end
+        it 'returns @items' do
+          expected = described_class.class_eval { @items }
+          expect(described_class.items).to eq expected
+        end
+      end
+
+      context 'when @items is nil' do
+        before :each do
+          described_class.class_eval { @items = nil }
+        end
+        it 'calls .generate_items' do
+          expect(described_class).to receive(:generate_items)
+          described_class.items
+        end
+      end
+    end
+  end
+
+  describe '::generate_items' do
+    let(:json_response) do
+      fixture = file_fixture('prices.json')
+      JSON.parse(fixture)['response']
+    end
+
+    context 'using keys to generate BackpackTF::Item objects' do
+      before(:each) do
+        described_class.response = json_response
+      end
+      after(:each) do
+        described_class.response = nil
+      end
+      it 'each value of hash is a BackpackTF::Price::Item object' do
+        actual = described_class.generate_items.values
+        expect(actual).to all be_a BackpackTF::Price::Item
+      end
+      it 'if an item does not have a valid `defindex`, then it is ignored' do
+        generated_items = described_class.generate_items
+        expect(generated_items['Random Craft Hat']).to be_nil
+      end
+    end
+  end
+end

data/spec/backpack_tf/price_history/interface_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe BackpackTF::PriceHistory::Interface do
+  it 'has these default attributes' do
+    expect(described_class.name).to eq :IGetPriceHistory
+    expect(described_class.version).to eq 1
+    expect(described_class.item).to eq nil
+    expect(described_class.quality).to eq nil
+    expect(described_class.tradable).to eq nil
+    expect(described_class.craftable).to eq nil
+    expect(described_class.priceindex).to eq nil
+  end
+  describe '::defaults' do
+    after(:each) do
+      described_class.class_eval do
+        @item = nil
+        @quality = nil
+        @tradable = nil
+        @craftable = nil
+        @priceindex = nil
+      end
+    end
+    it 'can modify its values' do
+      options = {
+        item: 'item name or defindex',
+        quality: 'quality name or defindex',
+        tradable: 1,
+        craftable: 1,
+        priceindex: 0
+      }
+      described_class.defaults(options)
+      ivars = [:@item, :@quality, :@tradable, :@craftable, :@priceindex]
+      ivars.each do |ivar|
+        expect(described_class.instance_variable_get(ivar)).not_to be_nil
+      end
+    end
+  end
+end

data/spec/backpack_tf/price_history/response_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe BackpackTF::PriceHistory::Response do
+  let(:json_response) do
+    fixture = file_fixture('price_history.json')
+    JSON.parse(fixture)['response']
+  end
+
+  describe '::history' do
+    before(:each) do
+      described_class.response = json_response
+    end
+    after :each do
+      described_class.response = nil
+    end
+
+    it 'each entry is a BackpackTF::PriceHistory object' do
+      actual = BackpackTF::PriceHistory::Response.history
+      expect(actual).to all be_a BackpackTF::PriceHistory
+    end
+  end
+end

data/spec/backpack_tf/price_history_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe BackpackTF::PriceHistory do
+  let(:response_attr) do
+    {
+      'value'      => 2.5,
+      'value_high' => 2.5,
+      'currency'   => 'keys',
+      'timestamp'  => 1346988149
+    }
+  end
+
+  describe '#initialize' do
+    it 'has these these attributes' do
+      price_history = described_class.new(response_attr)
+      expect(price_history).to have_attributes(
+        value: 2.5,
+        value_high: 2.5,
+        currency: 'keys',
+        timestamp: 1346988149
+      )
+    end
+  end
+end

data/spec/backpack_tf/response_spec.rb

@@ -1,124 +1,38 @@
 require 'spec_helper'
 
-module BackpackTF
-
-  describe Response do
-    let (:bp) { Client.new }
-
-    let(:json_obj) {
-      fixture = file_fixture('currencies.json')
-      fixture = JSON.parse(fixture)['response']
-      described_class.hash_keys_to_sym(fixture)
-    }
-
-    let(:more_json) {
-      fixture = file_fixture('currencies_updated.json')
-      fixture = JSON.parse(fixture)['response']
-      described_class.hash_keys_to_sym(fixture)
+describe BackpackTF::Response do
+  let(:response) do
+    {
+      'success' => 'success',
+      'message' => 'message',
+      'current_time' => 'current_time'
     }
+  end
 
-    describe '::interface' do
-      it 'should be nil' do
-        expect(Response.interface).to be_nil
-      end
+  context 'reader methods' do
+    before(:each) do
+      described_class.response = response
     end
-
-    describe '::to_sym' do
-      it 'should return the name of the class, as a Symbol object' do
-        expect(Response.to_sym).to eq :'BackpackTF::Response'
-      end
+    after(:each) do
+      described_class.response = nil
     end
 
-    describe '::responses' do
-      let (:faked_class_sym) { :'BackpackTF::FakedClass' }
-
-      after :all do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        expect(described_class.response).to be_nil
-      end
-
-      it 'returns a Hash object' do
-        expect(Response.responses).to be_instance_of Hash
+    describe '::success' do
+      it 'returns success' do
+        expect(described_class.success).to eq 'success'
       end
-
-      context 'expected input' do
-        it 'has these keys' do
-          stub_http_response_with('currencies.json')
-          expect(bp.fetch(:currencies).keys).to eq ['success', 'currencies', 'name', 'url', 'current_time']
-        end
-      end
-
-      context 'resetting' do
-        before :each do
-          Response.responses(faked_class_sym => json_obj)
-          expect(Response.responses[faked_class_sym]).to eq json_obj
-        end
-        it 'can be emptied by passing in `:reset => :confirm`' do
-          Response.responses(:reset => :confirm)
-          expect(Response.responses).to be_empty
-        end
-      end
-
-      context 'reading' do
-
-        before :each do
-          Response.responses(:reset => :confirm)
-          expect(Response.responses).to be_empty
-        end
-
-        it 'returns the value of the key' do
-          res = { faked_class_sym => json_obj }
-          Response.responses(res)
-          expect(Response.responses[faked_class_sym]).to eq json_obj
-        end
-        it 'returns nil when key has no value' do
-          Response.responses(:foo)
-          expect(Response.responses[:foo]).to be_nil
-        end
-      end
-
-      context 'updating' do
-
-        before :each do
-          Response.responses(:reset => :confirm)
-          expect(Response.responses).to be_empty
-        end
-
-        it "updates a key's value when the key already exists" do
-          entry1 = { faked_class_sym => json_obj }
-          Response.responses(entry1)
-          expect(Response.responses[faked_class_sym]).to eq json_obj
-          entry2 = { faked_class_sym => more_json }
-          Response.responses(entry2)
-          expect(Response.responses[faked_class_sym]).to eq more_json
-        end
-        it 'creates a new key & value if key does not exist' do
-          res = { faked_class_sym => json_obj }
-          expect(Response.responses(res)[faked_class_sym]).to eq json_obj
-        end
-        it 'is not nil when you reference entire hash object' do
-          Response.responses( { faked_class_sym => json_obj } )
-          expect(Response.responses).not_to be_nil
-        end
-      end
-
     end
 
-    describe '::response' do
-      it "returns nil when called by #{described_class}" do
-        expect(described_class.response).to be_nil
+    describe '::message' do
+      it 'returns message' do
+        expect(described_class.message).to eq 'message'
       end
     end
 
-    describe '::hash_keys_to_sym' do
-      it 'changes the type of each key from String to Symbol' do
-        metal = {'quality'=>6, 'priceindex'=>0, 'single'=>'ref', 'plural'=>'ref', 'round'=>2, 'blanket'=>0, 'craftable'=>'Craftable', 'tradable'=>'Tradable', 'defindex'=>5002}
-        hashed_metal = {:quality=>6, :priceindex=>0, :single=>'ref', :plural=>'ref', :round=>2, :blanket=>0, :craftable=>'Craftable', :tradable=>'Tradable', :defindex=>5002}
-         expect(Response.hash_keys_to_sym(metal)).to eq hashed_metal
-        end
+    describe '::current_time' do
+      it 'returns current_time' do
+        expect(described_class.current_time).to eq 'current_time'
+      end
     end
-
   end
-
 end

data/spec/backpack_tf/special_item/interface_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe BackpackTF::SpecialItem::Interface do
+  it 'has these default attributes' do
+    expect(described_class.name).to eq :IGetSpecialItems
+    expect(described_class.version).to eq 1
+  end
+end

data/spec/backpack_tf/special_item/response_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe BackpackTF::SpecialItem::Response do
+  let(:json_response) do
+    fixture = file_fixture('special_items.json')
+    JSON.parse(fixture)['response']
+  end
+
+  describe '::items' do
+    before(:each) do
+      described_class.response = json_response
+    end
+    after(:each) do
+      described_class.response = nil
+    end
+
+    it 'has these 2 keys' do
+      actual_keys = described_class.items.keys
+      expected_keys = [':weed:', 'Random Craft Hat']
+      expect(actual_keys).to match_array expected_keys
+    end
+    it 'each key points to an instance of BackpackTF::SpecialItem' do
+      expect(described_class.items.values).to all be_a BackpackTF::SpecialItem
+    end
+  end
+end