bgg 1.0.0

data/spec/bgg_play_spec.rb

@@ -0,0 +1,166 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Bgg::Play do
+  describe 'instance' do
+    let(:item_data) { {'id'=>'7680984',
+                       'date'=>'2012-06-23',
+                       'quantity'=>'1',
+                       'length'=>'0',
+                       'incomplete'=>'0',
+                       'nowinstats'=>'0',
+                       'location'=>'',
+                       'item'=>[{'name'=>'Cheeky Monkey', 'objecttype'=>'thing', 'objectid'=>'29773', 'subtypes'=>[{'subtype'=>[{'value'=>'boardgame'}]}]}]} }
+
+    let(:item) { Bgg::Play.new(item_data) }
+
+    describe '.id' do
+      it 'exists' do
+        expect( item ).to respond_to(:id)
+      end
+
+      it 'returns correct value' do
+        expect( item.id ).to eq(7680984)
+      end
+    end
+
+    describe '.date' do
+      it 'exists' do
+        expect( item ).to respond_to(:date)
+      end
+
+      # FIXME: should move to an actual date object
+      it 'returns the correct value' do
+        expect( item.date ).to eq('2012-06-23')
+      end
+    end
+
+    describe '.quantity' do
+      it 'exists' do
+        expect( item ).to respond_to(:quantity)
+      end
+
+      it 'returns the correct value' do
+        expect( item.quantity ).to eq(1)
+      end
+    end
+
+    describe '.length' do
+      it 'exists' do
+        expect( item ).to respond_to(:length)
+      end
+
+      it 'returns the correct value' do
+        expect( item.length ).to eq(0)
+      end
+    end
+
+    describe '.incomplete?' do
+      it 'exists' do
+        expect( item ).to respond_to(:incomplete?)
+      end
+
+      it 'returns true when incomplete == 0' do
+        item_data['incomplete'] = '0'
+        expect( item.incomplete? ).to eq(false)
+      end
+
+      it 'returns true when incomplete == 1' do
+        item_data['incomplete'] = '1'
+        expect( item.incomplete? ).to eq(true)
+      end
+    end
+
+    describe '.location' do
+      it 'exists' do
+        expect( item ).to respond_to(:location)
+      end
+
+      it 'returns empty string when it is empty' do
+        expect( item.location ).to eq('')
+      end
+
+      it 'returns a string when it is filled in' do
+        item_data['location'] = 'BGGCon!'
+        expect( item.location ).to eq('BGGCon!')
+      end
+    end
+
+    describe '.nowinstats?' do
+      it 'exists' do
+        expect( item ).to respond_to(:nowinstats?)
+      end
+
+      it 'returns true when nowinstats == 1' do
+        item_data['nowinstats'] = '1'
+        expect( item.nowinstats? ).to eq(true)
+      end
+
+      it 'returns false when nowinstats == 0' do
+        item_data['nowinstats'] = '0'
+        expect( item.nowinstats? ).to eq(false)
+      end
+    end
+
+    describe '.players' do
+      it 'exists' do
+        expect( item ).to respond_to(:players)
+      end
+
+      it 'returns the list of players' do
+        expect( item.players ).to match_array([])
+      end
+    end
+
+    describe '.game_name' do
+      it 'exists' do
+        expect( item ).to respond_to(:game_name)
+      end
+
+      it 'returns the correct value' do
+        expect( item.game_name ).to eq('Cheeky Monkey')
+      end
+    end
+
+    describe '.game_id' do
+      it 'exists' do
+        expect( item ).to respond_to(:game_id)
+      end
+
+      it 'returns the correct value' do
+        expect( item.game_id ).to eq(29773)
+      end
+    end
+
+    describe '.game_type' do
+      it 'exists' do
+        expect( item ).to respond_to(:game_type)
+      end
+
+      it 'returns the correct value' do
+        expect( item.game_type ).to eq('boardgame')
+      end
+    end
+
+    describe '.game' do
+      it 'exists' do
+        expect( item ).to respond_to(:game)
+      end
+
+      it 'returns a Bgg::Game object corresponding to the entry' do
+        response_file = 'sample_data/thing?id=29773&type=boardgame'
+        request_url = 'http://www.boardgamegeek.com/xmlapi2/thing'
+
+        stub_request(:any, request_url).
+          with(query: {id: 29773, type: 'boardgame'}).
+          to_return(body: File.open(response_file), status: 200)
+
+        game = item.game
+
+        expect( game ).to be_instance_of(Bgg::Game)
+        expect( game.name ).to eq('Cheeky Monkey')
+        expect( game.designers ).to eq(['Reiner Knizia'])
+      end
+    end
+  end
+end

