ruby-lol 0.9.18 → 0.9.19

data/spec/lol/league_spec.rb

@@ -23,7 +23,7 @@ describe League do
     end
 
     it "fills entries with LeagueEntry objects" do
-      league_data = load_fixture("league", LeagueRequest.api_version, "get")
+      league_data = load_fixture("league", LeagueRequest.api_version)
       league = League.new(league_data[league_data.keys.first].first)
       expect(league.entries.map(&:class).uniq).to eq([LeagueEntry])
     end

data/spec/lol/mastery_page_spec.rb

@@ -16,7 +16,7 @@ describe MasteryPage do
   end
 
   describe "#masteries" do
-    let(:fixture) { load_fixture("summoner-masteries", SummonerRequest.api_version, "get") }
+    let(:fixture) { load_fixture("summoner-masteries", SummonerRequest.api_version) }
     let(:masteries) { fixture["30743211"]["pages"].first["masteries"] }
 
     subject { MasteryPage.new fixture["30743211"]["pages"].first }

data/spec/lol/match_history_request_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+require "lol"
+
+include Lol
+
+describe MatchHistoryRequest do
+end

data/spec/lol/match_request_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+require "lol"
+
+include Lol
+
+describe MatchRequest do
+end

data/spec/lol/request_spec.rb

@@ -36,19 +36,19 @@ describe Request do
 
     it "calls HTTParty get" do
       expect(subject.class).to receive(:get).and_return(error401)
-      expect { subject.perform_request "foo"}.to raise_error(InvalidAPIResponse)
+      expect { subject.perform_request "foo?api_key=asd"}.to raise_error(InvalidAPIResponse)
     end
 
     it "handles 401" do
       expect(subject.class).to receive(:get).and_return(error401)
-      expect { subject.perform_request "foo" }.to raise_error(InvalidAPIResponse)
+      expect { subject.perform_request "foo?api_key=asd" }.to raise_error(InvalidAPIResponse)
     end
 
     it "handles 404" do
       expect(error401).to receive(:respond_to?).and_return(true)
       expect(error401).to receive(:not_found?).and_return(true)
       expect(subject.class).to receive(:get).and_return(error401)
-      expect { subject.perform_request "foo"}.to raise_error(NotFound)
+      expect { subject.perform_request "foo?api_key=asd"}.to raise_error(NotFound)
     end
 
     context "caching" do
@@ -74,27 +74,27 @@ describe Request do
       let(:fake_redis) { FakeRedis.new }
       let(:request) { Request.new "api_key", "euw", {redis: fake_redis, ttl: 60, cached: true }}
       before :each do
-        expect(request.class).to receive(:get).with("/foo").and_return({foo: "bar"}).at_least(:once)
-        first_result = request.perform_request "/foo"
+        expect(request.class).to receive(:get).with("/foo?api_key=asd").and_return({foo: "bar"}).at_least(:once)
+        first_result = request.perform_request "/foo?api_key=asd"
       end
 
       it "is cached" do
         expect(request.class).not_to receive(:get)
-        request.perform_request "/foo"
+        request.perform_request "/foo?api_key=asd"
       end
 
       it "serializes cached responses" do
         expect(JSON).to receive(:parse)
-        request.perform_request "/foo"
+        request.perform_request "/foo?api_key=asd"
       end
 
       it "sets ttl" do
-        expect(fake_redis.get("/foo:ttl")).to eq(60)
+        expect(fake_redis.get("/foo?:ttl")).to eq(60)
       end
 
       it "uses clean urls" do
         expect(request).to receive(:clean_url).at_least(:once)
-        request.perform_request "/foo"
+        request.perform_request "/foo?api_key=asd"
       end
     end
   end

data/spec/lol/rune_page_spec.rb

@@ -16,7 +16,7 @@ describe RunePage do
   end
 
   describe "#slots" do
-    let(:fixture) { load_fixture("summoner-runes", SummonerRequest.api_version, "get") }
+    let(:fixture) { load_fixture("summoner-runes", SummonerRequest.api_version) }
     let(:slots) { fixture["30743211"]["pages"].first["slots"] }
 
     subject { RunePage.new fixture["30743211"]["pages"].first }

