def create_deposit(self):
transactions = [create_revenue() for i in range(100)]
data = {"PlayerID": self.player.PlayerID, "InitID": generate_random_int(),
"Transactions": [r.__dict__ for r in transactions]}
self.client.post(get_deposit_resource(),
data=json.dumps(data),
headers=get_api_headers())
def test_tc_32_player_registration_empty_tracking_code(self):
"""
IMPORTANT NOTE: According to doc https://qa-gaming.aretonet.com/kb/campaigns#ua_campaigns_promo
If both a promotional code and a tracking code are received, the promotional code will be taken into
consideration while the tracking code will be discarded;
and if tracking code is available this value will be used as CustomString3 iff promo code is not null or empty
:return:
"""
player = create_random_player()
player.TrackingCode = ""
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(), data=json.dumps(player.__dict__),
headers=get_api_headers())
self.assertTrue(response.status_code, 500)
body = response.json()
logging.info("API response: {}".format(body))
q_net_customer = requests.get("http://{}/customer?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()[0]
q_net_dw_fact_signup = requests.get("http://{}/sign_up?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()[0]
self.assertTrue(q_net_customer)
self.assertTrue(q_net_dw_fact_signup)
self.assertEquals(q_net_customer["CustomString3"], str(player.CustomString3))
self.assertTrue(body['Success'])
self.assertEqual(body["Message"], "OK")
def test_tc_2_cancel_wager_parimutuel_without_player_id(self):
player = create_random_player(player_id_length=40)
logging.info("Creating player: {}".format(player.__dict__))
# Create player
channel = 1
self.create_and_validate_player(player, channel)
wagers = self.create_wagers()
# Create Wager
data, request_id = self.create_and_validate_wager_parimutuel(
player, wagers)
data["PlayerID"] = None
wager_parimutuel_response = requests.delete(
get_wagers_parimutuel_resource(channel=''),
data=json.dumps(data),
headers=get_api_headers())
self.assertTrue(wager_parimutuel_response.status_code, 200)
body = wager_parimutuel_response.json()
self.assertEqual(body.get('Success'), False)
self.assertEqual(body.get('Message'),
get_api_error_player_id_not_passed())
self.assertEqual(body.get('RequestID'), 0)
def create_five_wagers(self):
wagers, url = self.create_random_wager()
data = {
"PlayerID": self.player.PlayerID,
"InitID": generate_random_int(),
"Wagers": [r.__dict__ for r in wagers]
}
self.client.post(url, data=json.dumps(data), headers=get_api_headers())
def test_tc_6_event_lottery_empty_list(self):
parimutuel_event_response = requests.post(get_dim_lottery_resource(),
data=json.dumps([]),
headers=get_api_headers())
self.assertTrue(parimutuel_event_response.status_code, 200)
body = parimutuel_event_response.json()
self.assertEqual(body.get('Success'), False)
self.assertEqual(body.get('Message'), get_api_error_event_list_empty())
self.assertEqual(body.get('RequestID'), 0)
def _create_player():
player = create_random_player(player_id_length=40)
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(),
data=json.dumps(player.__dict__),
headers=get_api_headers())
body = response.json()
logging.info("API response: {}".format(body))
return player
def create_withdrawal(self):
withdrawals = [create_withdrawal()]
data = {
"PlayerID": self.player.PlayerID,
"InitID": generate_random_int(),
"Withdrawals": [r.__dict__ for r in withdrawals]
}
self.client.post(get_withdrawal_resource(),
data=json.dumps(data),
headers=get_api_headers())
def create_wager_casino(self):
wagers = [create_wager_casino() for i in range(100)]
data = {
"PlayerID": self.player.PlayerID,
"InitID": generate_random_int(),
"Wagers": [r.__dict__ for r in wagers]
}
self.client.post(get_wager_casino_resource(channel=1),
data=json.dumps(data),
headers=get_api_headers())
def create_payout(self):
bonuses = [create_payout(self.get_payout_type())]
data = {
"PlayerID": self.player.PlayerID,
"InitID": generate_random_int(),
"Payouts": [r.__dict__ for r in bonuses]
}
self.client.post(get_payout_resource(),
data=json.dumps(data),
headers=get_api_headers())
def test_tc_2_wager_parimutuel_without_player_id(self):
data = {"PlayerID": None, "Wagers": []}
wager_parimutuel_response = requests.post(get_wagers_parimutuel_resource(),
data=json.dumps(data),
headers=get_api_headers())
self.assertTrue(wager_parimutuel_response.status_code, 200)
body = wager_parimutuel_response.json()
self.assertEqual(body.get('Success'), False)
self.assertEqual(body.get('Message'), get_api_error_player_id_not_passed())
self.assertEqual(body.get('RequestID'), 0)
def send_lottery_event(self, events):
parimutuel_event_response = requests.post(get_dim_lottery_resource(),
data=json.dumps(events),
headers=get_api_headers())
self.assertTrue(parimutuel_event_response.status_code, 200)
body = parimutuel_event_response.json()
logging.info("Event Parimutuel API response: {}".format(body))
self.assertEqual(body.get('Success'), True)
self.assertEqual(body.get('Message'), get_api_ok_message())
request_id = body.get('RequestID')
self.assertTrue(request_id)
return request_id
def create_areto_api_object(resource, data, success=True, msg=get_api_ok_message()):
response = requests.post(resource, data=json.dumps(data), headers=get_api_headers())
assert response.status_code == 200
body = response.json()
assert body.get('Success') == success
assert body.get('Message').lower() == msg.lower()
request_id = body.get('RequestID')
if success:
assert request_id is not None
else:
assert request_id == 0
return request_id
def cancel_wagers_sports(self, data):
wager_parimutuel_response = requests.delete(get_wager_sport_resource(channel=''),
data=json.dumps(data),
headers=get_api_headers())
self.assertTrue(wager_parimutuel_response.status_code, 200)
body = wager_parimutuel_response.json()
logging.info("Cancel Wager Parimutuel API response: {}".format(body))
self.assertEqual(body.get('Success'), True)
self.assertEqual(body.get('Message'), get_api_ok_message())
request_id = body.get('RequestID')
self.assertTrue(request_id)
return request_id
def _create_wagers(player, wagers=[]):
_wagers = [create_casino()] if wagers == [] else wagers
logging.info("Creating wagers: {}".format([r.__dict__ for r in _wagers]))
data = {"PlayerID": player.PlayerID, "InitID": generate_random_int(),
"Wagers": [r.__dict__ for r in _wagers]}
logging.info("Request data: {}".format(json.dumps(data)))
response = requests.post(get_wager_casino_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return wagers, response.json()["RequestID"]
def test_tc_4_signin_without_channel(self):
player = create_random_player(player_id_length=30)
logging.info("Creating player: {}".format(player.__dict__))
# Create player
channel = 2
self.create_and_validate_player(player, channel)
# Signin_channel_1
channel = ''
player_sign_in_response = requests.post(get_player_sign_in_resource(
player_id=player.PlayerID, channel=channel),
headers=get_api_headers())
self.assertTrue(player_sign_in_response.status_code, 404)
def create_and_validate_signin(self, player, channel=1):
player_sign_in_response = requests.post(get_player_sign_in_resource(player_id=player.PlayerID, channel=channel),
headers=get_api_headers())
self.assertTrue(player_sign_in_response.status_code, 200)
body = player_sign_in_response.json()
logging.info("API response: {}".format(body))
self.assertEqual(body.get('Result').get('Success'), True)
self.assertEqual(body.get('Result').get('Message'), get_api_ok_message())
signin_id = body.get('ID')
self.assertTrue(signin_id)
q_net_signin = self.get_signin(player)[0]
self.assertEqual(signin_id, q_net_signin['SignInID'])
return signin_id
def create_and_validate_wager_parimutuel(self, player, wagers, signin_id=None, channel=1):
data = {"PlayerID": player.PlayerID, "InitID": signin_id, "Wagers": wagers}
wager_parimutuel_response = requests.post(get_wagers_parimutuel_resource(channel=channel),
data=json.dumps(data),
headers=get_api_headers())
self.assertTrue(wager_parimutuel_response.status_code, 200)
body = wager_parimutuel_response.json()
logging.info("Wager Parimutuel API response: {}".format(body))
self.assertEqual(body.get('Success'), True)
self.assertEqual(body.get('Message'), get_api_ok_message())
request_id = body.get('RequestID')
self.assertTrue(request_id)
return data, request_id
def test_tc_12_wager_parimutuel_empty_wagers_list(self):
# New test
player = create_random_player(player_id_length=40)
data = {"PlayerID": player.PlayerID, "Wagers": []}
wager_parimutuel_response = requests.post(get_wagers_parimutuel_resource(),
data=json.dumps(data),
headers=get_api_headers())
self.assertTrue(wager_parimutuel_response.status_code, 200)
body = wager_parimutuel_response.json()
self.assertEqual(body.get('Success'), False)
self.assertEqual(body.get('Message'), get_api_error_wager_list_empty())
self.assertEqual(body.get('RequestID'), 0)
def _create_player_with_withdrawal(withdrawal=None):
player = create_random_player(player_id_length=40)
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(),
data=json.dumps(player.__dict__),
headers=get_api_headers())
body = response.json()
logging.info("API response: {}".format(body))
withdrawal = create_withdrawal() if withdrawal is None else withdrawal
logging.info("Creating withdrawal: {}".format(withdrawal.__dict__))
data = {
"PlayerID": player.PlayerID,
"InitID": generate_random_int(),
"Withdrawals": [withdrawal.__dict__]
}
logging.info("Request data: {}".format(data))
response = requests.post(get_withdrawal_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return player, withdrawal, response.json()["RequestID"]
def create_and_validate_player(self, player):
player_sign_up_response = requests.post(get_player_sign_up_resource(), data=json.dumps(player.__dict__),
headers=get_api_headers())
self.assertTrue(player_sign_up_response.status_code, 200)
body = player_sign_up_response.json()
logging.info("API response: {}".format(body))
self.assertTrue(body.get('Success'), True)
self.assertEqual(body.get('Message'), get_api_ok_message())
q_net_customer_list = self.get_customer(player)
self.assertEqual(len(q_net_customer_list), 1)
q_net_customer = q_net_customer_list[0]
self.assertTrue(q_net_customer)
self.assertEqual(player.PlayerID, q_net_customer['ExternalCustomerID'])
self.assertEqual(player.Email, q_net_customer['Email'])
def update_and_validate_player(self, player, obj_field, db_field):
player_update_response = requests.post(get_player_update_resource(),
data=json.dumps(
player.__dict__),
headers=get_api_headers())
self.assertTrue(player_update_response.status_code, 200)
body = player_update_response.json()
self.assertEqual(body.get('Success'), True)
self.assertEqual(body.get('Message'), get_api_ok_message())
updated_q_net_customer_list = self.get_customer(player)
updated_q_net_customer = [
c for c in updated_q_net_customer_list
if getattr(player, obj_field) == c[db_field]
]
self.assertTrue(updated_q_net_customer)
return updated_q_net_customer[0]
def _create_bonuses(player, bonuses=[]):
_bonuses = [create_bonus()] if bonuses == [] else bonuses
logging.info("Creating bonus: {}".format(
[r.__dict__ for r in _bonuses]))
data = {
"PlayerID": player.PlayerID,
"InitID": generate_random_int(),
"Bonuses": [r.__dict__ for r in _bonuses]
}
logging.info("Request data: {}".format(json.dumps(data)))
response = requests.post(get_bonus_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return bonuses, response.json()["RequestID"]
def _create_revenues(player, revenues=[]):
revenues = [create_revenue()] if revenues == [] else revenues
logging.info("Creating revenue: {}".format(
[r.__dict__ for r in revenues]))
data = {
"PlayerID": player.PlayerID,
"InitID": generate_random_int(),
"Transactions": [r.__dict__ for r in revenues]
}
logging.info("Request data: {}".format(json.dumps(data)))
response = requests.post(get_deposit_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return revenues, response.json()["RequestID"]
def _create_payouts(player, payout_type, payouts=[]):
_payouts = [create_payout(
payout_type=payout_type)] if payouts == [] else payouts
logging.info("Creating payouts: {}".format(
[r.__dict__ for r in _payouts]))
data = {
"PlayerID": player.PlayerID,
"InitID": int(generate_random_int()),
"Payouts": [r.__dict__ for r in _payouts]
}
logging.info("Request data: {}".format(json.dumps(data)))
response = requests.post(get_payout_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return payouts, response.json()["RequestID"]
def test_tc_2_player_registration_id_41_chars(self):
player = create_random_player(player_id_length=41)
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(), data=json.dumps(player.__dict__),
headers=get_api_headers())
self.assertTrue(response.status_code, 200)
body = response.json()
logging.info("API response: {}".format(body))
self.assertFalse(body.get('Success'))
self.assertTrue(body.get('Message'), 'PlayerID too long')
q_net_customer = requests.get("http://{}/customer?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()
q_net_dw_fact_signup = requests.get("http://{}/sign_up?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()
self.assertFalse(q_net_customer)
self.assertFalse(q_net_dw_fact_signup)
def test_tc_5_player_registration_empty_name(self):
player = create_random_player()
player.Name = ''
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(), data=json.dumps(player.__dict__),
headers=get_api_headers())
self.assertTrue(response.status_code, 200)
body = response.json()
logging.info("API response: {}".format(body))
self.assertTrue(body.get('Success'), True)
q_net_customer = requests.get("http://{}/customer?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()[0]
q_net_dw_fact_signup = requests.get("http://{}/sign_up?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()
self.assertTrue(q_net_customer)
self.assertTrue(q_net_dw_fact_signup)
def test_tc_4_player_registration_invalid_email(self):
player = create_random_player()
player.Email = '12345.com'
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(), data=json.dumps(player.__dict__),
headers=get_api_headers())
self.assertTrue(response.status_code, 200)
body = response.json()
logging.info("API response: {}".format(body))
self.assertFalse(body.get('Success'))
self.assertTrue(body.get('Message'), 'Email not being passed or is invalid')
q_net_customer = requests.get("http://{}/customer?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()
q_net_dw_fact_signup = requests.get("http://{}/sign_up?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()
self.assertFalse(q_net_customer)
self.assertFalse(q_net_dw_fact_signup)
def test_tc_1_player_registration_id_40_chars(self):
player = create_random_player(player_id_length=40)
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(), data=json.dumps(player.__dict__),
headers=get_api_headers())
self.assertTrue(response.status_code, 200)
body = response.json()
logging.info("API response: {}".format(body))
self.assertTrue(body.get('Success'), True)
q_net_customer = requests.get("http://{}/customer?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()[0]
q_net_dw_fact_signup = requests.get("http://{}/sign_up?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()
self.assertTrue(q_net_customer)
self.assertTrue(q_net_dw_fact_signup)
self.assertEqual(player.PlayerID, q_net_customer['ExternalCustomerID'])
self.assertEqual(player.Email, q_net_customer['Email'])
self.assertEqual(player.Name, q_net_customer['Name'])
self.assertEqual(player.Surname, q_net_customer['Surname'])
def test_tc_1_a_player_registration_french(self):
player = create_random_player(player_id_length=40)
player.Name = u"Le jeu du garçon"
player.Surname = u"Le jeu du garçon"
player.CountryCode = u"FR"
player.City = u"Nîmes"
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(), data=json.dumps(player.__dict__),
headers=get_api_headers())
self.assertTrue(response.status_code, 200)
body = response.json()
logging.info("API response: {}".format(body))
self.assertTrue(body.get('Success'), True)
q_net_customer = requests.get("http://{}/customer?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()[0]
q_net_dw_fact_signup = requests.get("http://{}/sign_up?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()
self.assertTrue(q_net_customer)
self.assertTrue(q_net_dw_fact_signup)
def test_tc_37_player_registration_empty_optout_push(self):
player = create_random_player()
player.OptOutPush = ""
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(), data=json.dumps(player.__dict__),
headers=get_api_headers())
self.assertTrue(response.status_code, 500)
body = response.json()
logging.info("API response: {}".format(body))
q_net_customer = requests.get("http://{}/customer?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()[0]
q_net_dw_fact_signup = requests.get("http://{}/sign_up?customer_id={}".format(
get_config().get("test_framework", "db"), player.PlayerID)).json()[0]
self.assertTrue(q_net_customer)
self.assertTrue(q_net_dw_fact_signup)
self.assertEquals(q_net_customer["OptOutPush"], False)
self.assertTrue(body['Success'])
self.assertEqual(body["Message"], "OK")
