ruby-lol 0.12.2 → 1.0.0

data/spec/lol/league_request_spec.rb

@@ -4,94 +4,51 @@ require "lol"
 include Lol
 
 describe LeagueRequest do
-  it "inherits from Request" do
-    expect(LeagueRequest.ancestors[1]).to eq(Request)
-  end
-
-  let(:request) { LeagueRequest.new("api_key", "euw") }
-
-  describe "#get" do
-    subject { request.get(123) }
-
-    let(:fixture) { load_fixture('league', request.class.api_version) }
-
-    before(:each) { stub_request(request, 'league', 'league/by-summoner/123') }
-
-    it "returns a hash of arrays of Leagues" do
-      expect(subject.map {|_,v| v.map(&:class).uniq}.flatten).to eq([League])
-    end
+  subject { LeagueRequest.new 'api_key', 'euw' }
 
-    it 'has hash keys with string summoner ids' do
-      expect(subject.keys).to eq(fixture.keys)
-    end
+  it 'inherits from V3 Request' do
+    expect(LeagueRequest).to be < Request
   end
 
-  describe "#get_entries" do
-    subject { request.get_entries(123) }
-
-    let(:fixture) { load_fixture('league-entry', request.class.api_version) }
-
-    before(:each) { stub_request(request, 'league-entry', 'league/by-summoner/123/entry') }
-
-    it 'returns a hash of arrays of Leagues' do
-      expect(subject.map {|_,v| v.map(&:class).uniq}.flatten).to eq([League])
+  describe '#find_challenger' do
+    it 'returns a DynamicModel' do
+      stub_request subject, 'league-challenger', 'challengerleagues/by-queue/RANKED_SOLO_5x5'
+      expect(subject.find_challenger).to be_a DynamicModel
     end
 
-    it 'has hash keys with summoner ids' do
-      expect(subject.keys).to eq(fixture.keys)
+    it 'finds the challenger league for the given queue' do
+      stub_request subject, 'league-challenger', 'challengerleagues/by-queue/foo'
+      subject.find_challenger queue: 'foo'
     end
   end
 
-  describe '#by_team' do
-    subject { request.by_team('TEAM-7d7013d0-b38b-11e3-9e38-782bcb497d6f') }
-
-    let(:fixture) { load_fixture('league-by-team', request.class.api_version) }
-
-    before(:each) { stub_request(request, 'league-by-team', 'league/by-team/TEAM-7d7013d0-b38b-11e3-9e38-782bcb497d6f') }
-
-    it 'returns a hash of arrays of Leagues' do
-      expect(subject.map {|_,v| v.map(&:class).uniq}.flatten).to eq([League])
+  describe '#find_master' do
+    it 'returns a LeagueList' do
+      stub_request subject, 'league-master', 'masterleagues/by-queue/RANKED_SOLO_5x5'
+      expect(subject.find_master).to be_a DynamicModel
     end
 
-    it 'has hash keys with string team id' do
-      expect(subject.keys).to eq(fixture.keys)
+    it 'finds the master league for the given queue' do
+      stub_request subject, 'league-master', 'masterleagues/by-queue/foo'
+      subject.find_master queue: 'foo'
     end
   end
 
-  describe '#entries_by_team' do
-    subject { request.entries_by_team('TEAM-7d7013d0-b38b-11e3-9e38-782bcb497d6f') }
-
-    let(:fixture) { load_fixture('league-entry-by-team', request.class.api_version) }
-
-    before(:each) { stub_request(request, 'league-entry-by-team', 'league/by-team/TEAM-7d7013d0-b38b-11e3-9e38-782bcb497d6f/entry') }
-
-    it 'returns a hash of arrays of Leagues' do
-      expect(subject.map {|_,v| v.map(&:class).uniq}.flatten).to eq([League])
-    end
-
-    it 'has hash keys with string team id' do
-      expect(subject.keys).to eq(fixture.keys)
+  describe '#summoner_leagues' do
+    it 'returns an array of LeagueList objects' do
+      stub_request subject, 'league-summoner', 'leagues/by-summoner/1'
+      result = subject.summoner_leagues summoner_id: 1
+      expect(result).to be_a Array
+      expect(result.map(&:class).uniq).to eq [DynamicModel]
     end
   end
 
