infostrada 0.1.26 → 0.1.27

data/spec/nation_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+RSpec.describe Infostrada::Nation do
+  let(:home_team) { JSONHelper::Nation.get(:home_team) }
+  let(:away_team) { JSONHelper::Nation.get(:away_team) }
+  let(:referee) { JSONHelper::Nation.get(:referee) }
+  let(:team) { JSONHelper::Nation.get(:team) }
+  let(:competition) { JSONHelper::Nation.get(:competition) }
+  let(:nation) { Infostrada::Nation }
+
+  describe '#initialize' do
+    context 'home team nation' do
+      let(:home_team_nation) { nation.new(home_team, 'home_team') }
+
+      it 'has id' do
+        expect(home_team_nation.id).to eq(2235)
+      end
+
+      it 'has name' do
+        expect(home_team_nation.name).to eq('Brazil')
+      end
+
+      it 'has short name' do
+        expect(home_team_nation.short_name).to eq('BRA')
+      end
+    end
+
+    context 'away team nation' do
+      let(:away_team_nation) { nation.new(away_team, 'away_team') }
+
+      it 'has id' do
+        expect(away_team_nation.id).to eq(2236)
+      end
+
+      it 'has name' do
+        expect(away_team_nation.name).to eq('Argentina')
+      end
+
+      it 'has short name' do
+        expect(away_team_nation.short_name).to eq('AR')
+      end
+    end
+
+    context 'referee nation' do
+      let(:referee_nation) { nation.new(referee, 'referee') }
+
+      it 'has id' do
+        expect(referee_nation.id).to eq(0)
+      end
+
+      it 'has name' do
+        expect(referee_nation.name).to eq('Portugal')
+      end
+
+      it 'has short name' do
+        expect(referee_nation.short_name).to eq('PT')
+      end
+    end
+
+    context 'team nation' do
+      let(:team_nation) { nation.new(team, 'team') }
+
+      it 'has id' do
+        expect(team_nation.id).to eq(2235)
+      end
+
+      it 'has name' do
+        expect(team_nation.name).to eq('Brazil')
+      end
+
+      it 'has short name' do
+        expect(team_nation.short_name).to eq('BRA')
+      end
+    end
+
+    context 'competition nation' do
+      let(:competition_nation) { nation.new(competition, 'competition') }
+
+      it 'has id' do
+        expect(competition_nation.id).to eq(2101)
+      end
+
+      it 'has name' do
+        expect(competition_nation.name).to eq('Europe')
+      end
+
+      it 'has short name' do
+        expect(competition_nation.short_name).to eq('EUR')
+      end
+    end
+  end
+
+  describe '.from_json' do
+    context 'home team nation' do
+      let(:home_team_nation_json) { nation.new(home_team, 'home_team').as_json }
+      let(:home_from_json) { nation.from_json(home_team_nation_json, 'home_team') }
+
+      it 'has id' do
+        expect(home_from_json.id).to eq(2235)
+      end
+
+      it 'has name' do
+        expect(home_from_json.name).to eq('Brazil')
+      end
+
+      it 'has short name' do
+        expect(home_from_json.short_name).to eq('BRA')
+      end
+    end
+
+    context 'away team nation' do
+      let(:away_team_nation_json) { nation.new(away_team, 'away_team').as_json }
+      let(:away_from_json) { nation.from_json(away_team_nation_json, 'away_team') }
+
+      it 'has id' do
+        expect(away_from_json.id).to eq(2236)
+      end
+
+      it 'has name' do
+        expect(away_from_json.name).to eq('Argentina')
+      end
+
+      it 'has short name' do
+        expect(away_from_json.short_name).to eq('AR')
+      end
+    end
+
+    context 'referee nation' do
+      let(:referee_nation_json) { nation.new(referee, 'referee').as_json }
+      let(:referee_from_json) { nation.from_json(referee_nation_json, 'referee') }
+
+      it 'has id' do
+        expect(referee_from_json.id).to eq(0)
+      end
+
+      it 'has name' do
+        expect(referee_from_json.name).to eq('Portugal')
+      end
+
+      it 'has short name' do
+        expect(referee_from_json.short_name).to eq('PT')
+      end
+    end
+
+    context 'team nation' do
+      let(:team_nation_json) { nation.new(team, 'team').as_json }
+      let(:team_from_json) { nation.from_json(team_nation_json, 'team') }
+
+      it 'has id' do
+        expect(team_from_json.id).to eq(2235)
+      end
+
+      it 'has name' do
+        expect(team_from_json.name).to eq('Brazil')
+      end
+
+      it 'has short name' do
+        expect(team_from_json.short_name).to eq('BRA')
+      end
+    end
+
+    context 'competition nation' do
+      let(:competition_nation_json) { nation.new(competition, 'competition').as_json }
+      let(:competition_from_json) { nation.from_json(competition_nation_json, 'competition') }
+
+      it 'has id' do
+        expect(competition_from_json.id).to eq(2101)
+      end
+
+      it 'has name' do
+        expect(competition_from_json.name).to eq('Europe')
+      end
+
+      it 'has short name' do
+        expect(competition_from_json.short_name).to eq('EUR')
+      end
+    end
+  end
+end

