sports_data_api 0.12.1 → 0.13.0

data/spec/lib/sports_data_api/nhl/player_spec.rb

@@ -7,50 +7,102 @@ describe SportsDataApi::Nhl::Player, vcr: {
 } do
   before do
     SportsDataApi.set_key(:nhl, api_key(:nhl))
-    SportsDataApi.set_access_level(:nhl, 'ot')
+    SportsDataApi.set_access_level(:nhl, 'trial')
   end
-  let(:player) { SportsDataApi::Nhl.team_roster('441713b7-0f24-11e2-8525-18a905767e44').players.first.player }
-
-  describe 'player' do
-    subject { player }
-    it 'should have an id' do
-      expect(subject[:id]).to eq '3d1e8155-8371-11e2-a3e0-f4ce4684ea4c'
-    end
-
-    it 'should have a status' do
-      expect(subject[:status]).to eq 'ACT'
-    end
-
-    it 'should have a full_name' do
-      expect(subject[:full_name]).to eq 'Brian Flynn'
-    end
-
-    it 'should have a first_name' do
-      expect(subject[:first_name]).to eq 'Brian'
-    end
-
-    it 'should have a last_name' do
-      expect(subject[:last_name]).to eq 'Flynn'
-    end
-
-    it 'should have an abbr_name' do
-      expect(subject[:abbr_name]).to eq 'B.Flynn'
-    end
-
-    it 'should have a handedness' do
-      expect(subject[:handedness]).to eq 'R'
-    end
-
-    it 'should have a position' do
-      expect(subject[:position]).to eq 'F'
+  context 'when from team_roster' do
+    let(:roster) { SportsDataApi::Nhl.team_roster('4416091c-0f24-11e2-8525-18a905767e44') }
+    let(:players) { roster.players }
+    it 'parses out the data' do
+      player = players.find do |x|
+        x.player[:id] == '431e124a-0f24-11e2-8525-18a905767e44'
+      end
+      expect(player[:status]).to eq 'ACT'
+      expect(player[:full_name]).to eq 'Zach Parise'
+      expect(player[:first_name]).to eq 'Zach'
+      expect(player[:last_name]).to eq 'Parise'
+      expect(player[:abbr_name]).to eq 'Z.Parise'
+      expect(player[:height]).to eq 71
+      expect(player[:weight]).to eq 196
+      expect(player[:position]).to eq 'F'
+      expect(player[:primary_position]).to eq 'LW'
+      expect(player[:jersey_number]).to eq '11'
+      expect(player[:experience]).to eq '11'
+      expect(player[:college]).to eq 'North Dakota'
+      expect(player[:birth_place]).to eq 'Minneapolis, MN, USA'
+      expect(player[:birthdate]).to eq '1984-07-28'
+      expect(player[:updated]).to eq '2018-01-02T18:04:00+00:00'
+      expect(player[:reference]).to eq '8470610'
+      expect(player.stats).to be_nil
     end
+  end
 
-    it 'should have a primary_position' do
-      expect(subject[:primary_position]).to eq 'LW'
-    end
+  context 'when from .game_summary' do
+    let(:game_summary) { SportsDataApi::Nhl.game_summary('af285aa3-3d80-4051-9449-5b58e5985a4e') }
+    let(:team) { game_summary.home_team }
+    let(:players) { team.players }
 
