giant_bomb_api 0.5.1

data/spec/fixtures/search-response.json

@@ -0,0 +1,59 @@
+{
+  "error": "OK",
+  "limit": 100,
+  "offset": 0,
+  "number_of_page_results": 1,
+  "number_of_total_results": 1,
+  "status_code": 1,
+  "results": [
+    {
+      "aliases": "Drive Club\r\n#DRIVECLUB",
+      "api_detail_url": "http://www.giantbomb.com/api/game/3030-41693/",
+      "date_added": "2013-02-20 15:57:29",
+      "date_last_updated": "2014-11-30 06:30:47",
+      "deck": "Driveclub is a team-based racing game from Evolution Studios for PlayStation 4.",
+      "description": "<p style=\"\"> </p>",
+      "expected_release_day": null,
+      "expected_release_month": null,
+      "expected_release_quarter": null,
+      "expected_release_year": null,
+      "id": 41693,
+      "image": {
+        "icon_url": "http://static.giantbomb.com/uploads/square_avatar/8/82063/2560905-driveclub.jpg",
+        "medium_url": "http://static.giantbomb.com/uploads/scale_medium/8/82063/2560905-driveclub.jpg",
+        "screen_url": "http://static.giantbomb.com/uploads/screen_medium/8/82063/2560905-driveclub.jpg",
+        "small_url": "http://static.giantbomb.com/uploads/scale_small/8/82063/2560905-driveclub.jpg",
+        "super_url": "http://static.giantbomb.com/uploads/scale_large/8/82063/2560905-driveclub.jpg",
+        "thumb_url": "http://static.giantbomb.com/uploads/scale_avatar/8/82063/2560905-driveclub.jpg",
+        "tiny_url": "http://static.giantbomb.com/uploads/square_mini/8/82063/2560905-driveclub.jpg"
+      },
+      "name": "Driveclub",
+      "number_of_user_reviews": 0,
+      "original_game_rating": [
+        {
+          "api_detail_url": "http://www.giantbomb.com/api/game_rating/3065-7/",
+          "id": 7,
+          "name": "PEGI: 3+"
+        },
+        {
+          "api_detail_url": "http://www.giantbomb.com/api/game_rating/3065-25/",
+          "id": 25,
+          "name": "CERO: A"
+        }
+      ],
+      "original_release_date": "2014-10-07 00:00:00",
+      "platforms": [
+        {
+          "api_detail_url": "http://www.giantbomb.com/api/platform/3045-146/",
+          "id": 146,
+          "name": "PlayStation 4",
+          "site_detail_url": "http://www.giantbomb.com/playstation-4/3045-146/",
+          "abbreviation": "PS4"
+        }
+      ],
+      "site_detail_url": "http://www.giantbomb.com/driveclub/3030-41693/",
+      "resource_type": "game"
+    }
+  ],
+  "version": "1.0"
+}

data/spec/lib/collection_resource_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe GiantBombApi::CollectionResource do
+
+  class DummyCollection
+    extend GiantBombApi::CollectionResource
+  end
+
+  class AnotherDummyCollection
+    extend GiantBombApi::CollectionResource
+
+    collection_resource_name "some_dummy_collection"
+  end
+
+  describe 'extension' do
+    it 'will also extend from GiantBombApi::Resource' do
+      expect(DummyCollection).to be_a GiantBombApi::Resource
+    end
+  end
+
+  describe '#collection_resource_name' do
+
+    context "when in a class the collection_resource_name has been defined" do
+      it 'returns the collection_resource_name of that class' do
+        expect(AnotherDummyCollection.collection_resource_name).to eq "some_dummy_collection"
+      end
+    end
+
+    context "when in a class the collection_resource_name has NOT been defined" do
+      it 'returns the pluralized form of the resource_name' do
+        expect(DummyCollection.collection_resource_name).to eq "dummy_collections"
+      end
+    end
+
+  end
+
+  describe '#where' do
+    let(:client) { double("GiantBombApi::Client") }
+    before do 
+      allow(GiantBombApi).to receive(:client).and_return(client)
+    end
+
+    context "when given NO additional attributes" do
+      let(:dummy_collection_request) { double("DummyCollectionRequest") }
+      let(:response) { double("GiantBombApi::Response") }
+
+      it 'will send a blank collection-request for itself' do
+        expect(GiantBombApi::Request::Collection).to receive(:new).with(DummyCollection).and_return(dummy_collection_request)
+        expect(client).to receive(:send_request).with(dummy_collection_request).and_return(response)
+        expect(DummyCollection.where).to eq response
+      end
+    end
+    context "when given a hash that does not contain :sort, :offset or :limit" do
+      let(:dummy_collection_request) { double("DummyCollectionRequest") }
+      let(:response) { double("GiantBombApi::Response") }
+
+      it 'will send a collection-request with the given has as a filter' do
+        expect(GiantBombApi::Request::Collection).to receive(:new).with(DummyCollection, filter: { name: "something", aliases: "other" }).and_return(dummy_collection_request)
+        expect(client).to receive(:send_request).with(dummy_collection_request).and_return(response)
+        expect(DummyCollection.where(name: "something", aliases: "other")).to eq response
+      end
+    end
+
+    context "when given a hash that contains :sort, :offset and :limit" do
+      let(:dummy_collection_request) { double("DummyCollectionRequest") }
+      let(:response) { double("GiantBombApi::Response") }
+
+      it 'will send a collection-request with the the parameters assorted correctly' do
+        expect(GiantBombApi::Request::Collection).to receive(:new).with(DummyCollection, filter: { name: "something", aliases: "other" }, sort: {something: :desc}, limit: 10, offset: 1).and_return(dummy_collection_request)
+        expect(client).to receive(:send_request).with(dummy_collection_request).and_return(response)
+        expect(DummyCollection.where(name: "something", aliases: "other", sort: {something: :desc}, limit: 10, offset: 1)).to eq response
+      end
+    end
+  end
+
+end

