backpack_tf 0.8.4 → 1.0.0.rc1

data/lib/backpack_tf/user.rb

@@ -1,21 +1,10 @@
-module BackpackTF
-  class User < Response
-    INTERFACE = :IGetUsers
-    @interface = INTERFACE
-    @response = nil
-    @@players = {}
-
-    def self.response
-      @response = superclass.responses[to_sym]
-    end
+require 'backpack_tf/user/interface'
+require 'backpack_tf/user/response'
 
-    def self.players
-      return @response if response.nil?
-      @@players = response[:players].inject({}) do |players, (steamid, attr)|
-        players[steamid] = new(attr)
-        players 
-      end
-    end
+module BackpackTF
+  # Ruby representations of a JSON response to IGetUsers
+  class User
+    include Helpers
 
     attr_reader :steamid
     attr_reader :success
@@ -32,8 +21,10 @@ module BackpackTF
     attr_reader :ban_vac
     attr_reader :notifications
 
-    def initialize attr
-      attr = check_attr_keys(attr)
+    # @param attr [Hash] Attributes.
+    # @return [User] A new User object.
+    def initialize(attr)
+      attr = hash_keys_to_sym(attr)
 
       @steamid                = attr[:steamid]
       @success                = attr[:success]

data/lib/backpack_tf/user_listing/interface.rb

@@ -0,0 +1,18 @@
+module BackpackTF
+  class UserListing
+    # Access the IGetUserListings interface
+    class Interface < BackpackTF::Interface
+      class << self
+        attr_reader :steamid
+      end
+
+      @name = :IGetUserListings
+      @version = 2
+
+      def self.defaults(options)
+        @steamid = options[:steamid] || nil
+        super(options)
+      end
+    end
+  end
+end

data/lib/backpack_tf/user_listing/response.rb

@@ -0,0 +1,15 @@
+module BackpackTF
+  class UserListing
+    # Process reponses from IGetUserListings
+    class Response < BackpackTF::Response
+      @response = nil
+      @listings = []
+
+      def self.listings
+        @listings = response['listings'].map do |attr|
+          BackpackTF::UserListing.new(attr)
+        end
+      end
+    end
+  end
+end

data/lib/backpack_tf/user_listing.rb

@@ -1,60 +1,48 @@
-module BackpackTF
-  class UserListing < Response
-
-    INTERFACE = :IGetUserListings
-
-    @interface = INTERFACE
-    @response = nil
-    @@listings = []
+require 'backpack_tf/user_listing/interface'
+require 'backpack_tf/user_listing/response'
 
-    def self.interface; @interface; end
-
-    def self.response
-      @response = superclass.responses[to_sym]
-    end
-
-    def self.listings
-      return @response if response.nil?
-      @@listings = response[:listings].inject([]) do |listings, attr|
-        listings << new(attr)
-        listings
-      end
-    end
+module BackpackTF
+  # Ruby representations of a JSON response to IGetUserListings
+  class UserListing
+    include Helpers
 
-    attr_reader :id
     attr_reader :bump
-    attr_reader :created
+    attr_reader :intent
     attr_reader :currencies
-    attr_reader :item
-    attr_reader :details
-    attr_reader :meta
     attr_reader :buyout
+    attr_reader :details
+    attr_reader :item
+    attr_reader :flags
+    attr_reader :created
+    attr_reader :id
 
-    def initialize attr
-      attr = check_attr_keys(attr)
-
-      @id = attr[:id].to_sym
-      @bump = attr[:bump]
-      @created = attr[:created]
-      @currencies = attr[:currencies]
-      @item = set_keys_of_key_to_symbols(attr[:item], 'attributes')
-      @details = attr[:details]
-      @meta = self.class.hash_keys_to_sym(attr[:meta])
-      @buyout = attr[:buyout]
+    # @param attr [Hash] Attributes.
+    # @return [UserListing] A new UserListing object.
+    def initialize(attr)
+      attr = hash_keys_to_sym(attr)
+
+      @bump       = attr[:bump]
+      @intent     = attr[:intent]
+      @currencies = hash_keys_to_sym(attr[:currencies])
+      @buyout     = attr[:buyout]
+      @details    = attr[:details]
+      @item       = set_keys_of_key_to_symbols(attr[:item], 'attributes')
+      @flags      = hash_keys_to_sym(attr[:flags])
+      @created    = attr[:created]
+      @id         = attr[:id]
     end
 
     private
