backpack_tf 0.8.4 → 1.0.0.rc1

data/spec/backpack_tf/currency_spec.rb

@@ -1,126 +1,42 @@
 require 'spec_helper'
 
-module BackpackTF
-  describe Currency do
-    let(:bp) { Client.new }
-
-    let(:json_obj) {
-      fixture = file_fixture('currencies.json')
-      fixture = JSON.parse(fixture)['response']
-      Response.hash_keys_to_sym(fixture)
-    }
-
-    let(:more_json) {
-      fixture = file_fixture('currencies_updated.json')
-      fixture = JSON.parse(fixture)['response']
-      Response.hash_keys_to_sym(fixture)
-    }
-
-    it 'class has these default attributes' do
-      expect(described_class.interface).to eq :IGetCurrencies
-    end
-
-    describe '::response' do
-      before :all do
-        expect(described_class.response).to be_nil
-      end
-
-      before :each do
-        stub_http_response_with('currencies.json')
-        fetched_currencies = bp.fetch(:currencies)
-        bp.update(described_class, fetched_currencies)
-      end
-
-      after :all do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        expect(described_class.response).to be_nil
-        expect(described_class.currencies).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 1430784460
-        expect(response[:name]).to eq 'Team Fortress 2'
-        expect(response[:url]).to eq 'http://backpack.tf'
-      end
-    end
-
-    describe '::currencies' do
-      before :all do
-        expect(described_class.response).to be_nil
-        expect(described_class.currencies).to be_nil
-      end
-
-      before :each do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-
-        stub_http_response_with('currencies.json')
-        fetched_currencies = bp.fetch(:currencies)
-        bp.update(described_class, fetched_currencies)
-      end
-
-      after :all do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        described_class.class_eval { @currencies = nil }
-      end
-
-      it 'returns the fixture and sets to @@currencies variable' do
-        expect(described_class.currencies).not_to be_nil
-      end
-
-      it '@@currencies attribute should be a Hash object' do
-        expect(described_class.currencies).to be_instance_of Hash
-      end
-
-      it '@@currencies should have these keys' do
-        expected_keys = [:metal, :keys, :earbuds, :hat]
-        expect(described_class.currencies.keys).to match_array expected_keys
-      end
-    end
-
-    describe '#initialize' do
-
-      before :all do
-        expect(described_class.response).to be_nil
-        expect(described_class.currencies).to be_nil
-      end
-
-      before :each do
-        bp.update(described_class, json_obj)
-        expect(described_class.currencies).not_to be_nil
-      end
-
-      after :all do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        described_class.class_eval { @currencies = nil }
-      end
+describe BackpackTF::Currency do
+  let(:currencies) do
+    fixture = file_fixture('currencies_updated.json')
+    JSON.parse(fixture)['response']
+  end
 
