rating-chgk-v2 1.0.0.rc1

data/spec/lib/rating_chgk_v2/rest/teams_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::Teams do
+  let(:team_id) { 2 }
+
+  specify '#team' do
+    team = VCR.use_cassette('teams/team') do
+      test_client.team(team_id)
+    end
+
+    expect(team.id).to eq(team_id)
+    expect(team.name).to eq('Афина')
+    expect(team.town['id']).to eq(201)
+  end
+
+  describe '#teams' do
+    it 'returns a collection of teams' do
+      teams = VCR.use_cassette('teams/all_teams') do
+        test_client.teams
+      end
+
+      expect(teams[1].name).to eq('Афина')
+      expect(teams[1].id).to eq(2)
+      expect(teams[1].town['id']).to eq(201)
+    end
+
+    it 'returns a collection of teams with params' do
+      teams = VCR.use_cassette('teams/all_teams_params') do
+        test_client.teams itemsPerPage: 2, name: 'Н', page: 3
+      end
+
+      expect(teams.count).to eq(2)
+      expect(teams[0].name).to eq('Миллениум')
+      expect(teams[0].id).to eq(11)
+      expect(teams[0].town['id']).to eq(282)
+    end
+  end
+
+  describe '#team_seasons' do
+    it 'returns seasons by params' do
+      team_seasons = VCR.use_cassette('teams/team_seasons_params') do
+        test_client.team_seasons team_id, idseason: 9
+      end
+
+      expect(team_seasons).to be_an_instance_of(RatingChgkV2::Collections::PlayerSeasonsCollection)
+      season = team_seasons.first
+
+      expect(season.idplayer).to eq(707)
+      expect(season.idseason).to eq(9)
+      expect(season.idteam).to eq(team_id)
+    end
+  end
+
+  describe '#team_tournaments' do
+    it 'returns a collection of team tournaments with params' do
+      team_tournaments = VCR.use_cassette('teams/team_tournaments_params') do
+        test_client.team_tournaments team_id, pagination: true
+      end
+
+      tour = team_tournaments[2]
+
+      expect(tour.idtournament).to eq(8)
+      expect(tour.idteam).to eq(team_id)
+    end
+  end
+end

data/spec/lib/rating_chgk_v2/rest/tournament_flags_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::TournamentFlags do
+  let(:id) { 2 }
+
+  describe '#tournament_flags' do
+    it 'returns a collection of tournament flags' do
+      flag = VCR.use_cassette('tournament_flags/all_tournament_flags') do
+        test_client.tournament_flags
+      end.first
+
+      expect(flag.id).to eq(1)
+      expect(flag.shortName).to eq('!')
+      expect(flag.longName).to eq('Общий зачёт')
+    end
+  end
+
+  specify '#tournament_flag' do
+    flag = VCR.use_cassette('tournament_flags/tournament_flag') do
+      test_client.tournament_flag id
+    end
+
+    expect(flag.id).to eq(id)
+    expect(flag.shortName).to eq('МШ')
+    expect(flag.longName).to eq('Младшие школьники (5-9 классы)')
+  end
+end

data/spec/lib/rating_chgk_v2/rest/tournament_synch_appeals_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::TournamentSynchAppeals do
+  let(:id) { 1000 }
+
+  specify '#tournament_synch_appeal' do
+    appeal = VCR.use_cassette('tournament_synch_appeals/tournament_synch_appeal') do
+      test_client.tournament_synch_appeal id
+    end
+
+    expect(appeal.id).to eq(id)
+    expect(appeal.idtournament).to eq(2225)
+    expect(appeal.type).to eq('A')
+    expect(appeal.issuedAt).to eq('2013-04-19T22:28:10+04:00')
+    expect(appeal.status).to eq('D')
+    expect(appeal.appeal).to include('Из текста вопроса следует')
+    expect(appeal.comment).to include('В воспоминаниях фигурирует')
+    expect(appeal.overriddenBy).to be_nil
+    expect(appeal.questionNumber).to eq(8)
+    expect(appeal.answer).to be_nil
+  end
+end

data/spec/lib/rating_chgk_v2/rest/tournament_synch_controversials_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::TournamentSynchControversials do
+  let(:id) { 1000 }
+
+  specify '#tournament_synch_controversial' do
+    contr = VCR.use_cassette('tournament_synch_controversial/tournament_synch_controversia') do
+      test_client.tournament_synch_controversial id
+    end
+
+    expect(contr.id).to eq(id)
+    expect(contr.questionNumber).to eq(26)
+    expect(contr.answer).to eq('валяться')
+    expect(contr.issuedAt).to eq('2012-01-31T09:26:32+04:00')
+    expect(contr.status).to eq('D')
+    expect(contr.comment).to eq('')
+    expect(contr.resolvedAt).to eq('2012-01-31T15:26:32+04:00')
+    expect(contr.appealJuryComment).to be_nil
+  end
+end