data/spec/lib/giant_bomb_api_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe GiantBombApi do
+
+  before do
+    GiantBombApi.configure do |config|
+      config.api_key = "12345"
+    end
+  end
+
+  after do
+    GiantBombApi.configuration = nil
+  end
+
+  describe "#configure" do
+
+    it "will correctly retain it's configuration" do
+      expect(GiantBombApi.configuration.api_key).to eq "12345"
+    end
+  end
+
+  describe '#search' do
+    let(:search_request) { double() }
+    let(:result) { double() }
+
+    it 'uses the modules default client to send a Request::Search at returns the result' do
+      expect(GiantBombApi::Request::Search).to receive(:new).with("query").and_return(search_request)
+      expect(GiantBombApi.client).to receive(:send_request).with(search_request).and_return(result)
+
+      expect(GiantBombApi.search("query")).to eq result
+    end
+  end
+
+  describe "#client" do
+
+    context "when correctly configured first" do
+      let(:client) { double("GiantBombApi::Client") }
+
+      it "will use the module-config to configure a client and returns it" do
+        expect(GiantBombApi::Client).to receive(:new).with(api_key: "12345").and_return(client)
+        expect(GiantBombApi.client).to eq client
+      end
+    end
+    
+    context "when not configured first" do
+      before do
+        GiantBombApi.configuration = nil
+      end
+
+      it "will raise an error and asks to configure first" do
+        expect{GiantBombApi.client}.to raise_error(GiantBombApi::Exception)
+      end
+    end
+  end
+
+end

data/spec/lib/request/collection_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe GiantBombApi::Request::Collection do
+  describe "#initialize" do
+    context "when only a resource is given" do
+      it "sets query and the correct request_params" do
+        collection_request = GiantBombApi::Request::Collection.new GiantBombApi::Resource::Game
+
+        expect(collection_request.end_point).to eq "games"
+        expect(collection_request.params).to eq({limit: 100, offset: 0})
+      end
+    end
+
+    context "when a resource with filter is given" do
+      it "sets query and the correct request_params" do
+        collection_request = GiantBombApi::Request::Collection.new GiantBombApi::Resource::Game, filter: {name: "other", aliases: "something"}
+
+        expect(collection_request.end_point).to eq "games"
+        expect(collection_request.params).to eq(filter: "name:other,aliases:something", limit: 100, offset: 0)
+      end
+    end
+
+    context "when a resource with filter and sort is given" do
+      it "sets query and the correct request_params" do
+        collection_request = GiantBombApi::Request::Collection.new GiantBombApi::Resource::Game, filter: {name: "other", aliases: "something"}, sort: {name: :desc}
+
+        expect(collection_request.end_point).to eq "games"
+        expect(collection_request.params).to eq(filter: "name:other,aliases:something", sort: "name:desc", limit: 100, offset: 0)
+      end
+    end
+  end
+end