-    it 'should have a jersey_number' do
-      expect(subject[:jersey_number]).to eq '32'
+    it 'parses out the data' do
+      player = players.find do |x|
+        x.player[:id] == '431e124a-0f24-11e2-8525-18a905767e44'
+      end
+      expect(player[:status]).to be_nil
+      expect(player[:full_name]).to eq 'Zach Parise'
+      expect(player[:first_name]).to eq 'Zach'
+      expect(player[:last_name]).to eq 'Parise'
+      expect(player[:position]).to eq 'F'
+      expect(player[:primary_position]).to eq 'LW'
+      expect(player[:jersey_number]).to eq '11'
+      expect(player[:starter]).to eq true
+      expect(player[:played]).to eq true
+      expect(player.stats).to be_a SportsDataApi::MergedStats
+      expect(player.stats[:total_goals]).to eq 0
+      expect(player.stats[:total_assists]).to eq 1
+      expect(player.stats[:total_penalties]).to eq 1
+      expect(player.stats[:total_penalty_minutes]).to eq 2
+      expect(player.stats[:total_shots]).to eq 2
+      expect(player.stats[:total_blocked_att]).to eq 0
+      expect(player.stats[:total_missed_shots]).to eq 2
+      expect(player.stats[:total_hits]).to eq 1
+      expect(player.stats[:total_giveaways]).to eq 0
+      expect(player.stats[:total_takeaways]).to eq 2
+      expect(player.stats[:total_blocked_shots]).to eq 2
+      expect(player.stats[:total_faceoffs_won]).to eq 0
+      expect(player.stats[:total_faceoffs_lost]).to eq 0
+      expect(player.stats[:total_plus_minus]).to eq(-1)
+      expect(player.stats[:total_shooting_pct]).to eq 0
+      expect(player.stats[:total_faceoff_win_pct]).to eq 0
+      expect(player.stats[:total_faceoffs]).to eq 0
+      expect(player.stats[:total_points]).to eq 1
+      expect(player.stats[:powerplay_shots]).to eq 0
+      expect(player.stats[:powerplay_goals]).to eq 0
+      expect(player.stats[:powerplay_missed_shots]).to eq 0
+      expect(player.stats[:powerplay_assists]).to eq 0
+      expect(player.stats[:powerplay_faceoffs]).to eq 0
+      expect(player.stats[:powerplay_faceoffs_won]).to eq 0
+      expect(player.stats[:powerplay_faceoffs_lost]).to eq 0
+      expect(player.stats[:powerplay_faceoff_win_pct]).to eq 0
+      expect(player.stats[:shorthanded_shots]).to eq 0
+      expect(player.stats[:shorthanded_goals]).to eq 0
+      expect(player.stats[:shorthanded_missed_shots]).to eq 0
+      expect(player.stats[:shorthanded_assists]).to eq 0
+      expect(player.stats[:shorthanded_faceoffs]).to eq 0
+      expect(player.stats[:shorthanded_faceoffs_won]).to eq 0
+      expect(player.stats[:shorthanded_faceoffs_lost]).to eq 0
+      expect(player.stats[:shorthanded_faceoff_win_pct]).to eq 0
+      expect(player.stats[:evenstrength_shots]).to eq 2
+      expect(player.stats[:evenstrength_goals]).to eq 0
+      expect(player.stats[:evenstrength_missed_shots]).to eq 2
+      expect(player.stats[:evenstrength_assists]).to eq 1
+      expect(player.stats[:evenstrength_faceoffs]).to eq 0
+      expect(player.stats[:evenstrength_faceoffs_won]).to eq 0
+      expect(player.stats[:evenstrength_faceoffs_lost]).to eq 0
+      expect(player.stats[:evenstrength_faceoff_win_pct]).to eq 0
+      expect(player.stats[:penalty_shots]).to eq 0
+      expect(player.stats[:penalty_goals]).to eq 0
+      expect(player.stats[:penalty_missed_shots]).to eq 0
+      expect(player.stats[:shootout_shots]).to eq 0
+      expect(player.stats[:shootout_goals]).to eq 0
+      expect(player.stats[:shootout_missed_shots]).to eq 0
     end
   end
 end

data/spec/lib/sports_data_api/nhl/season_spec.rb