data/spec/lib/rating_chgk_v2/rest/tournament_synch_requests_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::TournamentSynchRequests do
+  let(:id) { 1000 }
+
+  specify '#tournament_synch_requests' do
+    req = VCR.use_cassette('tournament_synch_requests/tournament_synch_request') do
+      test_client.tournament_synch_request id
+    end
+
+    expect(req.id).to eq(id)
+    expect(req.status).to eq('A')
+    expect(req.venue['name']).to eq('Павлодар')
+    expect(req.representative['name']).to eq('Айбек')
+    expect(req.narrators.first['surname']).to eq('Логвиненко')
+    expect(req.approximateTeamsCount).to be_nil
+    expect(req.issuedAt).to eq('2012-09-21T10:30:14+04:00')
+    expect(req.tournamentId).to eq(2180)
+  end
+end

data/spec/lib/rating_chgk_v2/rest/tournament_types_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::TournamentTypes do
+  let(:id) { 3 }
+
+  specify '#tournament_types' do
+    t_type = VCR.use_cassette('tournament_types/tournament_types') do
+      test_client.tournament_types
+    end.first
+
+    expect(t_type.id).to eq(1)
+    expect(t_type.name).to eq('Неизвестный')
+  end
+
+  specify '#tournament_type' do
+    t_type = VCR.use_cassette('tournament_types/tournament_type') do
+      test_client.tournament_type id
+    end
+
+    expect(t_type.id).to eq(id)
+    expect(t_type.name).to eq('Синхрон')
+  end
+end

data/spec/lib/rating_chgk_v2/rest/tournaments_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::Tournaments do
+  let(:tournament_id) { 7798 }
+
+  # rubocop:disable RSpec/MultipleExpectations
+  specify '#tournament' do
+    tournament = VCR.use_cassette('tournaments/tournament') do
+      test_client.tournament(tournament_id)
+    end
+
+    expect(tournament.id).to eq(tournament_id)
+    expect(tournament.name).to eq('Игры доброй воли')
+    expect(tournament.lastEditDate).to eq('2022-03-30T09:34:21+03:00')
+    expect(tournament.dateStart).to eq('2022-03-13T13:00:00+03:00')
+    expect(tournament.dateEnd).to eq('2022-03-20T13:00:00+03:00')
+    expect(tournament.type['id']).to eq(3)
+    expect(tournament.orgcommittee.first['id']).to eq(14_450)
+    expect(tournament.synchData['dateRequestsAllowedTo']).to eq('2022-03-19T23:55:00+03:00')
+    expect(tournament.mainPayment).to eq(300)
+    expect(tournament.discountedPayment).to eq(100)
+    expect(tournament.discountedPaymentReason).to eq('школьные команды')
+    expect(tournament.currency).to eq('r')
+    expect(tournament.editors.first['id']).to eq(14_450)
+    expect(tournament.tournamentInRatingBalanced).to be(true)
+    expect(tournament.difficultyForecast).to eq(2.5)
+    expect(tournament.maiiAegis).to be(true)
+    expect(tournament.maiiAegisUpdatedAt).to eq('2022-02-12T08:35:02.372430Z')
+    expect(tournament.maiiRating).to be(true)
+    expect(tournament.maiiRatingUpdatedAt).to eq('2022-02-12T08:35:02.372192Z')
+    expect(tournament.questionQty['1']).to eq(9)
+  end
+  # rubocop:enable RSpec/MultipleExpectations
+
+  describe '#tournaments' do
+    it 'returns a collection of tournaments' do
+      tournaments = VCR.use_cassette('tournaments/all_tournaments') do
+        test_client.tournaments
+      end
+
+      expect(tournaments[0].name).to eq('Чемпионат Южного Кавказа')
+    end
+
+    it 'returns a collection of tournaments with params' do
+      tournaments = VCR.use_cassette('tournaments/all_tournaments_params') do
+        test_client.tournaments itemsPerPage: 2, page: 3
+      end
+
+      expect(tournaments.count).to eq(2)
+      expect(tournaments[0].name).to eq('Бостонское чаепитие')
+    end
+  end
+
+  specify '#tournament_appeals' do
+    appeals = VCR.use_cassette('tournaments/appeals') do
+      test_client.tournament_appeals tournament_id
+    end
+
+    expect(appeals[0].id).to eq(12_153)
+    expect(appeals[0].questionNumber).to eq(20)
+  end
+
+  specify '#tournament_requests' do
+    requests = VCR.use_cassette('tournaments/requests') do
+      test_client.tournament_requests tournament_id
+    end
+
+    expect(requests[0].id).to eq(101_060)
+    expect(requests[0].status).to eq('A')
+  end
+
+  specify '#tournament_results' do
+    results = VCR.use_cassette('tournaments/results') do
+      test_client.tournament_results tournament_id, includeTeamMembers: 1, includeMasksAndControversials: 1,
+                                                    includeTeamFlags: 1, includeRatingB: 1, town: 202
+    end.first
+
+    expect(results.team['id']).to eq(53_341)
+    expect(results.mask).to eq('011111111111011110001000000011111110111011111')
+    expect(results.current['name']).to eq('Парадные ватники')
+    expect(results.rating['b']).to eq(1216)
+    expect(results.controversials).to be_empty
+    expect(results.flags).to be_empty
+    expect(results.teamMembers.first['flag']).to eq('Б')
+    expect(results.questionsTotal).to eq(31)
+    expect(results.synchRequest['id']).to eq(103_475)
+    expect(results.position).to eq(1)
+  end
+end