data/spec/lib/request/search_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe GiantBombApi::Request::Search do
+  describe "#initialize" do
+    context "when only a query is given" do
+      it "sets query and the correct defaults as request_params" do
+        search_request = GiantBombApi::Request::Search.new "query"
+
+        expect(search_request.params).to eq({ query: "query",
+                                              resources: "game",
+                                              limit: 100,
+                                              page: 1 })
+      end
+    end
+
+    context "when a query and some resources are given" do
+      it "maps the resources-class to resource-names and sets the correct request_params" do
+        search_request = GiantBombApi::Request::Search.new "query", resources: [GiantBombApi::Resource::Game, GiantBombApi::Resource::Company, GiantBombApi::Resource::Character]
+
+        expect(search_request.params).to eq({ query: "query",
+                                              resources: "game,company,character",
+                                              limit: 100,
+                                              page: 1 })
+      end
+    end
+
+    context "when a query, some resources and parameters are given" do
+      it "sets the correct request_params" do
+        search_request = GiantBombApi::Request::Search.new "query", resources: [GiantBombApi::Resource::Game, GiantBombApi::Resource::Company], limit: 50, page: 2
+
+        expect(search_request.params).to eq({ query: "query",
+                                              resources: "game,company",
+                                              limit: 50,
+                                              page: 2 })
+      end
+    end
+  end
+end

data/spec/lib/resource/factory_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe GiantBombApi::Resource::Factory do
+
+  let(:game_json) {{'api_detail_url' => 'http://www.giantbomb.com/api/game/3030-41693/', 'some' => 'data' }}
+  let(:unknown_json) {{'api_detail_url' => 'http://www.giantbomb.com/api/unknown/1234-567/', 'some' => 'data' }}
+  let(:image_json) {{"icon_url": "http://url","medium_url": "http://url2","screen_url": "http://url3"}}
+
+  describe '#init_resource_from' do
+    context "when a json without resource_name is given" do
+      context 'and a api_detail_url is present' do
+        let(:game) { double('Game') }
+  
+        it 'initializes the object based on the found resource_name in the api_detail_url' do
+          expect(GiantBombApi::Resource::Game).to receive(:new).with(game_json).and_return(game)
+          expect(GiantBombApi::Resource::Factory.init_resource_from(game_json)).to eq game
+        end
+  
+        context 'and an unknown-resource-name is discovered' do
+          it 'will not fail and return nil' do
+            expect(GiantBombApi::Resource::Factory.init_resource_from(unknown_json)).to be_nil
+          end
+        end
+      end
+    end
+    context "when a json with resource_name is given" do
+      let(:image) { double('Image') }
+      it 'initializes the object based on the given resource_name' do
+        expect(GiantBombApi::Resource::Image).to receive(:new).with(image_json).and_return(image)
+        expect(GiantBombApi::Resource::Factory.init_resource_from(image_json, resource_name: :image)).to eq image
+      end
+    end
+  end
+
+end

data/spec/lib/resource/game_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe GiantBombApi::Resource::Game do
+
+  let(:games_detail_response) { JSON.parse File.read(File.join('spec', 'fixtures', 'detail-response.json')) }
+
+  describe '#initialize' do
+    it 'correctly builds an object hierachy for a detail-json' do
+      game = GiantBombApi::Resource::Game.new games_detail_response["results"]
+
+      expect(game.name).to eq "Driveclub"
+      expect(game.image).to be_present
+      expect(game.original_game_rating.count).to eq 2
+      expect(game.platforms.count).to eq 1
+      expect(game.images.count).to eq 30
+      expect(game.videos.count).to eq 5
+      expect(game.developers.count).to eq 1
+      expect(game.genres.count).to eq 1
+      expect(game.franchises).to be_nil
+      expect(game.publishers.count).to eq 2
+      expect(game.releases.count).to eq 4
+      expect(game.similar_games.count).to eq 1
+
+    end
+
+  end
+
+end

data/spec/lib/resource_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe GiantBombApi::Resource do
+
+  class DummyResource
+    extend GiantBombApi::Resource
+  end
+
+  class AnotherDummyResource
+    extend GiantBombApi::Resource
+
+    resource_name "some_dummy_resource"
+  end
+
+  describe 'inclusion' do
+    it 'will also include from GiantBombApi::Resource' do
+      expect(DummyCollection).to include(GiantBombApi::ResourceValueSetter)
+    end
+  end
+
+  describe '#resource_name' do
+
+    context "when in a class the resource_name has been defined" do
+      it 'returns the resource_name of that class' do
+        expect(AnotherDummyResource.resource_name).to eq "some_dummy_resource"
+      end
+    end
+
+    context "when in a class the resource_name has NOT been defined" do
+      it 'returns the underscored class_name' do
+        expect(DummyResource.resource_name).to eq "dummy_resource"
+      end
+    end
+
+  end
+
+end