@@ -28,7 +28,7 @@ describe SportsDataApi::Nhl::Season, vcr: {
   end
   context 'results from schedule fetch' do
       let(:season) do
-        SportsDataApi.set_access_level(:nhl, 'ot')
+        SportsDataApi.set_access_level(:nhl, 'trial')
         SportsDataApi.set_key(:nhl, api_key(:nhl))
         SportsDataApi::Nhl.schedule(2013, :reg)
       end

data/spec/lib/sports_data_api/nhl/team_spec.rb

@@ -5,235 +5,147 @@ describe SportsDataApi::Nhl::Team, vcr: {
     record: :new_episodes,
     match_requests_on: [:host, :path]
 } do
-  let(:teams) do
+  before do
     SportsDataApi.set_key(:nhl, api_key(:nhl))
-    SportsDataApi.set_access_level(:nhl, 'ot')
-    SportsDataApi::Nhl.teams
-  end
-  let(:roster) do
-    SportsDataApi.set_key(:nhl, api_key(:nhl))
-    SportsDataApi.set_access_level(:nhl, 'ot')
-    SportsDataApi::Nhl.team_roster('44151f7a-0f24-11e2-8525-18a905767e44')
-  end
-  let(:game_summary) do
-    SportsDataApi.set_key(:nhl, api_key(:nhl))
-    SportsDataApi.set_access_level(:nhl, 'ot')
-    SportsDataApi::Nhl.game_summary('f0f7e327-3a3a-410b-be75-0956c90c4988')
+    SportsDataApi.set_access_level(:nhl, 'trial')
   end
 
   context 'results from teams fetch' do
-    subject { teams.first }
+    let(:teams) { SportsDataApi::Nhl.teams }
+    subject { teams.find { |t| t.alias == 'MIN' } }
+
     it { should be_an_instance_of(SportsDataApi::Nhl::Team) }
-    its(:id) { should eq "44151f7a-0f24-11e2-8525-18a905767e44" }
-    its(:alias) { should eq 'LA' }
+    its(:id) { should eq '4416091c-0f24-11e2-8525-18a905767e44' }
     its(:conference) { should eq 'WESTERN' }
-    its(:division) { should eq 'PACIFIC' }
-    its(:market) { should eq 'Los Angeles' }
-    its(:name) { should eq 'Kings' }
+    its(:division) { should eq 'CENTRAL' }
+    its(:market) { should eq 'Minnesota' }
+    its(:name) { should eq 'Wild' }
     its(:players) { should eq [] }
     its(:points) { should be_nil }
   end
+
   context 'results from team roster fetch' do
+    let(:roster) { SportsDataApi::Nhl.team_roster('4416091c-0f24-11e2-8525-18a905767e44') }
     subject { roster }
+
     it { should be_an_instance_of(SportsDataApi::Nhl::Team) }
-    its(:id) { should eq "44151f7a-0f24-11e2-8525-18a905767e44" }
-    its(:alias) { should eq 'LA' }
-    its(:market) { should eq 'Los Angeles' }
-    its(:name) { should eq 'Kings' }
-    its(:players) { should be_an_instance_of(Array) }
+    its(:id) { should eq '4416091c-0f24-11e2-8525-18a905767e44' }
+    its(:conference) { should eq 'WESTERN' }
+    its(:division) { should eq 'CENTRAL' }
+    its(:market) { should eq 'Minnesota' }
+    its(:name) { should eq 'Wild' }
     its(:points) { should be_nil }
-    context 'players' do
-      subject { roster.players }
-      its(:count) { should eq 25 }
+    it 'parses players' do
+      expect(subject.players.count).to eq 24
+      expect(subject.players.first).to be_a SportsDataApi::Nhl::Player
     end
   end
+
   context 'results from game_summary fetch' do
+    let(:game_summary) { SportsDataApi::Nhl.game_summary('af285aa3-3d80-4051-9449-5b58e5985a4e') }
     subject { game_summary.home_team }
+
     it { should be_an_instance_of(SportsDataApi::Nhl::Team) }
-    its(:id) { should eq '441713b7-0f24-11e2-8525-18a905767e44' }
-    its(:market) { should eq 'Montreal' }
-    its(:name) { should eq 'Canadiens' }
-    its(:points) { should eq 3 }
-    its(:alias) { should be_nil }
+    its(:id) { should eq '4416091c-0f24-11e2-8525-18a905767e44' }
     its(:conference) { should be_nil }
     its(:division) { should be_nil }
-    its(:players) { should be_an_instance_of(Array) }
+    its(:market) { should eq 'Minnesota' }
+    its(:name) { should eq 'Wild' }
+    its(:points) { should eq 4 }
+    its(:alias) { should be_nil }
 
     context 'players' do
       subject { game_summary.home_team.players }
-      its(:count) { should eq 26 }
+      its(:count) { should eq 22 }
     end
 
     context 'player' do
-      subject { game_summary.away_team.players.first }
+      let(:team) { game_summary.home_team }
+      let(:players) { team.players }
+      subject { players.find{ |x| x[:id] == '431e124a-0f24-11e2-8525-18a905767e44' } }
       it { should be_an_instance_of(SportsDataApi::Nhl::Player) }
       it 'should have an id' do
-        expect(subject.player[:id]).to eq "42bf409e-0f24-11e2-8525-18a905767e44"
+        expect(subject.player[:id]).to eq '431e124a-0f24-11e2-8525-18a905767e44'
       end
       it 'should have a full_name' do
-        expect(subject.player[:full_name]).to eq "Dave Bolland"
+        expect(subject.player[:full_name]).to eq 'Zach Parise'
       end
       it 'should have a first_name' do
-        expect(subject.player[:first_name]).to eq "Dave"
+        expect(subject.player[:first_name]).to eq 'Zach'
       end
       it 'should have a last_name' do
-        expect(subject.player[:last_name]).to eq "Bolland"
+        expect(subject.player[:last_name]).to eq 'Parise'
       end
       it 'should have a position' do
-        expect(subject.player[:position]).to eq "F"
+        expect(subject.player[:position]).to eq 'F'
       end
       it 'should have a primary_position' do
-        expect(subject.player[:primary_position]).to eq "C"
+        expect(subject.player[:primary_position]).to eq 'LW'
       end
       it 'should have a jersey_number' do
-        expect(subject.player[:jersey_number]).to eq "63"
+        expect(subject.player[:jersey_number]).to eq '11'
       end
       it 'should have a played' do
-        expect(subject.player[:played]).to eq "true"
-      end
-      it 'should not be scratched' do
-        expect(subject.player[:scratched]).to eq nil
+        expect(subject.player[:played]).to eq true
       end
-      it 'should not have goaltending' do
-        expect(subject.stats.goaltending).to eq nil
+      it 'should have an starter' do
+        expect(subject.player[:starter]).to eq true
       end
+      its(:stats){ should be_an_instance_of(SportsDataApi::MergedStats) }
 
-      its(:stats){ should be_an_instance_of(SportsDataApi::Stats) }
       context 'stats' do
-        subject { game_summary.away_team.players.first.stats.statistics }
-        it 'should have goals' do
-          expect(subject[:goals]).to eq '0'
-        end
-        it 'should have assists' do
-          expect(subject[:assists]).to eq '0'
-        end
-        it 'should have penalties' do
-          expect(subject[:penalties]).to eq '1'
-        end
-        it 'should have penalty_minutes' do
-          expect(subject[:penalty_minutes]).to eq '2'
-        end
-        it 'should have shots' do
-          expect(subject[:shots]).to eq '2'
-        end
-        it 'should have blocked_att' do
-          expect(subject[:blocked_att]).to eq '1'
-        end
-        it 'should have missed_shots' do
-          expect(subject[:missed_shots]).to eq '1'
-        end
-        it 'should have hits' do
-          expect(subject[:hits]).to eq '4'
-        end
-        it 'should have blocked_att' do
-          expect(subject[:giveaways]).to eq '0'
-        end
-        it 'should have takeaways' do
-          expect(subject[:takeaways]).to eq '1'
-        end
-        it 'should have blocked_shots' do
-          expect(subject[:blocked_shots]).to eq '1'
-        end
-        it 'should have faceoffs_won' do
-          expect(subject[:faceoffs_won]).to eq '4'
-        end
-        it 'should have faceoffs_lost' do
-          expect(subject[:faceoffs_lost]).to eq '4'
-        end
-        it 'should have winning_goal' do
-          expect(subject[:winning_goal]).to be_falsy
-        end
-        it 'should have shooting_pct' do
-          expect(subject[:shooting_pct]).to eq '0.0'
-        end
-        it 'should have faceoffs' do
-          expect(subject[:faceoffs]).to eq '8'
-        end
-        it 'should have faceoff_win_pct' do
-          expect(subject[:faceoff_win_pct]).to eq '50.0'
-        end
-        it 'should have points' do
-          expect(subject[:points]).to eq '0'
-        end
-        it 'should have powerplay_shots' do
-          expect(subject[:powerplay_shots]).to eq '0'
-        end
-        it 'should have powerplay_goals' do
-          expect(subject[:powerplay_goals]).to eq '0'
-        end
-        it 'should have powerplay_missed_shots' do
-          expect(subject[:powerplay_missed_shots]).to eq '0'
-        end
-        it 'should have powerplay_assists' do
-          expect(subject[:powerplay_assists]).to eq '0'
-        end
-        it 'should have shorthanded_shots' do
-          expect(subject[:shorthanded_shots]).to eq '0'
-        end
-        it 'should have shorthanded_goals' do
-          expect(subject[:shorthanded_goals]).to eq '0'
-        end
-        it 'should have shorthanded_missed_shots' do
-          expect(subject[:shorthanded_missed_shots]).to eq '0'
-        end
-        it 'should have shorthanded_assists' do
-          expect(subject[:shorthanded_assists]).to eq '0'
-        end
-        it 'should have eventstrength_shots' do
-          expect(subject[:evenstrength_shots]).to eq '2'
-        end
-        it 'should have eventstrength_goals' do
-          expect(subject[:evenstrength_goals]).to eq '0'
-        end
-        it 'should have eventstrength_missed_shots' do
-          expect(subject[:evenstrength_missed_shots]).to eq '1'
-        end
-        it 'should have eventstrength_assists' do
-          expect(subject[:evenstrength_assists]).to eq '0'
-        end
-        it 'should have penalty_shots' do
-          expect(subject[:penalty_shots]).to eq '0'
-        end
-        it 'should have penalty_goals' do
-          expect(subject[:penalty_goals]).to eq '0'
-        end
-        it 'should have penalty_missed_shots' do
-          expect(subject[:penalty_missed_shots]).to eq '0'
-        end
-        it 'should have shootout_shots' do
-          expect(subject[:shootout_shots]).to eq '0'
-        end
-        it 'should have shootout_goals' do
-          expect(subject[:shootout_goals]).to eq '0'
-        end
-        it 'should have shootout_missed_shots' do
-          expect(subject[:shootout_missed_shots]).to eq '0'
-        end
-      end
-    end
+        subject { game_summary.home_team.players.first.stats }
 
-    context 'goalie' do
-      subject { game_summary.away_team.players.select { |player| !player.stats.goaltending.nil? }.first.stats.goaltending }
-      it 'should have goaltending' do
-        expect(subject).to be_a Hash
-      end
-      it 'should have shots_against' do
-        expect(subject[:shots_against]).to eq '37'
-      end
-      it 'should have goals_against' do
-        expect(subject[:goals_against]).to eq '3'
-      end
-      it 'should have saves' do
-        expect(subject[:saves]).to eq '34'
-      end
-      it 'should have credit' do
-        expect(subject[:credit]).to eq 'win'
-      end
-      it 'should have shutout' do
-        expect(subject[:shutout]).to be_falsy
-      end
-      it 'should have saves_pct' do
-        expect(subject[:saves_pct]).to eq '0.919'
+        it 'parses the stats' do
+          expect(subject[:total_goals]).to eq 0
+          expect(subject[:total_assists]).to eq 1
+          expect(subject[:total_penalties]).to eq 0
+          expect(subject[:total_penalty_minutes]).to eq 0
+          expect(subject[:total_shots]).to eq 0
+          expect(subject[:total_blocked_att]).to eq 2
+          expect(subject[:total_missed_shots]).to eq 0
+          expect(subject[:total_hits]).to eq 0
+          expect(subject[:total_giveaways]).to eq 0
+          expect(subject[:total_takeaways]).to eq 0
+          expect(subject[:total_blocked_shots]).to eq 0
+          expect(subject[:total_faceoffs_won]).to eq 0
+          expect(subject[:total_faceoffs_lost]).to eq 0
+          expect(subject[:total_plus_minus]).to eq 1
+          expect(subject[:total_shooting_pct]).to eq 0
+          expect(subject[:total_faceoff_win_pct]).to eq 0
+          expect(subject[:total_faceoffs]).to eq 0
+          expect(subject[:total_points]).to eq 1
+          expect(subject[:powerplay_shots]).to eq 0
+          expect(subject[:powerplay_goals]).to eq 0
+          expect(subject[:powerplay_missed_shots]).to eq 0
+          expect(subject[:powerplay_assists]).to eq 0
+          expect(subject[:powerplay_faceoffs]).to eq 0
+          expect(subject[:powerplay_faceoffs_won]).to eq 0
+          expect(subject[:powerplay_faceoffs_lost]).to eq 0
+          expect(subject[:powerplay_faceoff_win_pct]).to eq 0
+          expect(subject[:shorthanded_shots]).to eq 0
+          expect(subject[:shorthanded_goals]).to eq 0
+          expect(subject[:shorthanded_missed_shots]).to eq 0
+          expect(subject[:shorthanded_assists]).to eq 0
+          expect(subject[:shorthanded_faceoffs]).to eq 0
+          expect(subject[:shorthanded_faceoffs_won]).to eq 0
+          expect(subject[:shorthanded_faceoffs_lost]).to eq 0
+          expect(subject[:shorthanded_faceoff_win_pct]).to eq 0
+          expect(subject[:evenstrength_shots]).to eq 0
+          expect(subject[:evenstrength_goals]).to eq 0
+          expect(subject[:evenstrength_missed_shots]).to eq 0
+          expect(subject[:evenstrength_assists]).to eq 1
+          expect(subject[:evenstrength_faceoffs]).to eq 0
+          expect(subject[:evenstrength_faceoffs_won]).to eq 0
+          expect(subject[:evenstrength_faceoffs_lost]).to eq 0
+          expect(subject[:evenstrength_faceoff_win_pct]).to eq 0
+          expect(subject[:penalty_shots]).to eq 0
+          expect(subject[:penalty_goals]).to eq 0
+          expect(subject[:penalty_missed_shots]).to eq 0
+          expect(subject[:shootout_shots]).to eq 0
+          expect(subject[:shootout_goals]).to eq 0
+          expect(subject[:shootout_missed_shots]).to eq 0
+        end
       end
     end
   end

data/spec/lib/sports_data_api/nhl/teams_spec.rb

@@ -5,72 +5,21 @@ describe SportsDataApi::Nhl::Teams, vcr: {
     record: :new_episodes,
     match_requests_on: [:host, :path]
 } do
-  let(:teams) do
+  before do
     SportsDataApi.set_key(:nhl, api_key(:nhl))
-    SportsDataApi.set_access_level(:nhl, 'ot')
-    SportsDataApi::Nhl.teams
+    SportsDataApi.set_access_level(:nhl, 'trial')
   end
-
-  let(:url) { 'https://api.sportsdatallc.org/nhl-ot4/league/hierarchy.xml' }
-
-  let(:kings_xml) do
-    str = RestClient.get(url, params: { api_key: api_key(:nhl) }).to_s
-    xml = Nokogiri::XML(str)
-    xml.remove_namespaces!
-    xml.xpath('/league/conference/division/team[@alias=\'LA\']')
-  end
-
-  let(:kings) { SportsDataApi::Nhl::Team.new(kings_xml) }
-
-  subject { teams }
-  its(:conferences) { should eq %w(WESTERN EASTERN).map { |str| str.to_sym } }
-  its(:divisions) { should eq %w(PACIFIC CENTRAL ATLANTIC METROPOLITAN).map { |str| str.to_sym } }
-  its(:count) { should eq 30 }
-
-  it { subject[:"44151f7a-0f24-11e2-8525-18a905767e44"].should eq kings }
-
-  describe 'meta methods' do
-    it { should respond_to :EASTERN }
-    it { should respond_to :WESTERN }
-    it { should respond_to :eastern }
-    it { should respond_to :western }
-    it { should respond_to :ATLANTIC }
-    it { should respond_to :atlantic }
-    it { should respond_to :PACIFIC }
-
-    its(:EASTERN) { should be_a Array }
-    its(:WESTERN) { should be_a Array }
-
-    context '#EASTERN' do
-      subject { teams.EASTERN }
-      its(:count) { should eq 16 }
-    end
-
-    context '#eastern' do
-      subject { teams.eastern }
-      its(:count) { should eq 16 }
-    end
-
-    context '#WESTERN' do
-      subject { teams.WESTERN }
-      its(:count) { should eq 14 }
-    end
-
-    context '#western' do
-      subject { teams.western }
-      its(:count) { should eq 14 }
-    end
-
-    context '#pacific' do
-      subject { teams.pacific }
-      its(:count) { should eq 7 }
-      it { should include kings }
-    end
-
-    context '#PACIFIC' do
-      subject { teams.PACIFIC }
-      its(:count) { should eq 7 }
-      it { should include kings }
-    end
+  subject { SportsDataApi::Nhl.teams }
+
+  its(:count) { should eq 31 }
+  it 'parses outs the specific team' do
+    team = subject.find { |t| t.name == 'Red Wings' }
+    expect(team.id).to eq '44169bb9-0f24-11e2-8525-18a905767e44'
+    expect(team.market).to eq 'Detroit'
+    expect(team.alias).to eq 'DET'
+    expect(team.conference).to eq 'EASTERN'
+    expect(team.division).to eq 'ATLANTIC'
+    expect(team.venue).to be_a SportsDataApi::Nhl::Venue
+    expect(team.players).to be_empty
   end
 end

data/spec/lib/sports_data_api/nhl/venue_spec.rb

@@ -6,19 +6,22 @@ describe SportsDataApi::Nhl::Venue, vcr: {
     match_requests_on: [:host, :path]
 } do
   let(:daily_schedule) do
-    SportsDataApi.set_access_level(:nhl, 'ot')
+    SportsDataApi.set_access_level(:nhl, 'trial')
     SportsDataApi.set_key(:nhl, api_key(:nhl))
     SportsDataApi::Nhl.daily(2013, 12, 12)
   end
   context 'results from weekly schedule fetch' do
     subject { daily_schedule.first.venue }
-    its(:id) { should eq '0a162e5b-8d59-42d8-b173-a131bf632ffb' }
-    its(:name) { should eq 'Wells Fargo Center' }
-    its(:address) { should eq '3601 S. Broad St.' }
-    its(:city) { should eq 'Philadelphia' }
-    its(:state) { should eq 'PA' }
-    its(:zip) { '19148' }
-    its(:country) { should eq 'USA' }
-    its(:capacity) { should eq '19537' }
+    it 'parses the data' do
+      expect(subject[:id]).to eq '0a162e5b-8d59-42d8-b173-a131bf632ffb'
+      expect(subject[:name]).to eq 'Wells Fargo Center'
+      expect(subject[:capacity]).to eq 19543
+      expect(subject[:address]).to eq '3601 S. Broad St.'
+      expect(subject[:city]).to eq 'Philadelphia'
+      expect(subject[:state]).to eq 'PA'
+      expect(subject[:zip]).to eq '19148'
+      expect(subject[:country]).to eq 'USA'
+      expect(subject[:time_zone]).to eq 'US/Eastern'
+    end
   end
 end