data/spec/lol/static_request_spec.rb

@@ -10,9 +10,9 @@ describe StaticRequest do
     end
   end
 
-  let(:request) { StaticRequest.new "api_key", "euw" }
+  let(:request) { StaticRequest.new("api_key", "euw") }
 
-  describe "api_url" do
+  describe "#api_url" do
     it "contains a static-data path component" do
       expect(request.api_url("foo")).to eq("http://global.api.pvp.net/api/lol/static-data/euw/v1.2/foo?api_key=api_key")
     end
@@ -32,18 +32,13 @@ describe StaticRequest do
         end
 
         context "without_id" do
-          let(:fixtures) do
-            fixture = endpoint == 'champion' && 'static-champion' || endpoint.dasherize
-            load_fixture(fixture, StaticRequest.api_version, "get")
-          end
 
-          subject do
-            expect(request).to receive(:perform_request)
-              .with(request.api_url("#{endpoint.dasherize}"))
-              .and_return(fixtures)
+          let(:fixture_name) { endpoint == 'champion' ? 'static-champion' : endpoint.dasherize }
+          let(:fixture) { load_fixture(fixture_name, StaticRequest.api_version) }
 
-            request.send(endpoint).get
-          end
+          subject { request.public_send(endpoint).get }
+
+          before(:each) { stub_request(request, fixture_name, "#{endpoint.dasherize}") }
 
           it "returns an Array" do
             expect(subject).to be_an(Array)
@@ -54,21 +49,16 @@ describe StaticRequest do
           end
 
           it "fetches #{endpoint} from the API" do
-            expect(subject.size).to eq(fixtures["data"].size)
+            expect(subject.size).to eq(fixture["data"].size)
           end
         end
 
         context "with_id" do
           let(:id) { 1 }
-          let(:fixtures) { load_fixture("#{endpoint.dasherize}-by-id", StaticRequest.api_version, "get") }
 
-          subject do
-            expect(request).to receive(:perform_request)
-              .with(request.api_url("#{endpoint.dasherize}/#{id}"))
-              .and_return(fixtures)
+          before(:each) { stub_request(request, "#{endpoint.dasherize}-by-id", "#{endpoint.dasherize}/#{id}") }
 
-            request.send(endpoint).get(id)
-          end
+          subject { request.public_send(endpoint).get(id) }
 
           it "returns an OpenStruct" do
             expect(subject).to be_an(OpenStruct)
@@ -78,32 +68,20 @@ describe StaticRequest do
     end
   end
 
-  describe "realm" do
-    let(:fixtures) { load_fixture("realm", StaticRequest.api_version, "get") }
+  describe "#realm" do
+    subject { request.realm.get }
 
-    subject do
-      expect(request).to receive(:perform_request)
-        .with(request.api_url("realm"))
-        .and_return(fixtures)
-
-      request.send("realm").get
-    end
+    before(:each) { stub_request(request, 'realm', 'realm') }
 
     it "returns an OpenStruct" do
       expect(subject).to be_an(OpenStruct)
     end
   end
 
-  describe "versions" do
-    let(:fixtures) { load_fixture("versions", StaticRequest.api_version, "get") }
+  describe "#versions" do
+    subject { request.versions.get }
 
-    subject do
-      expect(request).to receive(:perform_request)
-        .with(request.api_url("versions"))
-        .and_return(fixtures)
-
-      request.send("versions").get
-    end
+    before(:each) { stub_request(request, 'versions', 'versions') }
 
     it "returns an Array" do
       expect(subject).to be_an(Array)

data/spec/lol/stats_request_spec.rb

@@ -4,76 +4,90 @@ require "lol"
 include Lol
 
 describe StatsRequest do
-  let(:request) { StatsRequest.new "api_key", "euw" }
+  let(:request) { StatsRequest.new("api_key", "euw") }
 
   it "inherits from Request" do
     expect(GameRequest.ancestors[1]).to eq(Request)
   end
 
   describe "#summary" do