data/spec/lib/rating_chgk_v2/rest/towns_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::Towns do
+  let(:town_id) { 1 }
+
+  specify '#town' do
+    town = VCR.use_cassette('towns/town') do
+      test_client.town(town_id)
+    end
+
+    expect(town.id).to eq(town_id)
+    expect(town.name).to eq('Абакан')
+    expect(town.region['name']).to eq('Хакасия')
+    expect(town.country['name']).to eq('Россия')
+  end
+
+  describe '#towns' do
+    it 'returns a collection of towns' do
+      towns = VCR.use_cassette('towns/all_towns') do
+        test_client.towns
+      end
+
+      expect(towns[0].name).to eq('Абакан')
+    end
+
+    it 'returns a collection of towns with params' do
+      towns = VCR.use_cassette('towns/all_towns_params') do
+        test_client.towns itemsPerPage: 2, page: 3
+      end
+
+      expect(towns.count).to eq(2)
+      expect(towns[0].name).to eq('Анапа')
+    end
+  end
+end

data/spec/lib/rating_chgk_v2/rest/venue_types_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::VenueTypes do
+  let(:type_id) { 1 }
+
+  specify '#venue_type' do
+    venue_type = VCR.use_cassette('venue_types/venue_type') do
+      test_client.venue_type(type_id)
+    end
+
+    expect(venue_type.id).to eq(type_id)
+    expect(venue_type.name).to eq('Постоянная')
+  end
+
+  describe '#venue_types' do
+    it 'returns a collection of venue types' do
+      types = VCR.use_cassette('venue_types/venue_types') do
+        test_client.venue_types
+      end
+
+      expect(types[0].name).to eq('Постоянная')
+    end
+
+    it 'returns a collection of venue types with params' do
+      types = VCR.use_cassette('venue_types/all_venue_types_params') do
+        test_client.venue_types itemsPerPage: 3, page: 2
+      end
+
+      expect(types[0].name).to eq('Разовая')
+    end
+  end
+
+  specify '#create_venue_type' do
+    stub_request(:post, 'https://api.rating.chgk.net/venue_types').
+      with(body: {name: 'Фейковая'}).
+      to_return(
+        status: 201,
+        body: '{"id":0,"name":"Фейковая"}',
+        headers: {}
+      )
+
+    venue_type = test_client.create_venue_type name: 'Фейковая'
+    expect(venue_type.name).to eq('Фейковая')
+    expect(venue_type.id).to eq(0)
+  end
+end