data/spec/person_info_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+RSpec.describe Infostrada::PersonInfo do
+  let(:default) { JSONHelper::PersonInfo.get(:default) }
+  let(:person_id) { 611_005 }
+  let(:person_info) { Infostrada::PersonInfo }
+
+  let(:path) { 'GetPersonInfo' }
+  let(:uri) { "#{@base_url}/#{path}?#{@default_params}&&personid=#{person_id}" }
+
+  # [default] - infostrada returns an array
+  before do
+    stub_request(:get, uri)
+      .to_return(status: 200, body: [default].to_json)
+  end
+
+  describe '.where' do
+    it 'returns new person info' do
+      result = person_info.where(person_id: person_id)
+
+      expect(result).not_to be_nil
+      expect(result).to be_kind_of(person_info)
+    end
+  end
+
+  describe '#initialize' do
+    let(:default_person) { person_info.new(person_id, default) }
+
+    it 'has id' do
+      expect(default_person.id).to eq(person_id)
+    end
+
+    it 'has first name' do
+      expect(default_person.first_name).to eq(default['c_FirstName'])
+    end
+
+    it 'has last name' do
+      expect(default_person.last_name).to eq(default['c_LastName'])
+    end
+
+    it 'has public name' do
+      expect(default_person.public_name).to eq(default['c_PublicName'])
+    end
+
+    it 'has nickname' do
+      expect(default_person.nickname).to eq(default['c_Nickname'])
+    end
+
+    it 'has birthdate' do
+      expect(default_person.birthdate).not_to be_nil
+    end
+
+    it 'has height' do
+      expect(default_person.height).to eq(default['n_Height'])
+    end
+
+    it 'has weight' do
+      expect(default_person.weight).to eq(default['n_Weight'])
+    end
+
+    it 'has birth city' do
+      expect(default_person.birth_city).to eq(default['c_BirthCity'])
+    end
+
+    it 'has birth country' do
+      expect(default_person.birth_country).to eq(default['c_BirthCountry'])
+    end
+  end
+end

