def test_vod_index_view(client, twitch_vod_game, user, mocker):
mocker.patch("hsreplaynet.api.views.vods.classify_deck", return_value=123)
mocker.patch.multiple(
"hsreplaynet.api.views.vods.VodIndexView",
authentication_classes=(),
permission_classes=(),
)
deck1 = create_deck_from_deckstring(TEST_TWITCH_DECKSTRING_1,
archetype_id=123)
deck2 = create_deck_from_deckstring(TEST_TWITCH_DECKSTRING_2,
archetype_id=123)
create_player("Test Player 1", 1, deck1, twitch_vod_game, rank=24)
create_player("Test Player 2", 2, deck2, twitch_vod_game, rank=25)
replay = create_replay(user, twitch_vod_game)
record_twitch_vod(replay, TEST_TWITCH_VOD_META)
response = client.get("/api/v1/vods/index/")
assert response.status_code == status.HTTP_200_OK, \
"Got invalid response: %r" % response.data
assert response.data == {123: [123]}
def test_record_twitch_vod(user, twitch_vod_game):
deck1 = create_deck_from_deckstring(TEST_TWITCH_DECK_STRING_1,
archetype_id=123)
deck2 = create_deck_from_deckstring(TEST_TWITCH_DECK_STRING_2)
create_player("Test Player 1", 1, deck1, twitch_vod_game, rank=25)
create_player("Test Player 2", 2, deck2, twitch_vod_game, rank=25)
replay = create_replay(user, twitch_vod_game)
record_twitch_vod(replay, TEST_REPLAY_META)
expected_vod = TwitchVod(friendly_player_archetype_id=123,
hsreplaynet_user_id=user.id,
rank=25,
replay_shortid=replay.shortid,
combined_rank="R25",
**TEST_TWITCH_VOD_PARAMS)
actual_vod = TwitchVod.get(TEST_REPLAY_META["twitch_vod"]["channel_name"],
"R25")
# Patch the TTL
expected_vod.ttl = actual_vod.ttl
assert expected_vod == actual_vod
def test_record_twitch_vod_missing_language(user, twitch_vod_game):
deck1 = create_deck_from_deckstring(TEST_TWITCH_DECK_STRING_1,
archetype_id=123)
deck2 = create_deck_from_deckstring(TEST_TWITCH_DECK_STRING_2)
create_player("Test Player 1", 1, deck1, twitch_vod_game, rank=25)
create_player("Test Player 2", 2, deck2, twitch_vod_game, rank=25)
replay = create_replay(user, twitch_vod_game)
def prune_language(d: dict):
return {k: v for k, v in d.items() if k != "language"}
replay_meta_no_language = {
"twitch_vod": prune_language(TEST_REPLAY_META["twitch_vod"])
}
expected_twitch_vod_params = prune_language(TEST_TWITCH_VOD_PARAMS)
record_twitch_vod(replay, replay_meta_no_language)
expected_vod = TwitchVod(friendly_player_archetype_id=123,
hsreplaynet_user_id=user.id,
rank=25,
replay_shortid=replay.shortid,
combined_rank="R25",
**expected_twitch_vod_params)
actual_vod = TwitchVod.get(TEST_REPLAY_META["twitch_vod"]["channel_name"],
"R25")
# Patch the TTL
expected_vod.ttl = actual_vod.ttl
assert expected_vod == actual_vod
def test_vod_list_view_at_legend_rank(client, twitch_vod_game, user,
mocker): # noqa: F811
mocker.patch.multiple(
"hsreplaynet.api.views.vods.VodListView",
authentication_classes=(),
permission_classes=(),
)
deck1 = create_deck_from_deckstring(TEST_TWITCH_DECKSTRING_1,
archetype_id=123)
deck2 = create_deck_from_deckstring(TEST_TWITCH_DECKSTRING_2)
create_player("Test Player 1",
1,
deck1,
twitch_vod_game,
rank=None,
legend_rank=1)
create_player("Test Player 2",
2,
deck2,
twitch_vod_game,
rank=None,
legend_rank=2)
replay = create_replay(user, twitch_vod_game)
record_twitch_vod(replay, TEST_TWITCH_VOD_META)
response = client.get("/api/v1/vods/?user_id=%s" % (user.id))
assert response.status_code == status.HTTP_200_OK, \
"Got invalid response: %r" % response.data
assert type(response.data) == list
channel_name = TEST_TWITCH_VOD_META["twitch_vod"]["channel_name"]
url = TEST_TWITCH_VOD_META["twitch_vod"]["url"]
assert response.data == [{
"channel_name": channel_name,
"language": "en",
"url": url,
"game_date": "2018-07-15T00:00:00Z",
"game_type": "BGT_RANKED_STANDARD",
"rank": 0,
"legend_rank": 1,
"friendly_player_archetype_id": 123,
"opposing_player_class": "PRIEST",
"opposing_player_archetype_id": None,
"won": False,
"went_first": True,
"game_length_seconds": 300,
"replay_shortid": replay.shortid,
}]
def test_classify_into_archetype(self, _):
deck = create_deck_from_deckstring(
"AAECAZICApnTAvH7Ag5AX+kB/gHTA8QGpAf2B+QIktICmNICntICv/ICj/YCAA==")
classification_failure_stubs = [{
"archetype_id": 123,
"reason": "bad_deck"
}, {
"archetype_id": 124,
"reason": "bad_deck"
}, {
"archetype_id": 124,
"reason": "too_many_firebats"
}]
def mock_classifier(_dbf_map,
_signature_weights,
failure_callback=None):
if failure_callback:
for stub in classification_failure_stubs:
failure_callback(stub)
with patch("hsreplaynet.decks.models.classify_deck", mock_classifier):
with patch("hsreplaynet.decks.models.influx_metric"
) as mock_influx_client:
deck.classify_into_archetype(CardClass.DRUID)
mock_influx_client.assert_has_calls([
call("archetype_classification_blocked", {"count": 2},
reason="bad_deck"),
call("archetype_classification_blocked", {"count": 1},
reason="too_many_firebats")
])
def test_record_twitch_vod_arena(user):
game = GlobalGame(game_type=BnetGameType.BGT_ARENA,
format=FormatType.FT_STANDARD,
match_start=datetime(2018, 7, 15, tzinfo=pytz.utc),
match_end=datetime(2018,
7,
15,
minute=5,
tzinfo=pytz.utc))
game.save()
deck = create_deck_from_deckstring(TEST_TWITCH_DECK_STRING_1)
create_player("Test Player 1", 1, deck, game, rank=0)
create_player("Test Player 2", 2, deck, game, rank=0)
replay = create_replay(user, game)
record_twitch_vod(replay, TEST_REPLAY_META)
expected_vod = TwitchVod(hsreplaynet_user_id=user.id,
rank=0,
replay_shortid=replay.shortid,
combined_rank="R0",
**dict(TEST_TWITCH_VOD_PARAMS,
game_type="BGT_ARENA"))
actual_vod = TwitchVod.get(TEST_REPLAY_META["twitch_vod"]["channel_name"],
"R0")
# Patch the TTL
expected_vod.ttl = actual_vod.ttl
assert expected_vod == actual_vod
def test_contains(self):
deck = create_deck_from_deckstring(
"AAECAZICAA9AzQHVAYECnALwA4sEiAXmBYUGtwbQB5oI2Qr5CgA=")
fireball = Card.objects.get(dbf_id=64)
assert fireball in deck
assert 64 in deck
assert "CS2_012" in deck
swipe = Card.objects.get(dbf_id=315)
assert swipe not in deck
assert 315 not in deck
assert "CS2_029" not in deck
def test_vod_list_view_multiple_identifiers(client, mocker, user):
mocker.patch.multiple(
"hsreplaynet.api.views.vods.VodListView",
authentication_classes=(),
permission_classes=(),
)
deck = create_deck_from_deckstring(TEST_TWITCH_DECKSTRING_1,
archetype_id=123)
response = client.get("/api/v1/vods/?user_id=%s&deck_id=%s" %
(user.id, deck.shortid))
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.data["non_field_errors"][0] == \
"Too many identifiers. Only user_id or deck_id or archetype_id must be specified."
def test_vod_list_view_by_deck_id_empty(client, mocker):
mocker.patch.multiple(
"hsreplaynet.api.views.vods.VodListView",
authentication_classes=(),
permission_classes=(),
)
deck = create_deck_from_deckstring(TEST_TWITCH_DECKSTRING_1)
response = client.get("/api/v1/vods/?deck_id=%s" % (deck.shortid))
assert response.status_code == status.HTTP_200_OK, \
"Got invalid response: %r" % response.data
assert type(response.data) == list
assert not len(response.data)
def test_record_twitch_vod_dynamodb_exception(user, twitch_vod_game):
deck = create_deck_from_deckstring(TEST_TWITCH_DECK_STRING_1)
create_player("Test Player 1", 1, deck, twitch_vod_game, rank=25)
create_player("Test Player 2", 2, deck, twitch_vod_game, rank=25)
replay = create_replay(user, twitch_vod_game)
def put_item_raise(*_args, **_kwargs):
raise PutError()
with patch.object(TableConnection, "put_item", put_item_raise):
record_twitch_vod(replay, TEST_REPLAY_META)
with raises(DoesNotExist):
TwitchVod.get(TEST_REPLAY_META["twitch_vod"]["channel_name"], "R25")
def test_record_twitch_vod_missing_rank(user, twitch_vod_game):
deck = create_deck_from_deckstring(TEST_TWITCH_DECK_STRING_1)
create_player("Test Player 1", 1, deck, twitch_vod_game, rank=None)
create_player("Test Player 2", 2, deck, twitch_vod_game, rank=None)
replay = create_replay(user, twitch_vod_game)
record_twitch_vod(replay, TEST_REPLAY_META)
expected_vod = TwitchVod(hsreplaynet_user_id=user.id,
rank=0,
replay_shortid=replay.shortid,
combined_rank="R0",
**TEST_TWITCH_VOD_PARAMS)
actual_vod = TwitchVod.get(TEST_REPLAY_META["twitch_vod"]["channel_name"],
"R0")
# Patch the TTL
expected_vod.ttl = actual_vod.ttl
assert expected_vod == actual_vod
def test_issuperset(self):
claw_swipe = create_deck_from_deckstring("AAECAZICAkCaCAAA")
claw = create_deck_from_deckstring("AAECAZICAZoIAAA=")
assert claw_swipe.issuperset(claw)
assert claw.issuperset(claw)
assert not claw.issuperset(claw_swipe)
def test_len(self):
deck = create_deck_from_deckstring(
"AAECAZICAA9AzQHVAYECnALwA4sEiAXmBYUGtwbQB5oI2Qr5CgA=")
assert len(deck) == 30
assert deck.is_full_deck
def test_card_lists(self):
deck = create_deck_from_deckstring(
"AAECAZICAA9AzQHVAYECnALwA4sEiAXmBYUGtwbQB5oI2Qr5CgA=")
assert deck.card_id_list() == [
"CS2_005",
"CS2_005",
"CS2_171",
"CS2_171",
"CS2_009",
"CS2_009",
"EX1_506",
"EX1_506",
"EX1_015",
"EX1_015",
"CS2_120",
"CS2_120",
"CS2_007",
"CS2_007",
"CS2_122",
"CS2_122",
"CS2_196",
"CS2_196",
"CS2_011",
"CS2_011",
"EX1_025",
"EX1_025",
"CS2_012",
"CS2_012",
"CS2_226",
"CS2_226",
"EX1_173",
"EX1_173",
"CS2_232",
"CS2_232",
]
assert deck.card_dbf_id_list() == [
1050,
1050,
648,
648,
213,
213,
976,
976,
284,
284,
1369,
1369,
773,
773,
1401,
1401,
257,
257,
742,
742,
523,
523,
64,
64,
496,
496,
823,
823,
205,
205,
]
def test_command(user):
global_game = GlobalGame.objects.create(
id=1,
format=FormatType.FT_STANDARD,
game_type=BnetGameType.BGT_RANKED_STANDARD,
match_start=datetime.now(),
match_end=datetime.now(),
num_turns=5,
)
friendly_deckstring = (
"AAECAZICApnTAvX8Ag5AX/0C5gXkCJvLAqDNAofOAo7QApjSAp7SAtvTAtfvAuL4AgA=")
friendly_player_deck = create_deck_from_deckstring(friendly_deckstring)
friendly_player = create_player(name="FriendlyPlayer#1234",
id=1,
deck=friendly_player_deck,
game=global_game,
rank=3)
opposing_deckstring = (
"AAECAR8I+AjtCdPFAobTApziArbqAsvsAoDzAguNAZcIq8IC2MICnM0C3dICi+EC4eMC8vECufgC4vgCAA=="
)
opposing_player_deck = create_deck_from_deckstring(opposing_deckstring)
opponent = create_player(name="OpposingPlayer#1234",
id=2,
deck=opposing_player_deck,
game=global_game,
rank=3)
game = create_replay(user=user, game=global_game, friendly_player_id=1)
game.replay_xml = SimpleUploadedFile("/replays/replay.xml", b"<replay/>")
game.save()
Command().handle(username=[user.username], continue_on_error=False)
dynamo_replays = list(DynamoDBGameReplay.query(user.id))
assert len(dynamo_replays) == 1
dynamo_replay = dynamo_replays[0]
assert dynamo_replay.user_id == int(game.user.id)
match_start = int(global_game.match_start.timestamp() * 1000)
match_end = int(global_game.match_end.timestamp() * 1000)
assert dynamo_replay.match_start == match_start
assert dynamo_replay.match_end == match_end
assert dynamo_replay.short_id == game.shortid
assert dynamo_replay.digest == global_game.digest
assert dynamo_replay.game_type == global_game.game_type
assert dynamo_replay.format_type == FormatType.FT_STANDARD
assert dynamo_replay.game_type_match_start == "{}:{}".format(
int(global_game.game_type), match_start)
assert dynamo_replay.ladder_season == global_game.ladder_season
assert dynamo_replay.brawl_season == global_game.brawl_season
assert dynamo_replay.scenario_id == global_game.scenario_id
assert dynamo_replay.num_turns == global_game.num_turns
assert dynamo_replay.friendly_player_account_hilo == "{}_{}".format(
friendly_player.pegasus_account.account_hi,
friendly_player.pegasus_account.account_lo,
)
assert dynamo_replay.friendly_player_battletag == friendly_player.name
assert dynamo_replay.friendly_player_is_first == friendly_player.is_first
assert dynamo_replay.friendly_player_rank == friendly_player.rank
assert dynamo_replay.friendly_player_legend_rank == friendly_player.legend_rank
assert dynamo_replay.friendly_player_rank_stars == friendly_player.stars
assert dynamo_replay.friendly_player_wins == friendly_player.wins
assert dynamo_replay.friendly_player_losses == friendly_player.losses
assert dynamo_replay.friendly_player_class == friendly_player.hero.card_class
assert dynamo_replay.friendly_player_hero == friendly_player.hero.dbf_id
assert len(dynamo_replay.friendly_player_deck)
assert dynamo_replay.friendly_player_blizzard_deck_id == friendly_player.deck_id
assert dynamo_replay.friendly_player_cardback_id == friendly_player.cardback_id
assert dynamo_replay.friendly_player_final_state == friendly_player.final_state
assert dynamo_replay.opponent_account_hilo == "{}_{}".format(
opponent.pegasus_account.account_hi,
opponent.pegasus_account.account_lo,
)
assert dynamo_replay.opponent_battletag == opponent.name
assert dynamo_replay.opponent_is_ai == opponent.is_ai
assert dynamo_replay.opponent_rank == opponent.rank
assert dynamo_replay.opponent_legend_rank == opponent.legend_rank
assert dynamo_replay.opponent_class == opponent.hero.card_class
assert dynamo_replay.opponent_hero == opponent.hero.dbf_id
assert len(dynamo_replay.opponent_revealed_deck)
assert len(dynamo_replay.opponent_predicted_deck)
assert dynamo_replay.opponent_cardback_id == opponent.cardback_id
assert dynamo_replay.opponent_final_state == opponent.final_state
assert dynamo_replay.replay_xml == game.replay_xml.name
assert dynamo_replay.disconnected == game.disconnected
assert dynamo_replay.reconnecting == game.reconnecting
assert dynamo_replay.hslog_version == game.hslog_version or "0.0"
assert dynamo_replay.visibility == game.visibility
assert dynamo_replay.views == int(game.views)
