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_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_ai(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=-1,
is_ai=True)
replay = create_replay(user, twitch_vod_game)
record_twitch_vod(replay, TEST_REPLAY_META)
expected_vod = TwitchVod(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_record_twitch_vod_legend_rank(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, archetype_id=456)
create_player("Test Player 1", 1, deck1, twitch_vod_game, rank=0, legend_rank=50)
create_player("Test Player 2", 2, deck2, twitch_vod_game, rank=0, legend_rank=49)
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,
legend_rank=50,
opposing_player_archetype_id=456,
rank=0,
replay_shortid=replay.shortid,
combined_rank="L50",
**TEST_TWITCH_VOD_PARAMS
)
actual_vod = TwitchVod.get(TEST_REPLAY_META["twitch_vod"]["channel_name"], "L50")
# 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_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_update_replay_feed_deleted_user(mocker, user):
game = GlobalGame(format=FormatType.FT_STANDARD,
game_type=BnetGameType.BGT_RANKED_STANDARD,
match_end=timezone.now())
game.save()
archetype = Archetype(name="Test Archetype",
player_class=CardClass.WARRIOR)
archetype.save()
deck = Deck(archetype=archetype)
deck.save()
create_player("Test 1", 1, deck, game)
create_player("Test 2", 2, deck, game)
replay = GameReplay(global_game=game, user=user)
replay.save()
user.delete()
mock_replay_feed = Mock()
mocker.patch("hsreplaynet.games.processing.get_replay_feed",
new=lambda comparator: mock_replay_feed)
update_replay_feed(replay)
mock_replay_feed.push.assert_called_once_with({
"id":
ANY,
"player1_archetype":
archetype.id,
"player1_legend_rank":
None,
"player1_rank":
25,
"player1_won":
False,
"player2_archetype":
archetype.id,
"player2_legend_rank":
None,
"player2_rank":
25,
"player2_won":
False
})
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)