data/spec/bgg_plays_iterator_spec.rb

@@ -0,0 +1,156 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Bgg::Plays::Iterator do
+  describe 'instance' do
+    let(:username) { 'texasjdl' }
+    let(:request_url) { 'http://www.boardgamegeek.com/xmlapi2/plays' }
+    let(:query) { {username: username, page: 1} }
+    let(:response_file) { "sample_data/plays?username=#{username}&page=1" }
+    let(:iterator) { Bgg::Plays::Iterator.new(username) }
+
+    before do
+      stub_request(:any, request_url).
+        with(query: query).
+        to_return(body: File.open(response_file), status: 200)
+    end
+
+    it 'is Enumerable' do
+      expect( iterator ).to be_a_kind_of(Enumerable)
+    end
+
+    context 'when the user has no plays' do
+      let(:username) { 'beetss' }
+      it 'returns an empty iterator' do
+        expect( iterator.empty? ).to eq(true)
+      end
+    end
+
+    context 'when the user does not exist' do
+      let(:username) { 'yyyyyyy' }
+      it 'returns an empty iterator' do
+        expect{ iterator }.to raise_error(ArgumentError, 'user does not exist')
+      end
+    end
+
+    context 'when the user exists and has plays' do
+      it 'returns an instance' do
+        expect( iterator ).to be_instance_of(Bgg::Plays::Iterator)
+      end
+    end
+
+    describe '.each' do
+      it 'exists' do
+        expect( iterator ).to respond_to(:each)
+      end
+
+      it 'allows stepping through results' do
+        iterator.each do |item|
+          expect( item ).to be_instance_of(Bgg::Play)
+          break if iterator.iteration == 3
+        end
+      end
+
+      it 'only allows stepping through the results once' do
+        iterator.each { break if iterator.iteration == 2 }
+        iterator.each { fail }
+      end
+
+      it 'returns multiple pages of results' do
+        [2,3].each do |i|
+          stub_request(:any, request_url).
+            with(query: {username: username, page: i}).
+            to_return(body: File.open("sample_data/plays?username=#{username}&page=#{i}"),
+                      status: 200)
+        end
+
+        iterator.each { }
+        expect( iterator.iteration ).to eq(299)
+      end
+    end
+
+    describe '.iteration' do
+      it 'exists' do
+        expect( iterator ).to respond_to(:iteration)
+      end
+
+      it 'returns the maximum value when the iterator is exhausted' do
+        count = 0
+        iterator.each do |item|
+          count += 1
+          expect( iterator.iteration ).to eq(count)
+          break if iterator.iteration == 3
+        end
+      end
+
+      it 'returns the current iteration through the block' do
+        count = 0
+        iterator.each do |item|
+          count += 1
+          expect( iterator.iteration ).to eq(count)
+          break if iterator.iteration == 3
+        end
+      end
+
+      context 'when the iterator starts empty,' do
+        let(:username) { 'beetss' }
+        it 'returns 0' do
+          expect( iterator.iteration ).to eq(0)
+        end
+      end
+    end
+
+    describe '.empty?' do
+      it 'exists' do
+        expect( iterator ).to respond_to(:empty?)
+      end
+
+      context 'when the iterator has no results' do
+        let(:username) { 'beetss' }
+        it 'returns true' do
+          expect( iterator.empty? ).to eq(true)
+        end
+      end
+
+      context 'when the iterator has results' do
+        it 'returns false' do
+          expect( iterator.empty? ).to eq(false)
+        end
+      end
+
+      context 'when the iterator has paged through results' do
+        it 'returns true if each() has already reached the end' do
+          [2,3].each do |i|
+            stub_request(:any, request_url).
+              with(query: {username: username, page: i}).
+              to_return(body: File.open("sample_data/plays?username=#{username}&page=#{i}"),
+                        status: 200)
+          end
+
+          iterator.each{ }
+          expect( iterator.empty? ).to eq(true)
+        end
+      end
+    end
+
+    describe '.total_count' do
+      it 'exists' do
+        expect( iterator ).to respond_to(:total_count)
+      end
+
+      context 'when the user has no plays' do
+        let(:username) { 'beetss' }
+        it 'returns 0' do
+          expect( iterator.total_count ).to eq(0)
+        end
+      end
+
+      context 'when the user has plays' do
+        let(:username) { 'texasjdl' }
+        it 'returns the correct count' do
+          expect( iterator.total_count ).to eq(299)
+        end
+      end
+    end
+  end
+end

