def test_send_push__with_several_different_entries__status201(self):
# arrange
game_invalid_api_key = create_game(api_key="invalid api key")
game_valid_api_key = create_game()
# fail
create_device_user(game=game_invalid_api_key)
# fail
create_device_user(gcm_id="invalid_gcm", game=game_invalid_api_key)
# error
create_device_user(gcm_id="valid_key_invalid_gcm",
game=game_valid_api_key)
# error
create_device_user(gcm_id="valid_key_invalid_gcm_two",
game=game_valid_api_key)
# success
create_device_user(game=game_valid_api_key)
data = {
"data":
"{'message': 'default_message'}",
"query":
"{'games': '" + str(game_invalid_api_key.id) + ',' +
str(game_valid_api_key.id) + "'}"
}
# act
response = self.client.post(self.url,
data=data,
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test__filter_device_user_by_country_code(self):
# Arrange
create_device_user(country_code="YT")
device_user_queryset = DeviceUser.manager.all()
# Act
response_query_set = DeviceUserFilter().filter_location_country_codes(
device_user_queryset, "YT")
# Assert
self.assertEqual(response_query_set.count(), 1)
def test__filter_device_user_by_gpg_id(self):
# Arrange
create_device_user(gpg_id="gpg1Dasus")
device_user_queryset = DeviceUser.manager.all()
# Act
response_query_set = DeviceUserFilter().filter_all(
device_user_queryset, "gpg1Dasus")
# Assert
self.assertEqual(response_query_set.count(), 1)
def test__filter_device_user_by_email(self):
# Arrange
create_device_user(email="*****@*****.**")
device_user_queryset = DeviceUser.manager.all()
# Act
response_query_set = DeviceUserFilter().filter_all(
device_user_queryset, "asus_gmm")
# Assert
self.assertEqual(response_query_set.count(), 1)
def test__filter_device_user_by_game_id(self):
# Arrange
game = create_game()
create_device_user(game=game)
device_user_queryset = DeviceUser.manager.all()
# Act
response_query_set = DeviceUserFilter().filter_games(
device_user_queryset, "1")
# Assert
self.assertEqual(response_query_set.count(), 1)
def test__filter_participant_by_country_codes(self):
# Arrange
create_participation(self.campaign, country_code="US", player=self.player)
create_participation(self.campaign, country_code="BR", player=create_device_user())
create_participation(self.campaign, country_code="CA", player=create_device_user())
participant_queryset = Participation.manager.all()
# Act
response_queryset = ParticipationFilter().filter_location_country_codes(participant_queryset, "BR,US")
# Assert
self.assertEqual(participant_queryset.count(), 3)
self.assertEqual(response_queryset.count(), 2)
def test_send_push__without_token__status401(self):
# arrange
game = create_game()
create_device_user(gcm_id='invalid gcm', game=game)
data = {
"data": "message",
"query": "{'games': '" + str(game.id) + "'}"
}
# act
response = self.client.post(self.url, data)
# assert
self.assertEquals(response.status_code, status.HTTP_401_UNAUTHORIZED)
def test_send_push__with_invalid_data__status400(self):
# arrange
game = create_game()
create_device_user(gcm_id='invalid', game=game)
data = {
"data": 'message',
"query": "{'games': '" + str(game.id) + "'}"
}
# act
response = self.client.post(self.url,
data,
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
def setUp(self):
self.game = create_game("Zennynho",
package_name="br.com.asus.test.zenny",
game_service_id="SERVICE_Id_XPTO",
api_key="key")
self.user = create_user("*****@*****.**", "gpg_id", "gcm_id")
self.environment_info_data = JsonObjects.environment_info_1()
create_device_user(game=self.game,
gcm_id="testing_gcm_id",
email="*****@*****.**")
self.game2 = create_game("Zenny2",
package_name="br.com.asus.test.zenny2",
game_service_id="SERVICE_ID_2",
api_key="key2")
def test_send_push__with_invalid_gcm_id_and_api_key__status201(self):
# arrange
game_with_invalid_api_key = create_game(api_key="invalid api key")
create_device_user(gcm_id='invalid', game=game_with_invalid_api_key)
data = {
"data": "{'message': 'default_message'}",
"query": "{'games': '" + str(game_with_invalid_api_key.id) + "'}"
}
# act
response = self.client.post(self.url,
data,
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test_send_push__with_invalid_query__status201(self, mock_push):
# arrange
game = create_game()
create_device_user(game=game)
create_device_user(game=game, gcm_id='invalid gcm')
data = {
"data": "{'message': 'default_message'}",
"query": "{'games': '" + str(10) + "'}"
}
# act
response = self.client.post(self.url,
data=data,
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test__push_details__participation__status200(self, mock_details):
# arrange
game = create_game(api_key=self.api_key_2)
campaign = create_campaign()
create_participation(campaign,
country_code="US",
player=create_device_user(game=game))
data = {
"data":
"{'message': 'default_message'}",
"query":
"{'games': '" + str(game.id) + "', 'campaigns': '" +
str(campaign.id) + "'}"
}
response = self.client.post(self.url,
data,
HTTP_AUTHORIZATION=self.token)
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
# act
response_details = self.client.get(
'/gmm/push/' + str(response.data[Field.ID]) + "/" + 'details',
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response_details.status_code, status.HTTP_200_OK)
def test__filter_player_by_last_date_played_using_end_date__two_players_dates_after_end_date__0(
self):
# Arrange
game = create_game()
campaign = create_campaign()
last_time_played_after_end_date_1 = datetime(2016,
10,
25,
14,
46,
58,
28310,
tzinfo=utc)
last_time_played_after_end_date_2 = datetime(2016,
11,
25,
14,
46,
58,
28310,
tzinfo=utc)
end_date_period_consult = datetime(2016,
5,
25,
14,
46,
58,
28310,
tzinfo=utc)
player_1 = create_device_user(
game=game, last_date_played=last_time_played_after_end_date_1)
player_2 = create_device_user(
game=game, last_date_played=last_time_played_after_end_date_2)
create_participation(campaign=campaign, player=player_1)
create_participation(campaign=campaign, player=player_2)
device_user_queryset = Participation.manager.all()
# Act
response_query_set = ParticipationFilter().filter_end_date(
device_user_queryset, str(end_date_period_consult))
# Assert
self.assertEqual(response_query_set.count(), 0)
def test_send_push__more_than_1000_regs_ids_per_api_key__status201(self):
game = create_game()
for i in range(100):
create_device_user(game=game, gcm_id=i)
for i in range(100):
create_device_user(game=game, gcm_id="")
data = {
"data": "{'message': 'default_message'}",
"query": "{'games': '" + str(game.id) + "'}"
}
# act
response = self.client.post(self.url,
data,
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test__filter_participant_by_campaign_ids(self):
# Arrange
other_campaign = create_campaign(name="OtherCampaign")
create_participation(other_campaign, player=self.player)
create_participation(self.campaign, country_code="BR", player=create_device_user())
participant_queryset = Participation.manager.all()
# Act
response_queryset = ParticipationFilter().filter_campaigns(participant_queryset, str(self.campaign.id)+',' +
str(other_campaign.id))
# Assert
self.assertEqual(response_queryset.count(), 2)
def test_send_push_to_different_games__several_players_with_invalid_gcm_id__status201(
self):
# arrange
game = create_game()
game2 = create_game(api_key=self.api_key_2,
package_name="pack",
game_service_id="service_id")
game3 = create_game(api_key=self.api_key_2,
package_name="other_pack",
game_service_id="service_id_2")
for i in range(2):
create_device_user(game=game, gcm_id="C")
for i in range(2):
create_device_user(game=game2, gcm_id="B")
for i in range(6):
create_device_user(game=game3, gcm_id="")
for i in range(11):
create_device_user(game=game3, gcm_id="OLA")
for i in range(11):
create_device_user(game=game2, gcm_id="")
data = {
"data":
"{'message': 'default_message'}",
"query":
"{'games': '" + str(game.id) + ',' + str(game3.id) + ',' +
str(game2.id) + "'}"
}
# act
response = self.client.post(self.url,
data,
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test_send_push__valid_participation__status201(self, mock_push):
# arrange
game = create_game(api_key=self.api_key_2)
campaign = create_campaign()
player = create_device_user(game=game)
create_participation(campaign, player=player, country_code="US")
data = {
"data":
"{'message': 'default_message'}",
"query":
"{'games': '" + str(game.id) + "', 'campaigns': '" +
str(campaign.id) + "'}"
}
# act
response = self.client.post(self.url,
data,
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test__push_details__players__status200(self, mock_details):
# arrange
game = create_game()
create_device_user(game=game, gcm_id=self.fake_gcm_id_1)
create_device_user(game=game, gcm_id=self.fake_gcm_id_2)
create_device_user(game=game, gcm_id=self.fake_gcm_id_3)
data = {
"data": "{'message': 'default_message'}",
"query": "{'games': '" + str(game.id) + "'}"
}
self.client.post(self.url, data, HTTP_AUTHORIZATION=self.token)
# act
response_details = self.client.get('/gmm/push/1/details',
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response_details.status_code, status.HTTP_200_OK)
def test_send_push__to_valid_end_invalid_gcm_ids__status201(
self, mock_push):
# arrange
game = create_game()
game2 = create_game(api_key=self.api_key_2,
package_name="pack",
game_service_id="service_id")
create_device_user(game=game)
create_device_user(gcm_id="wrong gcm id", game=game2)
create_device_user(gcm_id=self.valid_gcm_id_2, game=game)
data = {
"data": "{'message': 'default_message'}",
"query": "{'games': '" + str(game.id) + ',' + str(game2.id) + "'}"
}
# act
response = self.client.post(self.url,
data,
HTTP_AUTHORIZATION=self.token)
# assert
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def setUp(self):
self.campaign = create_campaign()
self.game = create_game()
self.player = create_device_user()
def setUp(self):
create_device_user()