-    # Similar to Response.hash_key_to_sym, except you are returning
-    # an Array of Hash objects instead of a Hash.
-    def set_keys_of_key_to_symbols attr, key
-      return nil unless attr.has_key? key
+
+    def set_keys_of_key_to_symbols(attr, key)
+      return nil unless attr.key?(key)
 
       item_attributes = attr[key].map do |set_of_attr|
-        self.class.hash_keys_to_sym(set_of_attr)
+        hash_keys_to_sym(set_of_attr)
       end
       attr[key] = item_attributes
 
-      self.class.hash_keys_to_sym(attr)
+      hash_keys_to_sym(attr)
     end
   end
 end

data/lib/backpack_tf/version.rb

@@ -1,3 +1,3 @@
 module BackpackTF
-  VERSION = "0.8.4"
+  VERSION = '1.0.0.rc1'.freeze
 end

data/lib/backpack_tf.rb

@@ -1,18 +1,18 @@
 require 'httparty'
 
-# namespace for classes & modules inside of the wrapper for the BackpackTF API
-module BackpackTF
-
-end
-
-# IMPORTANT! require the Response module before any other class or module
 require 'backpack_tf/version'
 require 'backpack_tf/response'
+require 'backpack_tf/interface'
 require 'backpack_tf/client'
+require 'backpack_tf/helpers'
 require 'backpack_tf/currency'
-require 'backpack_tf/item'
-require 'backpack_tf/item_price'
 require 'backpack_tf/price'
 require 'backpack_tf/special_item'
 require 'backpack_tf/user'
 require 'backpack_tf/user_listing'
+require 'backpack_tf/price_history'
+require 'backpack_tf/market_price'
+
+# backpack.tf API library
+module BackpackTF
+end

data/spec/backpack_tf/client_spec.rb

@@ -1,133 +1,183 @@
 require 'spec_helper'
 
-module BackpackTF
-  describe 'Client' do
-    let(:bp) { Client.new }
+describe BackpackTF::Client do
+  let(:key) { 'deadbeef01234567deadbeef' }
+  let(:bp) { BackpackTF::Client.new(key) }
+
+  describe '#initialize' do
+    it 'calls #check_key' do
+      expect_any_instance_of(described_class).to receive(:check_key)
+      described_class.new(key)
+    end
+    it 'sets a value for @key' do
+      client = described_class.new(key)
+      expect(client.instance_eval { @key }).to eq 'deadbeef01234567deadbeef'
+    end
+    it 'calls #httparty_settings' do
+      expect_any_instance_of(described_class).to receive(:httparty_settings)
+      described_class.new(key)
+    end
+  end
 
-    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
+  describe '#fetch' do
+    it 'calls #get_data' do
+      mock_response = { 'response' => nil }
+      expect(bp).to receive(:get_data).and_return(mock_response)
+      bp.fetch(:foo)
     end
+    it 'fetches JSON from an interface and returns a response' do
+      stub_http_response_with('currencies.json')
+      response = bp.fetch(:currencies, compress: 1, appid: 440)
+      response.keys.all? do |key|
+        expect(response[key]).not_to be_nil
+      end
+    end
+  end
 