-    let(:fixture) { load_fixture 'stats', StatsRequest.api_version, 'get' }
-
-    subject do
-      expect(request.class).to receive(:get).with(request.api_url("stats/by-summoner/1/summary")).and_return fixture
-
-      request.summary 1
-    end
 
     it 'requires a summoner' do
       expect { request.summary }.to raise_error ArgumentError
     end
 
-    it 'returns an array' do
-      expect(subject).to be_a Array
+    it 'raises an error when unexpected parameter is received' do
+      expect { request.summary '1', asd: 'foo' }.to raise_error ArgumentError
     end
 
-    it 'returns an array of PlayerStatistic' do
-      expect(subject.map(&:class).uniq).to eq [PlayerStatistic]
-    end
+    context 'with summoner' do
+      subject { request.summary(1) }
 
-    it 'fetches PlayerStatistics from the API' do
-      expect(subject.size).to eq load_fixture('stats', StatsRequest.api_version, 'get')['playerStatSummaries'].size
-    end
+      context 'without season' do
+        let(:fixture) { load_fixture('stats', StatsRequest.api_version) }
 
-    it 'optionally accepts a season' do
-      expect(request.class).to receive(:get).with(request.api_url('stats/by-summoner/1/summary', season: '1')).and_return fixture
-      request.summary '1', season: '1'
-    end
+        before(:each) { stub_request(request, 'stats', 'stats/by-summoner/1/summary') }
+
+        it 'returns an array' do
+          expect(subject).to be_a Array
+        end
+
+        it 'returns an array of PlayerStatistic' do
+          expect(subject.map(&:class).uniq).to eq [PlayerStatistic]
+        end
+
+        it 'fetches PlayerStatistics from the API' do
+          expect(subject.size).to eq(fixture['playerStatSummaries'].size)
+        end
+      end
+
+      context 'with season' do
+        before(:each) { stub_request(request, 'stats', 'stats/by-summoner/1/summary', season: '1') }
+
+        it 'optionally accepts a season' do
+          request.summary('1', season: '1')
+        end
+      end
 
-    it 'raises an error when unexpected parameter is received' do
-      expect { request.summary '1', asd: 'foo' }.to raise_error ArgumentError
     end
   end
 
   describe "#ranked" do
-    let(:fixture) { load_fixture 'ranked_stats', StatsRequest.api_version, 'get' }
-
-    subject do
-      expect(request.class).to receive(:get).with(request.api_url("stats/by-summoner/1/ranked")).and_return fixture
-      request.ranked 1
-    end
 
     it 'requires a summoner' do
       expect { request.ranked }.to raise_error ArgumentError
     end
 
-    it 'returns a RankedStatisticsSummary' do
-      expect(subject).to be_a RankedStatisticsSummary
+    it 'raises an error when unexpected parameter is received' do
+      expect { request.ranked '1', asd: 'foo' }.to raise_error ArgumentError
     end
 
-    it 'fetches RankedStatisticsSummary from the API' do
-      expect(subject.champions.size).to eq load_fixture('ranked_stats', StatsRequest.api_version, 'get')['champions'].size
-    end
+    context 'with summoner' do
+      let(:fixture) { load_fixture('ranked_stats', StatsRequest.api_version) }
 
-    it 'optionally accepts a season' do
-      expect(request.class).to receive(:get).with(request.api_url('stats/by-summoner/1/ranked', season: '1')).and_return fixture
+      context 'without season' do
+        subject { request.ranked(1) }
 
-      request.ranked '1', season: '1'
-    end
+        before(:each) { stub_request(request, 'ranked_stats', 'stats/by-summoner/1/ranked') }
 
-    it 'raises an error when unexpected parameter is received' do
-      expect { request.ranked '1', asd: 'foo' }.to raise_error ArgumentError
+        it 'returns a RankedStatisticsSummary' do
+          expect(subject).to be_a RankedStatisticsSummary
+        end
+
+        it 'fetches RankedStatisticsSummary from the API' do
+          expect(subject.champions.size).to eq(fixture['champions'].size)
+        end
+      end
+
+      context 'with season' do
+        before(:each) { stub_request(request, 'ranked_stats', 'stats/by-summoner/1/ranked', season: '1') }
+
+        it 'optionally accepts a season' do
+          request.ranked('1', season: '1')
+        end
+      end
     end
