def test_save_saves_result(storage):
fake = faker.Faker()
competitor1 = helpers.create_competitor(storage)
competitor2 = helpers.create_competitor(storage)
match = helpers.create_match(
storage,
competitors=[competitor1, competitor2],
)
result1 = {
fake.word(): fake.random_int(),
fake.word(): fake.random_int(),
}
result2 = {
fake.word(): fake.random_int(),
fake.word(): fake.random_int(),
}
match.set_result(competitor1, result1)
match.set_result(competitor2, result2)
storage.match.save(match)
loaded = storage.match.load(match.id)
assert loaded.result[0].competitor == competitor1
assert loaded.result[0].result == result1
assert loaded.result[1].competitor == competitor2
assert loaded.result[1].result == result2
def test_create(storage, phase):
fake = faker.Faker()
round = fake.random_int(1, 10)
position = fake.random_int(0, 3)
pool = fake.random_int(0, 4)
competitors = [
helpers.create_competitor(storage),
helpers.create_competitor(storage),
]
match = storage.match.create(
phase_id=phase.id,
round=round,
position=position,
pool=pool,
competitors=competitors,
)
assert match.id is not None
assert match.phase_id == phase.id
assert match.round == round
assert match.position == position
assert match.pool == pool
assert match.competitors == competitors
def test_save(storage):
fake = faker.Faker()
match = helpers.create_match(
storage,
competitors=[helpers.create_competitor(storage)],
)
new_round = fake.random_int(1, 10)
new_position = fake.random_int(0, 3)
new_pool = fake.random_int(0, 4)
new_competitors = [
helpers.create_competitor(storage),
helpers.create_competitor(storage),
]
match.round = new_round
match.position = new_position
match.pool = new_pool
match.competitors = new_competitors
saved = storage.match.save(match)
assert saved.round == new_round
assert saved.position == new_position
assert saved.pool == new_pool
assert saved.competitors == new_competitors
loaded = storage.match.load(match.id)
assert loaded.round == new_round
assert loaded.position == new_position
assert loaded.pool == new_pool
assert loaded.competitors == new_competitors
def test_find_all(storage):
competitors = [helpers.create_competitor(storage) for _ in range(0, 10)]
loaded = list(storage.competitor.find_all())
assert len(loaded) == len(competitors)
assert loaded == competitors
def test_create_with_competitors(storage, tournament):
fake = faker.Faker()
name = fake.word()
scheme = fake.word()
gender = fake.random_element(('m', 'f'))
minimum_age = fake.random_int(min=1, max=10)
maximum_age = fake.random_int(min=11, max=20)
minimum_weight = fake.pydecimal(left_digits=2,
right_digits=2,
positive=True)
maximum_weight = minimum_weight + 10
competitors = [helpers.create_competitor(storage) for _ in range(0, 5)]
competition = storage.competition.create(
tournament=tournament,
name=name,
scheme=scheme,
gender=gender,
minimum_age=minimum_age,
maximum_age=maximum_age,
minimum_weight=minimum_weight,
maximum_weight=maximum_weight,
competitors=competitors,
)
loaded = storage.competition.load(competition.id)
assert len(loaded.competitors) == len(competitors)
def test_load(storage):
match = helpers.create_match(
storage,
competitors=[
helpers.create_competitor(storage),
helpers.create_competitor(storage),
helpers.create_competitor(storage),
],
)
loaded = storage.match.load(match.id)
assert loaded.round == match.round
assert loaded.position == match.position
assert loaded.pool == match.pool
assert loaded.competitors == match.competitors
def test_save_merges_result(storage, phase):
fake = faker.Faker()
competitors = [create_competitor(storage) for _ in range(0, 4)]
for lot, competitor in enumerate(competitors):
phase.competitors.append(competitor, pool=1, lot=lot)
phase.result = [
phase_entities.Result(competitor, dict()) for competitor in competitors
]
phase = storage.phase.save(phase)
random.shuffle(competitors)
results = [
phase_entities.Result(
competitor=competitor,
result={fake.word(): fake.random_int()},
) for competitor in competitors[:-2]
]
phase.results = results
storage.phase.save(phase)
loaded = storage.phase.load(phase.id)
assert loaded.results == results
def test_save_competitors(storage, tournament, competition):
competitor = helpers.create_competitor(storage)
competition.competitors.append(competitor)
competition = storage.competition.save(competition)
assert competition.competitors == [competitor]
competition.competitors.remove(competitor)
competition = storage.competition.save(competition)
assert competition.competitors == []
def test_save_saves_competitors(storage):
competitors = [helpers.create_competitor(storage)]
tournament = helpers.create_tournament(storage, competitors)
competitor = helpers.create_competitor(storage)
tournament.competitors.append(competitor)
storage.tournament.save(tournament)
persisted = storage.tournament.load(tournament.id)
assert len(persisted.competitors) == 2
assert persisted.competitors == tournament.competitors
tournament.competitors.remove(tournament.competitors[0])
storage.tournament.save(tournament)
persisted = storage.tournament.load(tournament.id)
assert len(persisted.competitors) == 1
assert persisted.competitors == tournament.competitors
def test_create(storage):
fake = faker.Faker()
name = fake.word()
start_date = fake.date_object()
end_date = start_date + datetime.timedelta(days=2)
competitors = [
helpers.create_competitor(storage),
helpers.create_competitor(storage),
]
tournament = storage.tournament.create(
name=name,
start_date=start_date,
end_date=end_date,
competitors=competitors,
)
assert tournament.name == name
assert tournament.start_date == start_date
assert tournament.end_date == end_date
assert tournament.competitors == competitors
assert tournament.id is not None
def test_save_saves_competitors(storage):
phase = create_phase(storage)
competitors = [create_competitor(storage) for _ in range(0, 2)]
for lot, competitor in enumerate(competitors):
phase.competitors.append(competitor, pool=1, lot=lot)
phase = storage.phase.save(phase)
for lot, (actual, expected) in enumerate(
itertools.zip_longest(
phase.competitors,
competitors,
)):
assert isinstance(actual, phase_entities.Competitor)
assert actual.id == expected.id
assert actual.first_name == expected.first_name
assert actual.last_name == expected.last_name
loaded = storage.phase.load(phase.id)
assert loaded.competitors == phase.competitors
competitors.pop(0)
phase.competitors.pop(0)
phase = storage.phase.save(phase)
for actual, expected in itertools.zip_longest(
phase.competitors,
competitors,
):
assert isinstance(actual, phase_entities.Competitor)
assert actual.id == expected.id
assert actual.first_name == expected.first_name
assert actual.last_name == expected.last_name
loaded = storage.phase.load(phase.id)
assert loaded.competitors == phase.competitors
def competitor(storage):
return helpers.create_competitor(storage)