-    describe '::api_key' do
+  describe '#get_data' do
+    it 'calls #handle_timeout' do
+      allow(described_class).to receive(:get).and_return('get')
+      allow(bp).to receive(:build_url_via).and_return('url')
+      expect(bp).to receive(:handle_timeouts)
+      bp.send(:get_data, :foo)
+    end
+    it 'calls #build_url_via' do
+      allow(described_class).to receive(:get).and_return('get')
+      expect(bp).to receive(:build_url_via).and_return('url')
+      bp.send(:get_data, :foo)
+    end
+    it 'calls HTTParty.get' do
+      allow(bp).to receive(:build_url_via).and_return('url')
+      expect(described_class).to receive(:get)
+      bp.send(:get_data, :foo)
+    end
+  end
+
+  describe 'handle_timeouts' do
+    specify do
+      expect { |mtd| bp.send(:handle_timeouts, &mtd) }.to yield_control
+    end
+    it 'rescues on Net::OpenTimeout or Net::ReadTimeout exceptions' do
+      bp.send(:handle_timeouts) { raise Net::OpenTimeout }
+    end
+  end
+
+  describe('#httparty_settings') do
+    before(:each) do
+      bp.instance_eval { @key = 'foo' }
+    end
+    after(:each) do
+      bp.instance_eval { @key = nil }
+    end
+
+    it 'sets some default_options for HTTParty' do
+      bp.send(:httparty_settings)
+
+      actual = described_class.default_options
+      expect(actual[:base_uri]).not_to be_nil
+      expect(actual[:timeout]).not_to be_nil
+      expect(actual[:default_params][:key]).not_to be_nil
+    end
+  end
+
+  describe '#check_key' do
+    context('without a key') do
+      it 'gently reminds user to set an API key' do
+        expect(bp).to receive(:warn)
+        bp.send(:check_key)
+      end
+    end
+    context('checking a 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
+        expect { bp.send(:check_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
+        expect { bp.send(:check_key, fake_key) }.to raise_error ArgumentError
       end
-      it 'lets an otherwise theoretically-valid key, pass through' do
+      it 'lets an otherwise theoretically-valid key pass through' do
         key = generate_fake_api_key
-        expect(Client.api_key(key)).to eq key
+        expect(bp.send(:check_key, key)).to eq key
       end
     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
+    before(:each) do
+      allow(bp).to receive(:warn).and_return true
     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  
+    it 'returns correct destination url when asking for pricing data' do
+      query_opts = {
+        key: key,
+        compress: 1
+      }
 
-    describe '#fetch' do
+      actual = bp.send(:build_url_via, :prices, query_opts)
+      expected = "http://backpack.tf/api/IGetPrices/v4/?key=#{key}&compress=1"
 
-      before :each do
-        stub_http_response_with('currencies.json')
-      end
+      expect(actual).to eq expected
+    end
+  end
 
-      let(:fetched_currencies) {
-        bp.fetch(:currencies, {:compress => 1, :appid => 440})
+  describe '#extract_query_string' do
+    it 'produces a query parameter string' do
+      opts = {
+        key: key,
+        appid: 440,
+        format: 'json',
+        compress: 1,
+        raw: 2
       }
 
-      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
+      expected = "key=#{key}&appid=440&format=json&compress=1&raw=2"
+      expect(bp.send(:extract_query_string, opts)).to eq expected
+    end
+    it 'separates array values by comma' do
+      opts = {
+        steamids: %w(1 2 3)
+      }
 
+      expected = 'steamids=1,2,3'
+      expect(bp.send(:extract_query_string, opts)).to eq expected
     end
+  end
 
-    describe '#update' do
-      #context "USING rspec/mock, updating another another class' class variable" do
-      #  before :each do
-      #    MockResponse = class_double(Response)
-      #    MockCurrency = class_double(Currency)
-
-      #    allow(MockResponse).to receive(:responses) { 
-      #      { MockCurrency => fetched_currencies }
-      #    }
-      #    expect(MockResponse.responses.keys).to eq [MockCurrency]
-
-      #    allow(MockCurrency).to receive(:response) {
-      #      Response.hash_keys_to_sym(MockResponse.responses[MockCurrency])
-      #    }
-      #    expect(MockCurrency.response.keys).to eq [:success, :currencies, :name, :url, :current_time]
-
-      #    allow(MockCurrency).to receive(:currencies)
-      #    #expect(MockCurrency.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(MockCurrency => fetched_currencies)
-      #    MockCurrency.response
-      #    expect(MockCurrency.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(Currency.response).to be_nil
-        expect(Currency.currencies).to be_nil
+  describe '#select_interface_url_fragment' do
+    context 'verifying API base urls' do
+      it 'gets it right for IGetCurrencies' do
+        actual = bp.send(:select_interface_url_fragment, :currencies)
+        expect(actual).to eq '/IGetCurrencies/v1/?'
       end
-
-      after :each do
-        Response.responses(:reset => :confirm)
-        expect(Response.responses).to be_empty
-        expect(Currency.response).to be_nil
-        expect(Currency.currencies).to be_nil
+      it 'gets it right for IGetMarketPrices' do
+        actual = bp.send(:select_interface_url_fragment, :market_prices)
+        expect(actual).to eq '/IGetMarketPrices/v1/?'
       end
-
-      let(:fetched_currencies) {
-        bp.fetch(:currencies, {:compress => 1, :appid => 440})
-      }
-
-      context 'results on the Currency.response method' do
-        it 'returns this Hash object' do
-          bp.update(Currency, fetched_currencies)
-          processed_json = Response.hash_keys_to_sym(fetched_currencies)
-          expect(Currency.response).to eq processed_json
-        end
+      it 'gets it right for IGetPrices' do
+        actual = bp.send(:select_interface_url_fragment, :prices)
+        expect(actual).to eq '/IGetPrices/v4/?'
       end
-
-      context 'results on the Currency.currencies method' do
-        it 'returns this Hash object' do
-          bp.update(Currency, fetched_currencies)
-          processed_json = Response.hash_keys_to_sym(fetched_currencies['currencies'])
-          expect(Currency.currencies).to eq processed_json
-        end
+      it 'gets it right for IGetPriceHistory' do
+        actual = bp.send(:select_interface_url_fragment, :price_history)
+        expect(actual).to eq '/IGetPriceHistory/v1/?'
+      end
+      it 'gets it right for IGetSpecialItems' do
+        actual = bp.send(:select_interface_url_fragment, :special_items)
+        expect(actual).to eq '/IGetSpecialItems/v1/?'
+      end
+      it 'gets it right for IGetUsers' do
+        actual = bp.send(:select_interface_url_fragment, :users)
+        expect(actual).to eq '/IGetUsers/v3/?'
+      end
+      it 'gets it right for IGetUserListings' do
+        actual = bp.send(:select_interface_url_fragment, :user_listings)
+        expect(actual).to eq '/IGetUserListings/v2/?'
       end
-
     end
-
+    it 'returns nil when it cannot match to an action' do
+      actual = bp.send(:select_interface_url_fragment, :foobar)
+      expect(actual).to be_nil
+    end
   end
 end

data/spec/backpack_tf/currency/interface_spec.rb

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

data/spec/backpack_tf/currency/response_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe BackpackTF::Currency::Response do
+  let(:json_response) do
+    fixture = file_fixture('currencies_updated.json')
+    JSON.parse(fixture)['response']
+  end
+
+  context 'reader methods' do
+    before(:each) do
+      described_class.response = json_response
+    end
+    after(:each) do
+      described_class.response = nil
+    end
+
+    describe '::currencies' do
+      it 'should have these keys' do
+        currencies = described_class.currencies
+        expected_keys = %w(metal keys earbuds hat)
+        expect(currencies.keys).to match_array expected_keys
+      end
+      it 'each key points to an instance of BackpackTF::Currency' do
+        currencies = described_class.currencies
+        expect(currencies.values).to all be_a BackpackTF::Currency
+      end
+    end
+
+    describe '::name' do
+      it 'returns the value' do
+        expect(described_class.name).to eq 'Team Fortress 2'
+      end
+    end
+
+    describe '::url' do
+      it 'returns the value' do
+        expect(described_class.url).to eq 'http://backpack.tf'
+      end
+    end
+  end
+end