data/spec/lib/response_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe GiantBombApi::Response do
+
+  let(:search_response) { JSON.parse File.read(File.join('spec', 'fixtures', 'search-response.json')) }
+  let(:attributes_json) { { "limit" => "123", "offset" => "12", "number_of_page_results" => "1234", "number_of_total_results" => "4000"} }
+
+  describe '#has_more_results?' do
+    context "when total-results is bigger than offset plus page-results" do
+      it 'returns true' do
+        response = GiantBombApi::Response.new({ "offset" => 100, "number_of_page_results" => 100, "number_of_total_results" => 300 })
+        expect(response.has_more_results?).to eq true
+      end
+    end
+
+    context "when total-results is the same as offset + number_of_page_results" do
+      it 'returns false' do
+        response = GiantBombApi::Response.new({ "offset" => 0, "number_of_page_results" => 50, "number_of_total_results" => 50 })
+        expect(response.has_more_results?).to eq false
+      end
+    end
+  end
+
+  describe '#initialize' do
+    context "when handed a search-result" do
+      let(:response) { GiantBombApi::Response.new(search_response) }
+
+      it 'sets the correct values on itself' do
+        expect(response.limit).to eq 100
+        expect(response.offset).to eq 0
+        expect(response.number_of_page_results).to eq 1
+        expect(response.number_of_total_results).to eq 1
+      end
+
+      it 'creates the correct results of objects' do
+        expect(response.results.count).to eq 1
+
+        result = response.results.first
+
+        expect(result).to be_a GiantBombApi::Resource::Game
+        expect(result.aliases).to eq "Drive Club\r\n#DRIVECLUB"
+        expect(result.api_detail_url).to eq "http://www.giantbomb.com/api/game/3030-41693/"
+        expect(result.date_added).to eq "2013-02-20 15:57:29"
+        expect(result.date_last_updated).to eq "2014-11-30 06:30:47"
+        expect(result.deck).to eq "Driveclub is a team-based racing game from Evolution Studios for PlayStation 4."
+        expect(result.description).to eq "<p style=\"\"> </p>"
+        expect(result.expected_release_day).to be_nil
+        expect(result.expected_release_month).to be_nil
+        expect(result.expected_release_quarter).to be_nil
+        expect(result.expected_release_year).to be_nil
+        expect(result.id).to eq 41693
+        expect(result.name).to eq "Driveclub"
+        expect(result.number_of_user_reviews).to eq 0
+        expect(result.original_release_date).to eq "2014-10-07 00:00:00"
+      end
+
+      it 'sets the correct platforms' do
+        result = response.results.first
+
+        expect(result.image).to be_present
+        expect(result.image.icon_url).to eq "http://static.giantbomb.com/uploads/square_avatar/8/82063/2560905-driveclub.jpg"
+        expect(result.image.medium_url).to eq "http://static.giantbomb.com/uploads/scale_medium/8/82063/2560905-driveclub.jpg"
+        expect(result.image.screen_url).to eq "http://static.giantbomb.com/uploads/screen_medium/8/82063/2560905-driveclub.jpg"
+        expect(result.image.small_url).to eq "http://static.giantbomb.com/uploads/scale_small/8/82063/2560905-driveclub.jpg"
+        expect(result.image.super_url).to eq "http://static.giantbomb.com/uploads/scale_large/8/82063/2560905-driveclub.jpg"
+        expect(result.image.thumb_url).to eq "http://static.giantbomb.com/uploads/scale_avatar/8/82063/2560905-driveclub.jpg"
+        expect(result.image.tiny_url).to eq "http://static.giantbomb.com/uploads/square_mini/8/82063/2560905-driveclub.jpg"
+      end
+
+      it 'sets the correct platforms' do
+        result = response.results.first
+
+        expect(result.platforms.count).to eq 1
+        platform = result.platforms.first
+
+        expect(platform).to be_a GiantBombApi::Resource::Platform
+        expect(platform.api_detail_url).to eq "http://www.giantbomb.com/api/platform/3045-146/"
+        expect(platform.id).to eq 146
+        expect(platform.name).to eq "PlayStation 4"
+        expect(platform.abbreviation).to eq "PS4"
+      end
+
+      it 'sets the correct game_ratings' do
+        result = response.results.first
+
+        expect(result.original_game_rating.count).to eq 2
+
+        rating1 = result.original_game_rating[0]
+        rating2 = result.original_game_rating[1]
+
+        expect(rating1.api_detail_url).to eq "http://www.giantbomb.com/api/game_rating/3065-7/"
+        expect(rating1.id).to eq 7
+        expect(rating1.name).to eq "PEGI: 3+"
+
+        expect(rating2.api_detail_url).to eq "http://www.giantbomb.com/api/game_rating/3065-25/"
+        expect(rating2.id).to eq 25
+        expect(rating2.name).to eq "CERO: A"
+      end
+    end
+  end
+
+end