-  describe '#challenger' do
-    subject { request.challenger('RANKED_SOLO_5x5') }
-
-    before(:each) { stub_request(request, 'league-challenger', 'league/challenger', { :type => 'RANKED_SOLO_5x5' }) }
-
-    it 'returns League' do
-      expect(subject.class).to eq(League)
+  describe '#summoner_positions' do
+    it 'returns an array of DynamicModel objects' do
+      stub_request subject, 'league-positions', 'positions/by-summoner/1'
+      result = subject.summoner_positions summoner_id: 1
+      expect(result).to be_a Array
+      expect(result.map(&:class).uniq).to eq [DynamicModel]
     end
   end
-
-  describe '#master' do 
-    subject { request.master('RANKED_SOLO_5x5')}
-
-    before(:each) { stub_request(request, 'league-master', 'league/master', { :type => 'RANKED_SOLO_5x5'})}
-
-    it 'returns League' do 
-      expect(subject.class).to eq(League)
-    end
-  end
-
 end

data/spec/lol/lol_status_request_spec.rb

@@ -4,44 +4,16 @@ require "lol"
 include Lol
 
 describe LolStatusRequest do
-  it 'inherits from Request' do
-    expect(LolStatusRequest.ancestors[1]).to eq(Request)
-  end
-
-  describe '#api_url' do
-    it 'returns full url for' do
-      expect(subject.api_url('shards')).to eq 'http://status.leagueoflegends.com/shards'
-    end
-
-    it 'returns full url with path' do
-      expect(subject.api_url('shards', 'something')).to eq 'http://status.leagueoflegends.com/shards/something'
-    end
-  end
-
-  describe "#shards" do
-    let(:response) { subject.shards }
+  subject { LolStatusRequest.new "api_key", "euw" }
 
-    before(:each) { stub_request(subject, 'lol-status-shards', 'shards') }
-
-    it 'returns an array' do
-      expect(response).to be_a(Array)
-    end
-
-    it 'returns an array of Shard' do
-      expect(response.map(&:class).uniq).to eq([DynamicModel])
-    end
-
-    it 'fetches shards from the API' do
-      fixture = load_fixture('lol-status-shards', LolStatusRequest.api_version)
-      expect(response.size).to eq(fixture.size)
-    end
+  it 'inherits from Request' do
+    expect(LolStatusRequest).to be < Request
   end
 
-  describe '#current_shard' do
-    subject { LolStatusRequest.new 'euw'}
-    let(:response) { subject.current_shard }
+  describe '#shard_data' do
+    let(:response) { subject.shard_data }
 
-    before(:each) { stub_request(subject, 'lol-status-shard-by-region', 'shards', 'euw') }
+    before(:each) { stub_request(subject, 'lol-status-shard', 'shard-data') }
 
     it 'returns a Shard' do
       expect(response).to be_a(DynamicModel)

data/spec/lol/masteries_request_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+require "lol"
+
+describe Lol::MasteriesRequest do
+  subject { Lol::MasteriesRequest.new "api_key", "euw" }
+
+  describe "#by_summoner_id" do
+    it "returns an Array of DynamicModel" do
+      stub_request subject, "masteries", "masteries/by-summoner/1"
+      result = subject.by_summoner_id 1
+      expect(result).to be_a Array
+      expect(result.map(&:class).uniq).to eq [Lol::DynamicModel]
+    end
+  end
+end

data/spec/lol/match_request_spec.rb

@@ -4,24 +4,59 @@ require "lol"
 include Lol
 
 describe MatchRequest do
+  subject { MatchRequest.new "api_key", "euw" }
+
   it "inherits from Request" do
-    expect(MatchRequest.ancestors[1]).to eq(Request)
+    expect(MatchRequest).to be < Request
   end
 
-  let(:request) { MatchRequest.new("api_key", "euw") }
+  describe "#find" do
+    context "without a tournament code" do
+      let(:result) { subject.find 1 }
+      before { stub_request subject, 'match', "matches/1" }
+
+      it "returns a DynamicModel" do
+        expect(result).to be_a DynamicModel
+      end
+    end
+
+    context "with a tournament code" do
+      let(:result) { subject.find 1, tournament_code: 2 }
+      before { stub_request subject, 'match-with-tc', "matches/1/by-tournament-code/2" }
+
+      it "returns a DynamicModel" do
+        expect(result).to be_a DynamicModel
+      end
+    end
+  end
 
-  describe "#get" do
-    subject { request.get(1) }
+  describe "#find_timeline" do
+    it "returns a DynamicModel" do
+      stub_request subject, 'timeline', "timelines/by-match/1"
+      expect(subject.find_timeline 1).to be_a DynamicModel
+    end
+  end
 