data/spec/phase_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+RSpec.describe Infostrada::Competition do
+  let(:default)       { JSONHelper::Phase.get(:default).first }
+  let(:list)          { JSONHelper::Phase.get(:list) }
+  let(:phase)         { Infostrada::Phase }
+  let(:default_phase) { phase.new(default.clone) }
+  let(:serialized)    { default_phase.as_json }
+  let(:edition_id)    { 1 }
+  let(:uri) do
+    "#{@base_url}/GetPhaseList?#{@default_params}&&editionid=#{edition_id}"
+  end
+
+  before do
+    stub_request(:get, uri)
+      .to_return(status: 200, body: list.to_json)
+  end
+
+  describe '.where' do
+    it 'returns a list of phases' do
+      phases = phase.where(edition_id: edition_id)
+      expect(phases.count).to eq(list.count)
+      expect(phases.first).to be_a(phase)
+    end
+  end
+
+  describe '#initialize' do
+    let(:p) { phase.new(default.clone) }
+
+    it 'has id' do
+      expect(p.id).to eq(default['n_PhaseID'])
+    end
+
+    it 'has name' do
+      expect(p.name).to eq(default['c_Phase'])
+    end
+
+    it 'has level' do
+      expect(p.level).to eq(default['n_PhaseLevel'])
+    end
+
+    it 'has short_name' do
+      expect(p.short_name).to eq(default['c_PhaseShort'])
+    end
+
+    it 'has phase1_id' do
+      expect(p.phase1_id).to eq(default['n_Phase1ID'])
+    end
+
+    it 'has phase1_name' do
+      expect(p.phase1_name).to eq(default['c_Phase1'])
+    end
+
+    it 'has phase2_id' do
+      expect(p.phase2_id).to eq(default['n_Phase2ID'])
+    end
+
+    it 'has phase2_name' do
+      expect(p.phase2_name).to eq(default['c_Phase2'])
+    end
+
+    it 'has phase3_id' do
+      expect(p.phase3_id).to eq(default['n_Phase3ID'])
+    end
+
+    it 'has phase3_name' do
+      expect(p.phase3_name).to eq(default['c_Phase3'])
+    end
+
+    it 'has has_table' do
+      expect(p.has_table).to eq(default['b_Table'])
+    end
+
+    it 'has current' do
+      expect(p.current).to eq(default['b_Current'])
+    end
+
+    it 'has currents' do
+      expect(p.currents).to eq(default['b_Currents'])
+    end
+
+    it 'has start date' do
+      date = Date.parse(default['n_DateStart'].to_s)
+      expect(p.start_date).to eq(date)
+    end
+
+    it 'has end date' do
+      date = Date.parse(default['n_DateEnd'].to_s)
+      expect(p.end_date).to eq(date)
+    end
+  end
+
+  describe '.from_json' do
+    let(:from_json) { phase.from_json(serialized) }
+
+    it 'has id' do
+      expect(from_json.id).to eq(default_phase.id)
+    end
+
+    it 'has name' do
+      expect(from_json.name).to eq(default_phase.name)
+    end
+
+    it 'has level' do
+      expect(from_json.level).to eq(default_phase.level)
+    end
+
+    it 'has short_name' do
+      expect(from_json.short_name).to eq(default_phase.short_name)
+    end
+
+    it 'has phase1_id' do
+      expect(from_json.phase1_id).to eq(default_phase.phase1_id)
+    end
+
+    it 'has phase1_name' do
+      expect(from_json.phase1_name).to eq(default_phase.phase1_name)
+    end
+
+    it 'has phase2_id' do
+      expect(from_json.phase2_id).to eq(default_phase.phase2_id)
+    end
+
+    it 'has phase2_name' do
+      expect(from_json.phase2_name).to eq(default_phase.phase2_name)
+    end
+
+    it 'has phase3_id' do
+      expect(from_json.phase3_id).to eq(default_phase.phase3_id)
+    end
+
+    it 'has phase3_name' do
+      expect(from_json.phase3_name).to eq(default_phase.phase3_name)
+    end
+
+    it 'has has_table' do
+      expect(from_json.has_table).to eq(default_phase.has_table)
+    end
+
+    it 'has current' do
+      expect(from_json.current).to eq(default_phase.current)
+    end
+
+    it 'has currents' do
+      expect(from_json.currents).to eq(default_phase.currents)
+    end
+
+    it 'has start date' do
+      expect(from_json.start_date).to eq(default_phase.start_date)
+    end
+
+    it 'has end date' do
+      expect(from_json.end_date).to eq(default_phase.end_date)
+    end
+  end
+
+  module NullTable
+    class Infostrada::Table
+      class << self
+        attr_accessor :phase_id
+
+        def where(options = {})
+          @phase_id = options.delete(:phase_id)
+          true
+        end
+      end
+    end
+  end
+
+  # Only way to get the nulltable table scope
+  Mock = Struct.new(:phase_id) do
+    include NullTable
+  end
+
+  describe '#table' do
+    it 'calls Table where' do
+      phase.send(:include, NullTable)
+      dphase = phase.new(default.clone)
+      expect(dphase.table).to be(true)
+      expect(Mock::Infostrada::Table.phase_id).to be(default_phase.id)
+    end
+  end
+end

