rating-chgk-v2 1.0.0 → 1.0.1

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

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RatingChgkV2::Rest::Countries do
-  describe '#countries' do
-    it 'returns a collection of countries' do
-      countries = VCR.use_cassette('countries/all_countries') do
-        test_client.countries
-      end
-
-      expect(countries[1].name).to eq('Австралия')
-      expect(countries[1].id).to eq(2)
-    end
-
-    it 'returns a collection of countries with params' do
-      countries = VCR.use_cassette('countries/all_countries_params') do
-        test_client.countries itemsPerPage: 2, name: 'Бе'
-      end
-
-      expect(countries.items.size).to eq(2)
-      expect(countries.first.name).to eq('Беларусь')
-      expect(countries.first.id).to eq(5)
-    end
-  end
-
-  describe '#create_country' do
-    before { RatingChgkV2.reset_client! }
-
-    after { RatingChgkV2.reset_client! }
-
-    it 'raises an error when the token is invalid' do
-      custom_client = RatingChgkV2.client token: 'fake_token'
-
-      expect do
-        VCR.use_cassette('countries/create_country_incorrect_token') do
-          custom_client.create_country name: 'test'
-        end
-      end.to raise_error(RatingChgkV2::Error::Unauthorized)
-    end
-
-    it 'creates a country' do
-      stub_request(:post, 'https://api.rating.chgk.net/countries').
-        with(body: {name: 'Темерия'}).
-        to_return(
-          status: 200,
-          body: '{"id":0,"name":"Темерия"}',
-          headers: {}
-        )
-
-      country = test_client.create_country name: 'Темерия'
-      expect(country.name).to eq('Темерия')
-      expect(country.id).to eq(0)
-    end
-  end
-
-  specify '#update_country' do
-    stub_request(:put, 'https://api.rating.chgk.net/countries/0').
-      with(body: {name: 'Лирия'}).
-      to_return(
-        status: 200,
-        body: '{"id":0,"name":"Лирия"}',
-        headers: {}
-      )
-
-    country = test_client.update_country 0, name: 'Лирия'
-    expect(country.name).to eq('Лирия')
-    expect(country.id).to eq(0)
-  end
-
-  describe '#delete_country' do
-    it 'raises an error when the token is invalid' do
-      expect do
-        VCR.use_cassette('countries/delete_country_incorrect_token') do
-          test_client.delete_country 1
-        end
-      end.to raise_error(RatingChgkV2::Error::Unauthorized)
-    end
-
-    it 'deletes a country' do
-      stub_request(:delete, 'https://api.rating.chgk.net/countries/1').to_return(status: 204, body: '', headers: {})
-
-      expect(test_client.delete_country(1)).to eq('')
-    end
-  end
-
-  specify '#country' do
-    id = 20
-    country = VCR.use_cassette('countries/country') do
-      test_client.country id
-    end
-
-    expect(country.name).to eq('Нидерланды')
-    expect(country.id).to eq(id)
-  end
-end

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

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RatingChgkV2::Rest::Players do
-  let(:player_id) { 1110 }
-
-  specify '#player' do
-    player = VCR.use_cassette('players/player') do
-      test_client.player(player_id)
-    end
-
-    expect(player.id).to eq(player_id)
-    expect(player.name).to eq('Александр')
-    expect(player.surname).to eq('Андрианов')
-    expect(player.patronymic).to eq('Сергеевич')
-  end
-
-  describe '#player_tournaments' do
-    it 'returns a collection of player tournaments' do
-      player_tournaments = VCR.use_cassette('players/player_tournaments') do
-        test_client.player_tournaments player_id
-      end
-
-      expect(player_tournaments).to be_an_instance_of(RatingChgkV2::Collections::PlayerTournamentsCollection)
-      tour = player_tournaments.first
-
-      expect(tour.idplayer).to eq(player_id)
-      expect(tour.idtournament).to eq(314)
-      expect(tour.idteam).to eq(7121)
-    end
-
-    it 'returns a collection of player tournaments next page' do
-      player_tournaments = VCR.use_cassette('players/player_tournaments_params') do
-        test_client.player_tournaments player_id, itemsPerPage: 2
-      end
-
-      tour = player_tournaments[1]
-
-      expect(tour.idplayer).to eq(player_id)
-      expect(tour.idtournament).to eq(400)
-      expect(tour.idteam).to eq(7456)
-
-      VCR.use_cassette('players/player_tournaments_next_page') do
-        player_tournaments.next_page!
-      end
-
-      tour = player_tournaments[0]
-
-      expect(tour.idplayer).to eq(player_id)
-      expect(tour.idtournament).to eq(314)
-      expect(tour.idteam).to eq(7121)
-      expect(player_tournaments.endpoint.params[:itemsPerPage]).to eq(2)
-    end
-  end
-
-  describe '#player_seasons' do
-    it 'returns a collection of player seasons' do
-      player_seasons = VCR.use_cassette('players/player_seasons') do
-        test_client.player_seasons player_id
-      end
-
-      expect(player_seasons).to be_an_instance_of(RatingChgkV2::Collections::PlayerSeasonsCollection)
-      season = player_seasons.first
-
-      expect(season.idplayer).to eq(player_id)
-      expect(season.idseason).to eq(7)
-      expect(season.idteam).to eq(7121)
-      expect(season.dateAdded).to eq('2007-09-23T00:00:00+04:00')
-      expect(season.dateRemoved).to be_nil
-      expect(season.playerNumber).to eq(0)
-    end
-
-    it 'returns seasons by params' do
-      player_seasons = VCR.use_cassette('players/player_seasons_params') do
-        test_client.player_seasons player_id, itemsPerPage: 2, idseason: 8, idteam: 7456
-      end
-
-      expect(player_seasons).to be_an_instance_of(RatingChgkV2::Collections::PlayerSeasonsCollection)
-      season = player_seasons.first
-
-      expect(season.idplayer).to eq(player_id)
-      expect(season.idseason).to eq(8)
-      expect(season.idteam).to eq(7456)
-    end
-  end
-
-  describe '#players' do
-    it 'returns a collection of players' do
-      players = VCR.use_cassette('players/all_players') do
-        test_client.players
-      end
-
-      expect(players[0].surname).to eq('Абабилов')
-      expect(players[0].id).to eq(1)
-    end
-
-    it 'returns next page' do
-      players = VCR.use_cassette('players/all_players_params') do
-        test_client.players itemsPerPage: 3, page: 2
-      end
-
-      expect(players[0].name).to eq('Артур')
-      expect(players[0].id).to eq(12)
-
-      VCR.use_cassette('players/all_players_next_page') do
-        players.next_page!
-      end
-
-      expect(players[0].name).to eq('Олег')
-      expect(players[0].id).to eq(15)
-      expect(players.endpoint.params[:itemsPerPage]).to eq(3)
-    end
-
-    it 'returns previous page' do
-      players = VCR.use_cassette('players/all_players_params') do
-        test_client.players itemsPerPage: 3, page: 2
-      end
-
-      VCR.use_cassette('players/all_players_prev_page') do
-        players.prev_page!
-      end
-
-      expect(players[0].surname).to eq('Абабилов')
-      expect(players.endpoint.params[:itemsPerPage]).to eq(3)
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RatingChgkV2::Rest::Regions do
-  describe '#regions' do
-    it 'returns a collection of regions' do
-      regions = VCR.use_cassette('regions/all_regions') do
-        test_client.regions
-      end
-
-      expect(regions.last.name).to eq('Воронежская область')
-      expect(regions.last.id).to eq(30)
-      expect(regions.last.country['name']).to eq('Россия')
-    end
-
-    it 'returns a collection of regions with params' do
-      regions = VCR.use_cassette('regions/all_regions_params') do
-        test_client.regions itemsPerPage: 3, country: 'Россия'
-      end
-
-      expect(regions.items.size).to eq(3)
-      expect(regions[1].name).to eq('Адыгея')
-      expect(regions[1].country['name']).to eq('Россия')
-      expect(regions[1].id).to eq(2)
-    end
-  end
-
-  specify '#region' do
-    id = 3
-    region = VCR.use_cassette('regions/region') do
-      test_client.region id
-    end
-
-    expect(region.name).to eq('Акмолинская область')
-    expect(region.country['name']).to eq('Казахстан')
-    expect(region.id).to eq(id)
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RatingChgkV2::Rest::Releases do
-  describe '#releases' do
-    it 'returns a collection of releases' do
-      releases = VCR.use_cassette('releases/all_releases') do
-        test_client.releases
-      end
-
-      expect(releases.first.date).to eq('2003-07-01T00:00:00+04:00')
-    end
-
-    it 'returns a collection of releases with params' do
-      releases = VCR.use_cassette('releases/all_releases_params') do
-        test_client.releases itemsPerPage: 3, page: 2
-      end
-
-      expect(releases.items.size).to eq(3)
-      expect(releases.first.realDate).to eq('2005-04-01T00:00:00+04:00')
-    end
-  end
-
-  specify '#release' do
-    id = 4
-    release = VCR.use_cassette('releases/release') do
-      test_client.release id
-    end
-
-    expect(release.lastRunRefresh).to eq('2015-02-09T15:51:22+03:00')
-    expect(release.realDate).to eq('2005-04-01T00:00:00+04:00')
-    expect(release.date).to eq('2005-04-01T00:00:00+04:00')
-    expect(release.id).to eq(id)
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RatingChgkV2::Rest::Seasons do
-  describe '#seasons' do
-    it 'returns a collection of seasons' do
-      seasons = VCR.use_cassette('seasons/all_seasons') do
-        test_client.seasons
-      end
-
-      expect(seasons.first.dateStart).to eq('2002-09-01T00:00:00+04:00')
-    end
-  end
-
-  specify '#season' do
-    id = 5
-    season = VCR.use_cassette('seasons/season') do
-      test_client.season id
-    end
-
-    expect(season.id).to eq(id)
-    expect(season.dateStart).to eq('1999-09-01T00:00:00+04:00')
-    expect(season.dateEnd).to eq('2000-08-31T00:00:00+04:00')
-  end
-
-  specify '#create_season' do
-    data = {
-      dateStart: '2022-02-05T19:37:45.004Z',
-      dateEnd: '2022-02-05T19:37:45.004Z'
-    }
-    stub_request(:post, 'https://api.rating.chgk.net/seasons').
-      with(body: data).
-      to_return(
-        status: 200,
-        body: JSON.dump(data.merge({id: 0})),
-        headers: {}
-      )
-
-    season = test_client.create_season data
-
-    expect(season.id).to eq(0)
-    expect(season.dateStart).to eq(data[:dateStart])
-    expect(season.dateEnd).to eq(data[:dateEnd])
-  end
-
-  specify '#update_season' do
-    data = {
-      dateStart: '2021-02-05T19:37:45.004Z',
-      dateEnd: '2021-02-05T19:37:45.004Z'
-    }
-
-    stub_request(:put, 'https://api.rating.chgk.net/seasons/0').
-      with(body: data).
-      to_return(
-        status: 200,
-        body: JSON.dump(data.merge({id: 0})),
-        headers: {}
-      )
-
-    season = test_client.update_season 0, data
-
-    expect(season.id).to eq(0)
-    expect(season.dateStart).to eq(data[:dateStart])
-    expect(season.dateEnd).to eq(data[:dateEnd])
-  end
-
-  specify '#delete_season' do
-    stub_request(:delete, 'https://api.rating.chgk.net/seasons/0').to_return(status: 204, body: '', headers: {})
-
-    expect(test_client.delete_season(0)).to eq('')
-  end
-end

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

@@ -1,66 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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

@@ -1,89 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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