def test_tc_25_player_registration_empty_custom_string_4(self):
"""
IMPORTANT NOTE from asana: If the CustomString4 is empty,
the value from the PromoCode field will be added - IT IS RESERVED FIELD.
:return:
"""
player = create_random_player()
player.CustomString4 = ''
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))
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["CustomString4"], player.PromoCode)
self.assertTrue(body['Success'])
self.assertEqual(body["Message"], "OK")
def get_event(self, event_id, event=None):
url = "http://{}/games/sports?event_id={}".format(
get_config().get("test_framework", "db"), event_id)
if event:
url = "http://{}/games/sports?event={}".format(
get_config().get("test_framework", "db"), event)
return get_until_not_empty(url, timeout=100)
def test_tc_31_player_registration_empty_promo_code(self):
"""
IMPORTANT NOTE from asana: If PromoCode the CustomString4 will be replaced with
promocode value, if promocode is empty CustomString4 will keep it's original value
:return:
"""
player = create_random_player()
player.PromoCode = ""
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["CustomString4"], str(player.CustomString4))
self.assertTrue(body['Success'])
self.assertEqual(body["Message"], "OK")
def test_tc_4_create_game_session_casino_without_session_date(self):
player = create_random_player(player_id_length=40)
session = create_game_session()
session.SessionDate = None
data = {
"PlayerID": player.PlayerID,
"GameSessions": [session.__dict__]
}
channel = 1
create_areto_api_object(resource=get_game_session_resource(channel),
data=data)
for session in data['GameSessions']:
q_net_session_list = get_game_session_response(player.PlayerID)
self.assertEqual(len(q_net_session_list['fact']), 1)
self.assertEqual(len(q_net_session_list['dim']), 1)
fact = q_net_session_list['fact'][0]
self.assertEqual(fact['MerchantID'],
int(get_config().get("api", "merchant_id")))
self.assertTrue(fact['ActivityDate'])
self.assertTrue(fact['DateCreated'])
self.assertTrue(fact['ExternalCustomerID'], player.PlayerID)
self.assertTrue(fact['ChannelID'], channel)
self.assertTrue(fact['FactGameID'])
self.assertTrue(fact['GameID'])
self.assertGreaterEqual(fact['TimeID'], 0)
self.assertGreaterEqual(fact['SignInID'], 0)
game_id = fact['GameID']
dim = q_net_session_list['dim'][0]
self.assertEqual(dim['MerchantID'],
int(get_config().get("api", "merchant_id")))
self.assertTrue(dim['DateCreated'])
self.assertEqual(dim['GameName'], session['GameIdentifier'])
self.assertEqual(dim['GameCategory'], session['GameType'])
self.assertEqual(dim['GameID'], game_id)
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 __init__(self):
server = get_config().get("mssql", "server")
username = get_config().get("mssql", "username")
password = get_config().get("mssql", "password")
database = get_config().get("mssql", "database_name")
params = urllib.parse.quote_plus(
'DRIVER={ODBC Driver 17 for SQL Server};SERVER=' + server +
';DATABASE=' + database + ';UID=' + username + ';PWD=' + password)
self.dao = Dao("mssql+pyodbc:///?odbc_connect=%s" % params)
self.model = None
def get_freespin_by_customer_id():
customer_id = request.args.get("customer_id")
merchant_id = request.args.get("merchant_id",
int(get_config().get("api", "merchant_id")))
freespin = QNetDwFactFreeSpinRepository(
).get_by_external_customer_id_and_merchant_id(customer_id, merchant_id)
return json.dumps(freespin, default=str)
def get_customer_by_id_and_merchant():
customer_id = request.args.get("customer_id")
merchant_id = request.args.get("merchant_id",
int(get_config().get("api", "merchant_id")))
customers = QNetCustomerRepository(
).get_by_external_customer_id_and_merchant_id(customer_id, merchant_id)
logging.info("Customers: {}".format(customers))
return json.dumps(customers, default=str)
def get_customer_by_name_and_merchant_id():
name = request.args.get("name")
merchant_id = request.args.get("merchant_id",
int(get_config().get("api", "merchant_id")))
customers = QNetCustomerRepository().get_by_name_and_merchant_id(
name, merchant_id)
logging.info("Customer: {}".format(customers))
return json.dumps(customers, default=str)
def get_dim_freespin():
merchant_id = request.args.get("merchant_id",
int(get_config().get("ui", "merchant_id")))
name = request.args.get("name")
value = request.args.get("value")
freespin = QNetDwDimFreeSpinRepository().get_by_merchant_id_name_value(
merchant_id, name, value)
return json.dumps(freespin, default=str)
def get_dim_bonuses():
merchant_id = request.args.get("merchant_id",
int(get_config().get("ui", "merchant_id")))
name = request.args.get("name")
vertical_id = request.args.get("vertical_id")
bonuses = QNetDwDimBonusRepository().get_by_merchant_name_and_vertical_id(
merchant_id, name, vertical_id)
logging.info("DIM bonus: {}".format(bonuses))
return json.dumps(bonuses, default=str)
def test_tc_7_player_registration_empty_country_code(self):
player = create_random_player()
player.CountryCode = ''
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))
self.assertFalse(body['Success'])
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.assertTrue(q_net_customer == [])
self.assertTrue(q_net_dw_fact_signup == [])
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 get_api_headers():
headers = {
'Authorization':
'Bearer {token}'.format(
token=get_config().get("api", "authorization_header")),
'Content-Type':
'application/json'
}
return headers
def get_game_lottery():
name = request.args.get("name")
merchant_id = request.args.get("merchant_id",
int(get_config().get("api", "merchant_id")))
category = request.args.get("category")
games = QNetDwDimGameLotteryRepository().get_by_name_category(
name, category, merchant_id)
logging.info("Game parimutuel: {}".format(games))
return json.dumps(games, default=str)
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 assert_dim_bonuses_saved(context):
for bonus in context.bonuses:
url = "http://{}/dim_bonuses?name={}&vertical_id={}".format(
get_config().get("test_framework", "db"), bonus.Identifier,
bonus.ProductID)
db_bonus = get_until_not_empty(url, timeout=100)
assert len(db_bonus) == 1
assert db_bonus[0]['BonusID'] > 1
assert db_bonus[0]['MerchantID'] > 1
assert db_bonus[0]['Name'] == bonus.Identifier
assert db_bonus[0]['VerticalID'] == int(bonus.ProductID)
def test_tc_30_player_registration_empty_btag(self):
player = create_random_player()
player.Btag = ""
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["BTag"], "")
self.assertTrue(body['Success'])
self.assertEqual(body["Message"], "OK")
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 get_game_parimutuel_by_customer_id():
event_id = request.args.get("event_id")
merchant_id = request.args.get("merchant_id",
int(get_config().get("api", "merchant_id")))
breed = request.args.get("breed")
if not breed:
games = QNetDwDimGameParimutuelRepository().get_by_event_id(
event_id, merchant_id)
else:
games = QNetDwDimGameParimutuelRepository().get_by_breed(
breed, merchant_id)
logging.info("Game parimutuel: {}".format(games))
return json.dumps(games, default=str)
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 get_wagers_parimutuel_by_customer_id():
customer_id = request.args.get("customer_id")
merchant_id = request.args.get("merchant_id",
int(get_config().get("api", "merchant_id")))
wagercount = request.args.get("wagercount")
if wagercount:
wagers = QNetDwFactWagerRepository(
).get_by_external_customer_id_and_wagercount(customer_id, wagercount,
merchant_id)
else:
wagers = QNetDwFactWagerRepository(
).get_by_external_customer_id_and_merchant_id(customer_id, merchant_id)
logging.info("Wagers: {}".format(wagers))
return json.dumps(wagers, default=str)
def get_game_sports():
event_id = request.args.get("event_id")
merchant_id = request.args.get("merchant_id",
int(get_config().get("api", "merchant_id")))
event = request.args.get("event")
if not event:
games = QNetDwDimGameSportsRepository().get_by_event_id(
event_id, merchant_id)
else:
games = QNetDwDimGameSportsRepository().get_by_event(
event, merchant_id)
logging.info("Game parimutuel: {}".format(games))
return json.dumps(games, default=str)
def before_scenario(context, scenario):
context.cleanup_tasks = []
options = Options()
browser = os.getenv("BROWSER")
context.browser = WebDriver("http://{}:4444/wd/hub".format(
get_config().get(browser, "host")),
desired_capabilities={"browserName": browser},
options=options)
context.browser.set_page_load_timeout(15)
context.browser.implicitly_wait(15)
os.makedirs(join(context.screenshots_dir, scenario.name.replace(" ", "_")),
exist_ok=True)
context.screenshots_dir = join(context.screenshots_dir,
scenario.name.replace(" ", "_"))
def get_game():
merchant_id = request.args.get("merchant_id",
int(get_config().get("api", "merchant_id")))
customer_id = request.args.get("customer_id")
data = QNetDwFactGameRepository().get_by_customer_id_and_merchant_id(
customer_id, merchant_id)
if data:
d = {"fact": data}
dim = QNetDwDimGameRepository().get_by_id(data[0]['GameID'],
merchant_id)
d["dim"] = dim
data = d
logging.info("Game : {}".format(data))
return json.dumps(data, default=str)
def assert_users_saved(context):
for user in context.users:
url = "http://{}/customer_by_id?customer_id={}".format(
get_config().get("test_framework", "db"), user.PlayerID)
db_user = get_until_not_empty(url)
assert len(db_user) == 1
assert db_user[0]['ExternalCustomerID'] == user.PlayerID
assert db_user[0]['Email'] == user.Email
assert db_user[0]['Name'] == user.Name
assert db_user[0]['Surname'] == user.Surname
assert db_user[0]['ZipCode'] == user.ZipCode
assert db_user[0]['State'] == user.State
assert db_user[0]['City'] == user.City
assert db_user[0]['CountryCode'] == user.CountryCode
assert db_user[0]['DateOfBirth'] == user.DateOfBirth
assert db_user[0]['PhoneNumber'] == user.MobilePhone
assert db_user[0]['LastKnownLanguage'] == user.LanguageCode
assert db_user[0]['LastKnownTimezone'] == user.TimeZone
def test_tc_1_create_freespin_example(self):
player = create_random_player(player_id_length=40)
freespin = create_freespin()
data = {
"PlayerID": player.PlayerID,
"FreeSpins": [freespin.__dict__]
}
request_id = create_areto_api_object(resource=get_freespin_resource(), data=data)
q_net_freespin_list = get_freespin_response(data.get('PlayerID'))
self.assertEqual(len(q_net_freespin_list), 1)
for e in q_net_freespin_list:
self.assertEqual(e['MerchantID'], int(get_config().get("api", "merchant_id")))
self.assertTrue(e['FactFreeSpinID'])
self.assertGreaterEqual(e['TimeID'], 0)
self.assertGreaterEqual(e['SignInID'], 0)
self.assertTrue(e['FreeSpinID'])
self.assertTrue(e['DateCreated'])
self.assertTrue(e['ActivityDate'])
self.assertEqual(e['ExternalCustomerID'], data['PlayerID'])
def test_tc_1_create_event_sports_example(self):
event = create_sport_event(is_future=True)
logging.info("Creating event: {}".format(event.__dict__))
self.send_sport_event([event.__dict__])
q_net_event_list = self.get_event(event.EventID)
self.assertEqual(len(q_net_event_list), 1)
for e in q_net_event_list:
self.assertEqual(e['Event'], event.Event)
self.assertTrue(e['TimeID'])
self.assertTrue(e['GameID'])
self.assertEqual(e['Live'], event.Live)
self.assertEqual(e['MerchantID'],
int(get_config().get("api", "merchant_id")))
self.assertTrue(e['DateCreated'])
self.assertTrue(e['EventDate'])
self.assertEqual(e['Sport'], event.Sport)
self.assertEqual(e['ExternalEventID'], event.EventID)
self.assertEqual(e['League'], event.League)
def test_tc_4_create_freespin_without_transaction_date(self):
player = create_random_player(player_id_length=40)
freespin = create_freespin(is_future=True)
freespin.TransactionDate = None
data = {
"PlayerID": player.PlayerID,
"FreeSpins": [freespin.__dict__]
}
create_areto_api_object(resource=get_freespin_resource(), data=data)
q_net_freespin_list = get_freespin_response(data.get('PlayerID'))
self.assertEqual(len(q_net_freespin_list), 1)
for e in q_net_freespin_list:
self.assertEqual(e['MerchantID'], int(get_config().get("api", "merchant_id")))
self.assertTrue(e['FactFreeSpinID'])
self.assertTrue(e['TimeID'])
#self.assertFalse(e['SignInID'])
self.assertTrue(e['FreeSpinID'])
self.assertTrue(e['DateCreated'])
self.assertTrue(e['ActivityDate'])
self.assertEqual(e['ExternalCustomerID'], data['PlayerID'])
def test_tc_8_create_event_sports_aggregated(self):
events = []
for i in range(2):
events.append(create_sport_event(is_future=True).__dict__)
self.send_sport_event(events)
for event in events:
q_net_event_list = self.get_event(event['EventID'])
self.assertEqual(len(q_net_event_list), 1)
for e in q_net_event_list:
self.assertEqual(e['Event'], event['Event'])
self.assertTrue(e['TimeID'])
self.assertTrue(e['GameID'])
self.assertEqual(e['Live'], event['Live'])
self.assertEqual(e['MerchantID'],
int(get_config().get("api", "merchant_id")))
self.assertTrue(e['DateCreated'])
self.assertTrue(e['EventDate'])
self.assertEqual(e['Sport'], event['Sport'])
self.assertEqual(e['ExternalEventID'], event['EventID'])
self.assertEqual(e['League'], event['League'])