data/spec/lib/rating_chgk_v2/rest/venues_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2::Rest::Venues do
+  let(:venue_id) { 3601 }
+
+  specify '#venue' do
+    venue = VCR.use_cassette('venues/venue') do
+      test_client.venue(venue_id)
+    end
+
+    expect(venue.id).to eq(venue_id)
+    expect(venue.name).to eq('Библиотека')
+    expect(venue.town['name']).to eq('Витебск')
+    expect(venue.type['name']).to eq('Постоянная')
+    expect(venue.address).to eq('Витебск, пр. Фрунзе 30а')
+    expect(venue.urls.first).to include('vk.com')
+  end
+
+  describe '#venues' do
+    it 'returns a collection of venues' do
+      venues = VCR.use_cassette('venues/venues') do
+        test_client.venues
+      end
+
+      expect(venues[0].id).to eq(3030)
+    end
+
+    it 'returns a collection of venues with params' do
+      venues = VCR.use_cassette('venues/all_venues_params') do
+        test_client.venues itemsPerPage: 3, page: 2
+      end
+
+      expect(venues.count).to eq(3)
+      expect(venues[0].name).to eq('Ереван')
+    end
+  end
+
+  specify '#create_venue' do
+    stub_request(:post, 'https://api.rating.chgk.net/venues').
+      with(body: {name: 'Фейк', type: {name: 'Фейковый тип'}}).
+      to_return(
+        status: 201,
+        body: '{"id":0,"name":"Фейк","type":{"id":0,"name":"Фейковый тип"}}',
+        headers: {}
+      )
+
+    venue = test_client.create_venue name: 'Фейк', type: {name: 'Фейковый тип'}
+    expect(venue.name).to eq('Фейк')
+    expect(venue.type['id']).to eq(0)
+  end
+
+  specify '#update_venue' do
+    stub_request(:put, 'https://api.rating.chgk.net/venues/0').
+      with(body: {name: 'Обновлённая'}).
+      to_return(
+        status: 200,
+        body: '{"id":0,"name":"Обновлённая"}',
+        headers: {}
+      )
+
+    venue = test_client.update_venue 0, name: 'Обновлённая'
+    expect(venue.name).to eq('Обновлённая')
+    expect(venue.id).to eq(0)
+  end
+
+  specify '#delete_country' do
+    stub_request(:delete, 'https://api.rating.chgk.net/venues/1').to_return(status: 204, body: '', headers: {})
+
+    expect(test_client.delete_venue(1)).to eq('')
+  end
+end

data/spec/lib/rating_chgk_v2_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe RatingChgkV2 do
+  specify '.reset_client!' do
+    described_class.reset_client!
+    current_client = described_class.instance_variable_get :@client
+    expect(current_client).to be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'dotenv/load'
+require 'simplecov'
+require 'webmock/rspec'
+
+SimpleCov.start do
+  add_filter 'spec/'
+  add_filter '.github/'
+end
+
+if ENV['CI'] == 'true'
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
+require 'rating_chgk_v2'
+
+# Support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.include TestClient
+
+  WebMock.allow_net_connect!
+  WebMock::API.prepend(Module.new do
+    extend self
+    # disable VCR when a WebMock stub is created
+    # for clearer spec failure messaging
+    def stub_request(*args)
+      VCR.turn_off!
+      super
+    end
+  end)
+
+  config.before { VCR.turn_on! }
+end

data/spec/support/shared/paginated.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'paginated' do
+  let(:endpoint) { RatingChgkV2::Endpoints::BaseEndpoint.new test_client }
+  let(:collection) { described_class.new [], endpoint }
+
+  specify '#next_page!' do
+    allow(endpoint).to receive(:do_get).and_return([{paginated: true}])
+    expect(endpoint.params[:page]).to be_nil
+
+    expect(collection.next_page!).to be_an_instance_of(described_class)
+    expect(endpoint).to have_received(:do_get)
+
+    expect(collection.first.class.superclass).to eq(RatingChgkV2::Models::BaseModel)
+    expect(endpoint.params[:page]).to eq(2)
+  end
+
+  describe '#prev_page!' do
+    it 'fetches the previous page' do
+      allow(endpoint).to receive(:do_get).and_return([{paginated: true}])
+      allow(endpoint.params).to receive(:[]).with(:page).and_return(3)
+
+      expect(collection.prev_page!).to be_an_instance_of(described_class)
+      expect(endpoint).to have_received(:do_get)
+
+      expect(collection.first.class.superclass).to eq(RatingChgkV2::Models::BaseModel)
+      expect(endpoint.params[:page]).to eq(2)
+    end
+
+    it 'does not fetch anything when the page is the first one' do
+      allow(endpoint).to receive(:do_get).and_return([{paginated: true}])
+      expect(endpoint.params[:page]).to be_nil
+
+      expect(collection.prev_page!).to be_nil
+      expect(endpoint).not_to have_received(:do_get)
+
+      expect(collection.first).to be_nil
+      expect(endpoint.params[:page]).to be_nil
+    end
+  end
+end

data/spec/support/test_client.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TestClient
+  def test_client(token = nil, params = {})
+    RatingChgkV2.client(token: (token || ENV['API_TOKEN']), params: params)
+  end
+end

data/spec/support/vcr.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'vcr'
+
+VCR.configure do |c|
+  c.ignore_hosts 'codeclimate.com'
+  c.hook_into :faraday
+  c.default_cassette_options = {
+    decode_compressed_response: true
+  }
+  c.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes')
+  c.filter_sensitive_data('<API_TOKEN>') { ENV.fetch('API_TOKEN', 'hidden') }
+  c.filter_sensitive_data('<CHGK_EMAIL>') { ENV.fetch('CHGK_EMAIL', 'fake') }
+  c.filter_sensitive_data('<CHGK_PASSWORD>') { ENV.fetch('CHGK_PASSWORD', 'fake') }
+end