+
   end
 
 end

data/spec/lol/summoner_request_spec.rb

@@ -8,50 +8,44 @@ describe SummonerRequest do
     expect(SummonerRequest.ancestors[1]).to eq(Request)
   end
 
-  let(:request)   { SummonerRequest.new "api_key", "euw" }
-  let(:by_name)   { load_fixture("summoner-by-name", SummonerRequest.api_version, "get") }
-  let(:name)      { load_fixture("summoner-name", SummonerRequest.api_version, "get") }
-  let(:summoner)  { load_fixture("summoner", SummonerRequest.api_version, "get") }
-  let(:runes)     { load_fixture("summoner-runes", SummonerRequest.api_version, "get") }
-  let(:masteries) { load_fixture("summoner-masteries", SummonerRequest.api_version, "get") }
+  let(:request) { SummonerRequest.new('api_key', 'euw') }
 
   describe "#by_name" do
-    subject do
-      expect(request.class).to receive(:get).with(request.api_url("summoner/by-name/foo,bar")).and_return(by_name)
 
-      request.by_name ["foo", "bar"]
-    end
+    context 'regular arguments' do
+      subject { request.by_name(['foo', 'bar']) }
 
-    it "returns an array" do
-      expect(subject).to be_a(Array)
-    end
+      before(:each) { stub_request(request, 'summoner-by-name', 'summoner/by-name/foo,bar') }
 
-    it "returns an array of summoners" do
-      expect(subject.map(&:class).uniq).to eq([Summoner])
+      it "returns an array" do
+        expect(subject).to be_a(Array)
+      end
+
+      it "returns an array of summoners" do
+        expect(subject.map(&:class).uniq).to eq([Summoner])
+      end
     end
 
     it 'escapes the given names' do
-      expect(request.class).to receive(:get).with(request.api_url("summoner/by-name/f%C3%B2%C3%A5,f%C3%B9%C3%AE")).and_return(by_name)
-      request.by_name ['fòå', 'fùî']
+      stub_request(request, 'summoner-by-name', "summoner/by-name/f%C3%B2%C3%A5,f%C3%B9%C3%AE")
+      request.by_name(['fòå', 'fùî'])
     end
 
     it 'downcase the given names' do
-      expect(request.class).to receive(:get).with(request.api_url("summoner/by-name/foo,bar")).and_return(by_name)
-      request.by_name 'FoO', 'BAR'
+      stub_request(request, 'summoner-by-name', 'summoner/by-name/foo,bar')
+      request.by_name('FoO', 'BAR')
     end
 
     it 'strips spaces from names' do
-      expect(request.class).to receive(:get).with(request.api_url("summoner/by-name/foo,bar")).and_return(by_name)
-      request.by_name 'Fo o', 'b a r'
+      stub_request(request, 'summoner-by-name', 'summoner/by-name/foo,bar')
+      request.by_name('Fo o', 'b a r')
     end
   end
 
   describe "#name" do
-    subject do
-      expect(request.class).to receive(:get).with(request.api_url("summoner/foo,bar/name")).and_return(name)
+    subject { request.name("foo", "bar") }
 
-      request.name "foo", "bar"
-    end
+    before(:each) { stub_request(request, 'summoner-name', 'summoner/foo,bar/name') }
 
     it "returns an hash" do
       expect(subject).to be_a(Hash)
@@ -59,11 +53,9 @@ describe SummonerRequest do
   end
 
   describe "#get" do
-    subject do
-      expect(request.class).to receive(:get).with(request.api_url("summoner/foo,bar")).and_return(summoner)
+    subject { request.get(["foo", "bar"]) }
 
-      request.get ["foo", "bar"]
-    end
+    before(:each) { stub_request(request, 'summoner', 'summoner/foo,bar') }
 
     it "returns an array summoners" do
       expect(subject.map(&:class).uniq).to eq([Summoner])