data/spec/player_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+RSpec.describe Infostrada::Player do
+  let(:default) { JSONHelper::Player.get(:default) }
+  let(:goalkeeper) { JSONHelper::Player.get(:goalkeeper) }
+  let(:player) { Infostrada::Player }
+  let(:p) { player.new(default) }
+
+  describe '#initialize' do
+    it 'has person_id' do
+      expect(p.person_id).to eq(default['n_PersonID'])
+    end
+
+    it 'has name' do
+      expect(p.name).to eq(default['c_Person'])
+    end
+
+    it 'has short_name' do
+      expect(p.short_name).to eq(default['c_PersonShort'])
+    end
+
+    it 'has birthdate' do
+      expect(p.birthdate).not_to be_nil
+    end
+
+    it 'has function' do
+      expect(p.function).to eq(default['c_Function'])
+    end
+
+    it 'has function_type' do
+      expect(p.function_type).to eq(default['n_FunctionType'])
+    end
+
+    it 'has shirt_number' do
+      expect(p.shirt_number).to eq(default['n_ShirtNr'])
+    end
+
+    it 'has contract_starts_at' do
+      expect(p.contract_starts_at).not_to be_nil
+    end
+
+    it 'has contract_ends_at' do
+      expect(p.contract_ends_at).not_to be_nil
+    end
+
+    it 'has nation' do
+      expect(p.nation).not_to be_nil
+    end
+
+    it 'calls set_season_stats' do
+      called = false
+      expect_any_instance_of(player).to receive(:set_season_stats) do
+        called = true
+      end
+      player.new(default.clone)
+
+      expect(called).to be(true)
+    end
+  end
+
+  describe '#set_season_stats' do
+    context 'season stats hash' do
+      it 'has matches' do
+        expect(p.season_stats[:matches]).to eq(default['n_Matches'])
+      end
+
+      it 'has matches_start' do
+        expect(p.season_stats[:matches_start]).to eq(default['n_MatchesStart'])
+      end
+
+      it 'has matches_out' do
+        expect(p.season_stats[:matches_out]).to eq(default['n_MatchesOut'])
+      end
+
+      it 'has matches_in' do
+        expect(p.season_stats[:matches_in]).to eq(default['n_MatchesIn'])
+      end
+
+      it 'has minutes_played' do
+        expect(p.season_stats[:minutes_played]).to eq(default['n_MinutesPlayed'])
+      end
+
+      it 'has goals' do
+        expect(p.season_stats[:goals]).to eq(default['n_Goals'])
+      end
+
+      it 'has own_goals' do
+        expect(p.season_stats[:own_goals]).to eq(default['n_OwnGoals'])
+      end
+
+      it 'has assists' do
+        expect(p.season_stats[:assists]).to eq(default['n_Assists'])
+      end
+
+      it 'has cards_yellow' do
+        expect(p.season_stats[:cards_yellow]).to eq(default['n_CardsYellow'])
+      end
+
+      it 'has cards_red' do
+        expect(p.season_stats[:cards_red]).to eq(default['n_CardsRed'])
+      end
+
+      it 'has cards_red_direct' do
+        expect(p.season_stats[:cards_red_direct]).to eq(default['n_CardsRedDirect'])
+      end
+
+      it 'has cards_red_from_yellow' do
+        expect(p.season_stats[:cards_red_from_yellow]).to eq(default['n_CardsRed2Yellow'])
+      end
+    end
+  end
+end