-    before { stub_request(request, 'match', 'match/1') }
+  describe "#ids_by_tournament_code" do
+    it "returns a list of ids" do
+      stub_request subject, 'ids-by-tc', "matches/by-tournament-code/1/ids"
+      result = subject.ids_by_tournament_code '1'
+      expect(result).to be_a Array
+      expect(result.map(&:class).uniq).to eq [Integer]
+    end
+  end
 
-    it 'returns an hash' do
-      expect(subject).to be_a(Hash)
+  describe "#all" do
+    it "returns a DynamicModel" do
+      stub_request subject, 'matches', "matchlists/by-account/1"
+      expect(subject.all account_id: 1).to be_a DynamicModel
     end
+  end
 
-    it 'fetches matches from the API' do
-      fixture = load_fixture('match', MatchRequest.api_version)
-      expect(subject.keys).to match_array fixture.keys
+  describe "#recent" do
+    it "returns a DynamicModel" do
+      stub_request subject, 'matches-recent', "matchlists/by-account/1/recent"
+      expect(subject.recent account_id: 1).to be_a DynamicModel
     end
   end
 end

data/spec/lol/request_spec.rb

@@ -162,11 +162,11 @@ describe Request do
 
   describe "api_url" do
     it "defaults on Request#region" do
-      expect(subject.api_url("bar")).to match(/\/euw\//)
+      expect(subject.api_url("bar")).to match(/\/euw1\./)
     end
 
     it "defaults on Reques.api_version" do
-      expect(subject.api_url("bar")).to match(/\/v1.1\//)
+      expect(subject.api_url("bar")).to match(/\/v3\//)
     end
 
     it "a path" do
@@ -174,11 +174,11 @@ describe Request do
     end
 
     it "returns a full fledged api url" do
-      expect(subject.api_url("bar")).to eq("https://euw.api.pvp.net/api/lol/euw/v1.1/bar?api_key=api_key")
+      expect(subject.api_url("bar")).to eq("https://euw1.api.riotgames.com/lol/platform/v3/bar?api_key=api_key")
     end
 
     it "optionally accept query string parameters" do
-      expect(subject.api_url("foo", a: 'b')).to eq("https://euw.api.pvp.net/api/lol/euw/v1.1/foo?a=b&api_key=api_key")
+      expect(subject.api_url("foo", a: 'b')).to eq("https://euw1.api.riotgames.com/lol/platform/v3/foo?a=b&api_key=api_key")
     end
 
     it "delegates the base url to #api_base_url" do
@@ -194,7 +194,7 @@ describe Request do
 
   describe "#api_base_url" do
     it "returns the base domain" do
-      expect(subject.api_base_url).to eq "https://euw.api.pvp.net"
+      expect(subject.api_base_url).to eq "https://euw1.api.riotgames.com"
     end
   end
 

data/spec/lol/runes_request_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+require "lol"
+
+describe Lol::RunesRequest do
+  subject { Lol::RunesRequest.new "api_key", "euw" }
+
+  describe "#by_summoner_id" do
+    it "returns an Array of DynamicModel" do
+      stub_request subject, "runes", "runes/by-summoner/1"
+      result = subject.by_summoner_id 1
+      expect(result).to be_a Array
+      expect(result.map(&:class).uniq).to eq [Lol::DynamicModel]
+    end
+  end
+end

data/spec/lol/spectator_request_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "lol"
+
+describe Lol::SpectatorRequest do
+  subject { described_class.new "api_key", "euw" }
+
+  describe "#current_game" do
+    it "returns a DynamicModel" do
+      stub_request subject, "current-game", "active-games/by-summoner/23"
+      expect(subject.current_game summoner_id: 23).to be_a Lol::DynamicModel
+    end
+  end
+
+  describe "#featured_games" do
+    it "returns a FeaturedGameList" do
+      stub_request subject, "featured-games", "featured-games"
+      result = subject.featured_games
+      expect(result).to be_a Lol::FeaturedGameList
+      expect(result.client_refresh_interval).not_to be_nil
+      expect(result.size).not_to be_zero
+    end
+  end
+end

data/spec/lol/static_request_spec.rb

@@ -4,87 +4,83 @@ require "lol"
 include Lol
 
 describe StaticRequest do
-  describe "api_version" do
-    it "is v1.2" do
-      expect(StaticRequest.api_version).to eq("v1.2")
-    end
-  end
-
-  let(:request) { StaticRequest.new("api_key", "euw") }
-
-  describe "#api_url" do
-    it "contains a static-data path component" do
-      expect(request.api_url("foo")).to eq("https://global.api.pvp.net/api/lol/static-data/euw/v1.2/foo?api_key=api_key")
-    end
-  end
-
-  StaticRequest::STANDARD_ENDPOINTS.each do |endpoint|
-    describe "##{endpoint}" do
+  let(:subject) { StaticRequest.new("api_key", "euw") }
+
+  {
+    "champion"       => "champions",
+    "item"           => "items",
+    "mastery"        => "masteries",
+    "rune"           => "runes",
+    "summoner_spell" => "summoner_spells"
+  }.each do |old_edpoint, new_endpoint|
+    describe "##{new_endpoint}" do
       it "returns a Proxy" do
-        expect(request.send(endpoint).class).to eq(StaticRequest::Proxy)
+        expect(subject.send(new_endpoint).class).to eq(StaticRequest::Proxy)
       end
 
       describe "#get" do
-        it "proxies get to StaticRequest with the correct endpoint" do
-          expect(request).to receive(:get).with(endpoint, anything, anything)
+        let(:fixture_name) { "static-#{new_endpoint.dasherize}" }
 
-          request.send(endpoint).get
+        it "proxies get to StaticRequest with the correct endpoint" do
+          expect(subject).to receive(:get).with(new_endpoint, anything, anything)
+          subject.send(new_endpoint).get
         end
 
-        context "without_id" do
-
-          let(:fixture_name) { endpoint == 'champion' ? 'static-champion' : endpoint.dasherize }
+        context "without an id" do
           let(:fixture) { load_fixture(fixture_name, StaticRequest.api_version) }
 
-          subject { request.public_send(endpoint).get }
+          let(:result) { subject.public_send(new_endpoint).get }
 
-          before(:each) { stub_request(request, fixture_name, "#{endpoint.dasherize}") }
+          before { stub_request(subject, fixture_name, "#{new_endpoint.dasherize}") }
 
-          it "returns an Array" do
-            expect(subject).to be_an(Array)
+          it "returns an Array of OpenStruct" do
+            expect(result).to be_a Array
+            expect(result.map(&:class).uniq).to eq([OpenStruct])
           end
 
-          it "returns an Array of OpenStructs" do
-            expect(subject.map(&:class).uniq).to eq([OpenStruct])
-          end
-
-          it "fetches #{endpoint} from the API" do
-            expect(subject.size).to eq(fixture["data"].size)
+          it "fetches #{new_endpoint} from the API" do
+            expect(result.size).to eq(fixture["data"].size)
           end
         end
 
-        context "with_id" do
-          let(:id) { 1 }
-
-          before(:each) { stub_request(request, "#{endpoint.dasherize}-by-id", "#{endpoint.dasherize}/#{id}") }
-
-          subject { request.public_send(endpoint).get(id) }
-
+        context "with an id" do
           it "returns an OpenStruct" do
-            expect(subject).to be_an(OpenStruct)
+            stub_request(subject, "#{fixture_name}-by-id", "#{new_endpoint.dasherize}/1")
+            expect(subject.public_send(new_endpoint).get 1).to be_a OpenStruct
           end
         end
       end
     end
   end
 
-  describe "#realm" do
-    subject { request.realm.get }
+  describe "#maps" do
+    let(:result) { subject.maps.get }
+
+    before(:each) { stub_request(subject, 'static-maps', 'maps') }
+
+    it "returns an Array of OpenStructs" do
+      expect(result).to be_a Array
+      expect(result.map(&:class).uniq).to eq [OpenStruct]
+    end
+  end
+
+  describe "#realms" do
+    let(:result) { subject.realms.get }
 
-    before(:each) { stub_request(request, 'realm', 'realm') }
+    before(:each) { stub_request(subject, 'static-realms', 'realms') }
 
     it "returns an OpenStruct" do
-      expect(subject).to be_an(OpenStruct)
+      expect(result).to be_a OpenStruct
     end
   end
 
   describe "#versions" do
-    subject { request.versions.get }
+    let(:result) { subject.versions.get }
 
-    before(:each) { stub_request(request, 'versions', 'versions') }
+    before(:each) { stub_request(subject, 'static-versions', 'versions') }
 
     it "returns an Array" do
-      expect(subject).to be_an(Array)
+      expect(result).to be_an(Array)
     end
   end