@@ -71,11 +63,9 @@ describe SummonerRequest do
   end
 
   describe "#runes" do
-    subject do
-      expect(request.class).to receive(:get).with(request.api_url("summoner/foo,bar/runes")).and_return(runes)
+    subject { request.runes(["foo", "bar"]) }
 
-      request.runes ["foo", "bar"]
-    end
+    before(:each) { stub_request(request, 'summoner-runes', 'summoner/foo,bar/runes') }
 
     it "returns an array of Hash" do
       expect(subject).to be_a(Hash)
@@ -87,11 +77,9 @@ describe SummonerRequest do
   end
 
   describe "#masteries" do
-    subject do
-      expect(request.class).to receive(:get).with(request.api_url("summoner/foo,bar/masteries")).and_return(masteries)
+    subject { request.masteries(["foo", "bar"]) }
 
-      request.masteries ["foo", "bar"]
-    end
+    before(:each) { stub_request(request, 'summoner-masteries', 'summoner/foo,bar/masteries') }
 
     it "returns an array of Hash" do
       expect(subject).to be_a(Hash)

data/spec/lol/team_request_spec.rb

@@ -4,54 +4,44 @@ require "lol"
 include Lol
 
 describe TeamRequest do
-  let(:request) { TeamRequest.new "api_key", "euw" }
+  let(:request) { TeamRequest.new("api_key", "euw") }
 
   it "inherits from Request" do
     expect(TeamRequest.ancestors[1]).to eq(Request)
   end
 
-  describe "get" do
-    let(:request) { TeamRequest.new "api_key", "euw" }
-    let(:fixture) { load_fixture 'team', TeamRequest.api_version, 'get' }
+  describe "#by_summoner" do
+    let(:fixture) { load_fixture('team', TeamRequest.api_version) }
 
-    subject do
-      expect(request.class).to receive(:get).with(request.api_url("team/by-summoner/1")).and_return fixture
-      request.get 1
-    end
+    subject { request.by_summoner(1) }
 
-    it 'returns an hash' do
-      expect(subject).to be_a Hash
-    end
+    before(:each) { stub_request(request, 'team', 'team/by-summoner/1') }
 
-    it 'returns an array of Team' do
-      expect(subject[subject.keys.first].map(&:class).uniq).to eq [Team]
+    it 'returns an hash' do
+      expect(subject).to be_a(Hash)
     end
 
     it 'fetches Team from the API' do
-      expect(subject.size).to eq fixture.size
+      expect(subject.size).to eq(fixture.size)
     end
   end
 
-  describe "getbyid" do
-    let(:request) { TeamRequest.new "api_key", "euw" }
-    let(:fixture) { load_fixture 'team', TeamRequest.api_version, 'getbyid' }
+  describe "#get" do
 
-    subject do
-      expect(request.class).to receive(:get).with(request.api_url("team/TEAM-a9ad3db0-b377-11e3-b87d-782bcb4ce61a")).and_return fixture
-      request.getbyid "TEAM-a9ad3db0-b377-11e3-b87d-782bcb4ce61a"
+    it 'requires a team id' do
+      expect { request.get }.to raise_error
     end
 
-    it 'requires a summoner' do
-      expect { request.getbyid }.to raise_error ArgumentError
-    end
+    context 'with team id' do
+      subject { request.get("TEAM-a9ad3db0-b377-11e3-b87d-782bcb4ce61a") }
 
-    it 'returns a Team' do
-      expect(subject).to be_a Lol::Team
-    end
+      before(:each) { stub_request(request, 'team-by-id', 'team/TEAM-a9ad3db0-b377-11e3-b87d-782bcb4ce61a') }
 
-    it 'fetches Team from the API' do
-      expect(subject.full_id).to eq "TEAM-a9ad3db0-b377-11e3-b87d-782bcb4ce61a"
+      it 'returns an array of Teams' do
+        subject.each {|k,v| expect(v).to be_a Lol::Team}
+      end
     end
+
   end
 
 end