-      subject {
-        described_class.new(:metal, described_class.currencies[:metal])
+  describe '#initialize' do
+    it 'instance should have these values' do
+      processed_currencies = {
+        quality: 6,
+        priceindex: 0,
+        single: 'ref',
+        plural: 'ref',
+        round: '2',
+        craftable: 'Craftable',
+        tradable: 'Tradable',
+        defindex: 5002,
+        blanket: 0
       }
 
-      it 'instance should respond to these methods' do
-        expect(subject).to respond_to(:quality, :priceindex, :single, :plural, :round, :craftable, :tradable, :defindex, :blanket)
-      end
-
-      it 'instance should have these values' do
-        expect(subject.quality).to eq 6
-        expect(subject.priceindex).to eq 0
-        expect(subject.single).to eq 'ref'
-        expect(subject.plural).to eq 'ref'
-        expect(subject.round).to eq 2
-        expect(subject.craftable).to eq :Craftable
-        expect(subject.tradable).to eq :Tradable
-        expect(subject.defindex).to eq 5002
-        expect(subject.blanket).to eq 0
-      end
+      allow_any_instance_of(described_class)
+        .to receive(:hash_keys_to_sym)
+        .and_return(processed_currencies)
+
+      subject = described_class.new(:metal, currencies['metal'])
+
+      expect(subject).to have_attributes(
+        quality: 6,
+        priceindex: 0,
+        single: 'ref',
+        plural: 'ref',
+        round: '2',
+        craftable: :Craftable,
+        tradable: :Tradable,
+        defindex: 5002,
+        blanket: 0
+      )
     end
-
   end
 end

data/spec/backpack_tf/helpers_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe BackpackTF::Helpers do
+  module BackpackTF
+    class DummyClass # :nodoc:
+      include BackpackTF::Helpers
+
+      class Response < BackpackTF::Response # :nodoc:
+        self.response = { foo: 'bar' }
+      end
+    end
+  end
+
+  let(:dummy) { BackpackTF::DummyClass.new }
+
+  # TODO: these tests can be written more succinctly by expecting messages to
+  # be called or to have been called on the DummyClass::Response class.
+  describe '::response' do
+    context 'demonstrating how it normally works' do
+      context 'reading' do
+        it 'the inner Response class has this value for .response' do
+          expected = { foo: 'bar' }
+          expect(BackpackTF::DummyClass::Response.response).to eq(expected)
+        end
+      end
+
+      context 'writing' do
+        before(:each) do
+          BackpackTF::DummyClass::Response.response = { bar: 'foo' }
+        end
+        after(:each) do
+          BackpackTF::DummyClass::Response.class_eval do
+            self.response = { foo: 'bar' }
+          end
+        end
+        it 'can write .response of its own Response class (compare by value)' do
+          expected = { bar: 'foo' }
+          expect(BackpackTF::DummyClass::Response.response).to eq(expected)
+        end
+      end
+    end
+
+    context 'demonstrating how it works with the shortcut' do
+      context 'reading' do
+        it 'can read .response of its own Response class' do
+          expected = BackpackTF::DummyClass::Response.response
+          expect(BackpackTF::DummyClass.response).to eq(expected)
+        end
+      end
+
+      context 'writing' do
+        before(:each) do
+          BackpackTF::DummyClass.response = { bar: 'foo' }
+        end
+        after(:each) do
+          BackpackTF::DummyClass.class_eval { self.response = { foo: 'bar' } }
+        end
+
+        it 'can write to its own Response class (compare by value)' do
+          expected = { bar: 'foo' }
+          expect(BackpackTF::DummyClass.response).to eq(expected)
+        end
+        it 'can write to its own Response class (compare by reference)' do
+          expected = BackpackTF::DummyClass::Response.response
+          expect(BackpackTF::DummyClass.response).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe '#hash_keys_to_sym' do
+    it 'changes each key from a String to a Symbol' do
+      metal = {
+        'quality' => 6,
+        'single' => 'ref'
+      }
+      hashed_metal = {
+        quality: 6,
+        single: 'ref'
+      }
+      actual = dummy.send(:hash_keys_to_sym, metal)
+      expect(actual).to eq hashed_metal
+    end
+  end
+end

data/spec/backpack_tf/interface_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe BackpackTF::Interface do
+  describe '::defaults' do
+    after(:each) do
+      described_class.class_eval do
+        @format = 'json'
+        @callback = nil
+        @appid = '440'
+      end
+    end
+
+    it 'has these attributes & values by default' do
+      expect(described_class).to have_attributes(
+        format: 'json',
+        callback: nil,
+        appid: '440'
+      )
+    end
+    it 'can modify its values' do
+      options = {
+        format: 'foo',
+        callback: 'bar',
+        appid: '2'
+      }
+      described_class.defaults(options)
+      expect(described_class).to have_attributes(
+        format: 'foo',
+        callback: 'bar',
+        appid: '2'
+      )
+    end
+  end
+
+  describe '::url_name_and_version' do
+    before(:each) do
+      allow(described_class).to receive(:name).and_return('interface_name')
+      allow(described_class).to receive(:version).and_return(1)
+    end
+    after(:each) do
+      allow(described_class).to receive(:name).and_return(nil)
+      allow(described_class).to receive(:version).and_return(nil)
+    end
+
+    it 'calls .name and .version' do
+      expect(described_class).to receive(:name)
+      expect(described_class).to receive(:version)
+      described_class.url_name_and_version
+    end
+    it 'returns part of a url' do
+      actual = described_class.url_name_and_version
+      expected = '/interface_name/v1/?'
+      expect(actual).to eq expected
+    end
+  end
+end

data/spec/backpack_tf/market_price/interface_spec.rb

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

data/spec/backpack_tf/market_price/response_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe BackpackTF::MarketPrice::Response do
+  let(:json_response) do
+    fixture = file_fixture('market_prices.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 'each key points to a BackpackTF::MarketPrice object' do
+      items = described_class.items
+      expect(items.values).to all be_a BackpackTF::MarketPrice
+    end
+  end
+end

data/spec/backpack_tf/market_price_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe BackpackTF::MarketPrice do
+  let(:response_attr) do
+    {
+      'last_updated' => 1_453_654_816,
+      'quantity' => 52,
+      'value' => 89
+    }
+  end
+
+  describe '#initialize' do
+    it 'has these attributes' do
+      actual = described_class.new('A Color Similar to Slate', response_attr)
+      expect(actual).to have_attributes(
+        last_updated: 1_453_654_816,
+        quantity: 52,
+        value: 89
+      )
+    end
+  end
+end

data/spec/backpack_tf/price/interface_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe BackpackTF::Price::Interface do
+  it 'has these default attributes' do
+    expect(described_class.name).to eq :IGetPrices
+    expect(described_class.version).to eq 4
+    expect(described_class.raw).to eq nil
+    expect(described_class.since).to eq nil
+  end
+  describe '::defaults' do
+    after(:each) do
+      described_class.class_eval do
+        @raw = nil
+        @since = nil
+      end
+    end
+    it 'can modify its values' do
+      options = {
+        raw: 2,
+        since: '1451606400'
+      }
+      described_class.defaults(options)
+      expect(described_class.raw).to eq 2
+      expect(described_class.since).to eq '1451606400'
+    end
+  end
+end

data/spec/backpack_tf/price/item_price_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe BackpackTF::Price::ItemPrice do
+  let(:item_price) do
+    key = 'Unique_Tradable_Craftable'
+    described_class.new(key, {})
+  end
+
+  describe '::quality_name_to_index' do
+    before(:each) do
+      allow(described_class).to receive(:qualities).and_return([:foo, :bar])
+    end
+
+    it 'returns index of the quality' do
+      actual = described_class.quality_name_to_index(:bar)
+      expect(actual).to eq 1
+    end
+  end
+
+  describe '#split_key' do
+    it 'splits the string by the underscore' do
+      actual = item_price.send(:split_key, 'foo_bar_quux')
+      expected = %w(foo bar quux)
+      expect(actual).to eq expected
+    end
+  end
+
+  describe '#currency_or_nil' do
+    it 'returns nil when key is not present' do
+      attr = { 'foo' => 'bar' }
+      actual = item_price.send(:currency_or_nil, attr)
+      expect(actual).to be_nil
+    end
+
+    it 'otherwise returns values as a symbol' do
+      attr = { 'currency' => 'foo' }
+      actual = item_price.send(:currency_or_nil, attr)
+      expect(actual).to eq :foo
+    end
+  end
+
+  describe '#pick_particle_effect' do
+    it 'calls ParticleEffect.list' do
+      expect(BackpackTF::Price::ParticleEffect)
+        .to receive(:list)
+        .and_return([:foo, :bar])
+        .at_most(:twice)
+      item_price.send(:pick_particle_effect, '0')
+    end
+  end
+
+  describe 'A price for a typical item' do
+    item_price_attr = JSON.parse(file_fixture('item_price_typical.json'))
+
+    subject do
+      described_class.new('Unique_Tradable_Craftable', item_price_attr)
+    end
+
+    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 1_336_410_088
+        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_price_unusual.json'))
+
+    subject do
+      described_class.new('Unusual_Tradable_Craftable', item_price_attr, 6)
+    end
+
+    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 1_418_795_322
+        expect(subject.difference).to eq 280
+        expect(subject.priceindex).to eq 6
+        expect(subject.effect).to eq 'Green Confetti'
+      end
+    end
+  end
+end