data/spec/bgg_plays_spec.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Bgg::Plays do
+  describe 'class method' do
+    describe 'find_by_username' do
+      it 'throws an ArgumentError when a number is passed in' do
+        expect{ Bgg::Collection.find_by_username(38383) }.to raise_error(ArgumentError)
+      end
+
+      it 'throws an ArgumentError when an empty string is passed in' do
+        expect{ Bgg::Collection.find_by_username('') }.to raise_error(ArgumentError)
+      end
+
+      it 'throws an ArgumentError when a string of only numbers is passed in' do
+        expect{ Bgg::Collection.find_by_username('38383') }.to raise_error(ArgumentError)
+      end
+
+      it 'throws an ArgumentError when a non-existent user is passed in' do
+        response_file = 'sample_data/plays?username=yyyyyyy&page=1'
+        request_url = 'http://www.boardgamegeek.com/xmlapi2/plays'
+
+        stub_request(:any, request_url).
+          with(query: {username: 'yyyyyyy', page: 1}).
+          to_return(body: File.open(response_file), status: 200)
+
+        expect{ Bgg::Plays.find_by_username('yyyyyyy') }.to raise_error(ArgumentError)
+      end
+
+      it 'returns an empty iterator when a valid user has no plays' do
+        response_file = 'sample_data/plays?username=beetss&page=1'
+        request_url = 'http://www.boardgamegeek.com/xmlapi2/plays'
+
+        stub_request(:any, request_url).
+          with(query: {username: 'beetss', page: 1}).
+          to_return(body: File.open(response_file), status: 200)
+
+        iterator = Bgg::Plays.find_by_username('beetss')
+        expect( iterator ).to be_an_instance_of(Bgg::Plays::Iterator)
+        expect( iterator.empty? ).to eq(true)
+      end
+
+      it 'creates a Bgg::Plays::Iterator object for a user who has plays' do
+        response_file = 'sample_data/plays?username=texasjdl&page=1'
+        request_url = 'http://www.boardgamegeek.com/xmlapi2/plays'
+
+        stub_request(:any, request_url).
+          with(query: {username: 'texasjdl', page: 1}).
+          to_return(body: File.open(response_file), status: 200)
+
+        plays = Bgg::Plays.find_by_username('texasjdl')
+        first_play = plays.first
+
+        expect( plays ).to be_a_kind_of(Bgg::Plays::Iterator)
+        expect( first_play ).to be_instance_of(Bgg::Play)
+        expect( first_play.players ).to be_instance_of(Array)
+      end
+    end
+  end
+end

data/spec/bgg_search_result_spec.rb

@@ -0,0 +1,73 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Bgg::Search::Result do
+  describe 'instance' do
+    let(:item_data) { {'type'=>'boardgame',
+                       'id'=>'84876',
+                       'name'=>[{'type'=>'primary', 'value'=>'The Castles of Burgundy'}],
+                       'yearpublished'=>[{'value'=>'2011'}]} }
+    let(:search_result) { Bgg::Search::Result.new(item_data) }
+
+    describe '.id' do
+      it 'exists' do
+        expect( search_result ).to respond_to(:id)
+      end
+
+      it 'returns correct value' do
+        expect( search_result.id ).to eq(84876)
+      end
+    end
+
+    describe '.name' do
+      it 'exists' do
+        expect( search_result ).to respond_to(:name)
+      end
+
+      it 'returns the correct value' do
+        expect( search_result.name ).to eq('The Castles of Burgundy')
+      end
+    end
+
+    describe '.type' do
+      it 'exists' do
+        expect( search_result ).to respond_to(:type)
+      end
+
+      it 'returns boardgame when it is a boardgame' do
+        expect( search_result.type ).to eq('boardgame')
+      end
+    end
+
+    describe '.year_published' do
+      it 'exists' do
+        expect( search_result ).to respond_to(:year_published)
+      end
+
+      it 'returns the year it was published' do
+        expect( search_result.year_published ).to eq(2011)
+      end
+    end
+
+    describe '.game' do
+      it 'exists' do
+        expect( search_result ).to respond_to(:game)
+      end
+
+      it 'returns a Bgg::Game object corresponding to the entry' do
+        response_file = 'sample_data/thing?id=84876&type=boardgame'
+        request_url = 'http://www.boardgamegeek.com/xmlapi2/thing'
+
+        stub_request(:any, request_url).
+          with(query: {id: 84876, type: 'boardgame'}).
+          to_return(body: File.open(response_file), status: 200)
+
+        game = search_result.game
+
+        expect( game ).to be_instance_of(Bgg::Game)
+        expect( game.name ).to eq('The Castles of Burgundy')
+        expect( game.designers ).to eq(['Stefan Feld'])
+      end
+    end
+  end
+end