def setup_class(self):
Logger.logSuiteName(str(self).split('.')[-1])
self.actualOrgId = IrisHelper.updateOrgId(
constant.config['reon']['orgId'])
self.actualOrgName = IrisHelper.updateOrgName(
constant.config['reon']['orgName'])
CreateAudience.getPocUsers()
def create(campaignType, testControlType, payload=None, startDate=None, endDate=None, description=None,
testControlPercentage=None, name=None, updateNode=False, lockNode=False):
if not CreateCampaign.checkCampaignAvialable(campaignType, testControlType) or updateNode:
endpoint = IrisHelper.constructUrl('createcampaign')
payload = CreateCampaign.constructPayload(campaignType, startDate, endDate, description, testControlType,
testControlPercentage, name) if payload is None else payload
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint, data=payload, auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='POST')
)
if response['statusCode'] == 200:
CreateCampaign.validateCreateCampaign(response)
if not lockNode: CreateCampaign.updateNodeCampaign(campaignType, testControlType,
response['json']['entity']['campaignId'],
payload['name'], payload)
if campaignType == 'LAPSED': time.sleep(25) # Wait to make Campaign Lapsed
return {
'ID': response['json']['entity']['campaignId'],
'NAME': payload['name'],
'PAYLOAD': payload
}
else:
return {
'RESPONSE': response,
'PAYLOAD': payload
}
else:
return constant.config['node'][campaignType][testControlType]['CAMPAIGN']
def getObjectives():
campaignObjectivesEndpoint = IrisHelper.constructUrl('campaignobjectives')
response = Utils.makeRequest(url=campaignObjectivesEndpoint, data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='GET')
return {'RESPONSE': IrisHelper.constructResponse(response)}
def getMessageVariantById(campaignId, variantId):
endpoint = IrisHelper.constructUrl('getmessagevariant').replace('{campaignId}', str(campaignId)).replace(
'{variantId}',
variantId)
response = Utils.makeRequest(url=endpoint, data='', auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='GET')
return IrisHelper.constructResponse(response)
def test_irisv2_message_execute_flow_precheck_failed_immediate_CreditUnavialable(
self, campaignType, testControlType, listType, channel,
messageInfo):
preCheckError = {
'status': 'TEMPORARY_FAILURE',
'errorDescription': 'BULK_CREDITS_NOT_AVAILABLE'
}
try:
messageDetails = CreateMessage.create(campaignType,
testControlType,
listType,
channel,
messageInfo,
updateNode=True,
lockNode=True)
CreateMessage.assertResponse(messageDetails['RESPONSE'], 200)
IrisHelper.updateCredit(0, channel)
approveRespone = AuthorizeMessage.approve(
campaignType,
testControlType,
listType,
channel,
messageInfo,
messageCreateResponse=messageDetails)
AuthorizeMessage.assertResponse(approveRespone, 200)
PreCheckDBValidation(
constant.config['node'][campaignType][testControlType]
['CAMPAIGN']['ID'],
messageDetails['RESPONSE']['json']['entity']['id'],
messageInfo['scheduleType']['type'], ['OPENED'],
remindCheck=False,
precheck=preCheckError,
variantCheck=False).validateMessageFlow()
finally:
IrisHelper.updateCredit(99999, channel)
def test_irisv2_message_precheck_create_filter_mobile_recurring_CreditAvialable(
self, campaignType, testControlType, listType, channel,
messageInfo, precheckErrors):
try:
messageDetails = CreateMessage.create(campaignType,
testControlType,
listType,
channel,
messageInfo,
updateNode=True,
lockNode=True)
precheckErrors[1]['parameters'][
'balanceRequiredCredits'] = list_Calls().getCustomerCountInGVD(
messageDetails['PAYLOAD']['targetAudience']['include'][0])
CreateMessage.assertResponse(messageDetails['RESPONSE'], 200)
IrisHelper.updateCredit(0, channel)
preCheckResponse = PreCheck.executePrecheck(
constant.config['node'][campaignType][testControlType]
['CAMPAIGN']['ID'],
messageDetails['RESPONSE']['json']['entity']['id'])
PreCheck.assertPreCheckResponse(preCheckResponse, 200)
PreCheck.assertPrecheckStatus(preCheckResponse, precheckErrors)
except Exception, exp:
Assertion.constructAssertion(
False, 'Failure Due to Exception :{}'.format(exp))
def test_irisv2_message_execute_flow_precheck_particularDate_NotAuthorized_remind_retrail_remind_CreditUnavialable(
self, campaignType, testControlType, listType, channel,
messageInfo):
preCheckError = {
'create': {
'status': 'TEMPORARY_FAILURE',
'errorDescription': 'CAMPAIGN_NOT_AUTHORIZED'
},
'execute': {
'status': 'TEMPORARY_FAILURE',
'errorDescription': 'BULK_CREDITS_NOT_AVAILABLE'
}
}
try:
messageDetails = CreateMessage.create(campaignType,
testControlType,
listType,
channel,
messageInfo,
updateNode=True,
lockNode=True)
CreateMessage.assertResponse(messageDetails['RESPONSE'], 200)
PreCheckDBValidation(
constant.config['node'][campaignType][testControlType]
['CAMPAIGN']['ID'],
messageDetails['RESPONSE']['json']['entity']['id'],
messageInfo['scheduleType']['type'], ['REMINDED', 'OPENED'],
executeCheck=False,
precheck=preCheckError['create'],
variantCheck=False).validateMessageFlow()
IrisHelper.updateCredit(0, channel)
approveRespone = AuthorizeMessage.approve(
campaignType,
testControlType,
listType,
channel,
messageInfo,
messageCreateResponse=messageDetails)
AuthorizeMessage.assertResponse(approveRespone, 200)
Precheck_calls().waitForJobTypeUpdate(
constant.config['node'][campaignType][testControlType]
['CAMPAIGN']['ID'],
messageDetails['RESPONSE']['json']['entity']['id'],
'REMIND',
'PRECHECK',
'TEMPORARY_FAILURE',
expectedError='BULK_CREDITS_NOT_AVAILABLE')
PreCheckDBValidation(
constant.config['node'][campaignType][testControlType]
['CAMPAIGN']['ID'],
messageDetails['RESPONSE']['json']['entity']['id'],
messageInfo['scheduleType']['type'], ['REMINDED', 'OPENED'],
executeCheck=False,
precheck=preCheckError['execute'],
variantCheck=False).validateMessageFlow()
except AssertionError, exp:
Assertion.constructAssertion(False, 'Reason :{}'.format(exp))
def getMessageAll(campaignId, queryParam=[]):
endpoint = IrisHelper.constructUrl('getmessage', queryParam=queryParam).replace('{campaignId}',
str(campaignId)).replace(
'{messageId}',
'')
response = Utils.makeRequest(url=endpoint, data='', auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='GET')
return IrisHelper.constructResponse(response)
def approveWithCampaignAndMessageId(campaignId, messageId):
endPoint = IrisHelper.constructUrl('approvemessage').replace(
'{campaignId}', str(campaignId)).replace('{msgId}', messageId)
return IrisHelper.constructResponse(
Utils.makeRequest(url=endPoint,
data=None,
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='POST'))
def getOnboardingStatus(orgId):
orgOnboardingStatusEndpoint = IrisHelper.constructUrl(
'orgonboadringstatus').replace('{orgId}', orgId)
response = Utils.makeRequest(url=orgOnboardingStatusEndpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return {'RESPONSE': IrisHelper.constructResponse(response)}
def getOrgV2Status():
orgStatusEndpoint = IrisHelper.constructUrl('orgv2status')
response = Utils.makeRequest(url=orgStatusEndpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return {'RESPONSE': IrisHelper.constructResponse(response)}
def checkExists(campaignName):
checkExistsEndpoint = IrisHelper.constructUrl(
'checkcampaignexists').replace('{name}', campaignName)
response = Utils.makeRequest(url=checkExistsEndpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return IrisHelper.constructResponse(response)
def test_irisV2_getPoc_WrongAuth(self):
previousUserName = None
try:
previousUserName = IrisHelper.updateUserName('WrongName')
response = Poc.getPoc()
Poc.assertResponse(response, 401, 999999, 'Unauthorized')
finally:
if previousUserName is not None:
IrisHelper.updateUserName(previousUserName)
def test_productCategory_wrongPassword(self, apiCategory):
try:
actualPassword = IrisHelper.updatepassword(555)
actualResult = ProductCategory.getLevelsForDimension(apiCategory)
ProductCategory.assertResponse(actualResult,
401,
expectedErrorCode=999999,
expectedErrorMessage='Unauthorized')
finally:
IrisHelper.updatepassword(actualPassword)
def test_productCategory_wrongUserName(self, apiCategory):
try:
actualUserName = IrisHelper.updateUserName('ztyv')
actualResult = ProductCategory.getLevelsForDimension(apiCategory)
ProductCategory.assertResponse(actualResult,
401,
expectedErrorCode=999999,
expectedErrorMessage='Unauthorized')
finally:
IrisHelper.updateUserName(actualUserName)
def executePrecheck(campaignId, messageId, checkVariant=True):
if checkVariant: PreCheck.checkVariantIsClosed(messageId)
endpoint = IrisHelper.constructUrl('precheck').replace(
'{campaignId}', str(campaignId)).replace('{messageId}', messageId)
response = Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return IrisHelper.constructResponse(response)
def test_irisV2_getLoyaltyProgram_WrongAuth(self):
previousUserName = None
try:
previousUserName = IrisHelper.updateUserName('WrongName')
response = LoyaltyProgram.getLoyaltyProgram()
LoyaltyProgram.assertResponse(response, 401, 999999,
'Unauthorized')
finally:
if previousUserName is not None:
IrisHelper.updateUserName(previousUserName)
def getAll(queryParam):
endpoint = IrisHelper.constructUrl('getById',
queryParam=queryParam).replace(
'{group_id}', '')
response = Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return IrisHelper.constructResponse(response)
def getLevelsForDimension(category):
endpoint = IrisHelper.constructUrl('productcategory').replace(
'{category}', category)
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET'))
return response
def start(campaignId, messageId):
endpoint = IrisHelper.constructUrl('startmessage').replace(
'{campaignId}', str(campaignId)).replace('{msgId}', messageId)
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='POST'))
return response
def test_productCategory_orgNotSynced(self, apiCategory):
try:
IrisHelper.updateOrgId(constant.config['reonNotSynced']['orgId'])
actualResult = ProductCategory.getLevelsForDimension(apiCategory)
ProductCategory.assertResponse(
actualResult,
400,
expectedErrorCode=101,
expectedErrorMessage='Generic error: Could not fetch levels.')
finally:
IrisHelper.updateOrgId(self.actualOrgId)
def getLevelValuesForDimension(urlSubstringForDimension, levelName):
endpoint = IrisHelper.constructUrl('productlevel').replace(
'{urlSubstringForDimension}',
urlSubstringForDimension).replace('{levelName}', levelName)
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET'))
return response
def test_productCategory_unknownOrg(self, apiCategory):
try:
IrisHelper.updateOrgId(-1)
actualResult = ProductCategory.getLevelsForDimension(apiCategory)
ProductCategory.assertResponse(
actualResult,
401,
expectedErrorCode=999999,
expectedErrorMessage='Invalid org id')
finally:
IrisHelper.updateOrgId(self.actualOrgId)
def edit(campaignId, messageId, payload, editInfo=None):
endpoint = IrisHelper.constructUrl('editmessage').replace(
'{campaignId}', str(campaignId)).replace('{msgId}', messageId)
if editInfo is not None:
payload.update(editInfo)
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint,
data=payload,
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='PUT'))
return {'RESPONSE': response, 'PAYLOAD': payload}
def test_testAndPreview_negative_validationCases_emptyAuth(self):
previousAuth = IrisHelper.updateUserName('')
previousPass = IrisHelper.updatepassword('')
try:
payload = copy.deepcopy(self.testAndControlPayload['SMS'])
testPreviewResponse, testPreviewPayload = TestPreview.create(
'LIVE', 'ORG', 'MOBILE', 0, payload=payload)
TestPreview.assertResponse(testPreviewResponse, 401, 999999,
'Unauthorized')
except Exception, exp:
Assertion.constructAssertion(False,
'Exception Occured :{}'.format(exp))
def edit(campaignInfo,editInfo):
payload = copy.deepcopy(campaignInfo['PAYLOAD'])
payload.update(editInfo)
endpoint = IrisHelper.constructUrl('editcampaign').replace('{campaignId}',str(campaignInfo['ID']))
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint, data=payload, auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='PUT')
)
return {
'PAYLOAD':payload,
'RESPONSE' : response
}
def updateSettings(self, updateInfo={}):
campaignSettingsEndpoint = IrisHelper.constructUrl('campaignSettings')
payload = CampaignSetting.constructUploadPayload(updateInfo)
response = Utils.makeRequest(
url=campaignSettingsEndpoint,
data=payload,
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeadersPatch(),
method='PATCH')
return {
'RESPONSE': IrisHelper.constructResponse(response),
'PAYLOAD': payload
}
def test_irisv2_message_execute_flow_precheck_failed_particularDate_GatewayUnavialable_SuccessAtExecute(
self, campaignType, testControlType, listType, channel,
messageInfo):
preCheckError = {
'status': 'TEMPORARY_FAILURE',
'errorDescription': 'CAMPAIGN_NOT_AUTHORIZED,GATEWAY_NOT_AVAILABLE'
}
dummyGatewayCreated = False
try:
messageDetails = CreateMessage.create(campaignType,
testControlType,
listType,
channel,
messageInfo,
updateNode=True,
lockNode=True)
IrisHelper.disableDomainGatewayMapId(channel)
CreateMessage.assertResponse(messageDetails['RESPONSE'], 200)
PreCheckDBValidation(
constant.config['node'][campaignType][testControlType]
['CAMPAIGN']['ID'],
messageDetails['RESPONSE']['json']['entity']['id'],
messageInfo['scheduleType']['type'], ['REMINDED', 'OPENED'],
executeCheck=False,
precheck=preCheckError,
variantCheck=False).validateMessageFlow()
if IrisHelper.createNewDummyGateway(channel):
dummyGatewayCreated = True
approveRespone = AuthorizeMessage.approve(
campaignType,
testControlType,
listType,
channel,
messageInfo,
messageCreateResponse=messageDetails)
AuthorizeMessage.assertResponse(approveRespone, 200)
Precheck_calls().waitForJobTypeUpdate(
constant.config['node'][campaignType][testControlType]
['CAMPAIGN']['ID'],
messageDetails['RESPONSE']['json']['entity']['id'], 'REMIND',
'PRECHECK', 'SUCCESS')
PreCheckDBValidation(
constant.config['node'][campaignType][testControlType]
['CAMPAIGN']['ID'],
messageDetails['RESPONSE']['json']['entity']['id'],
messageInfo['scheduleType']['type'],
['REMINDED', 'OPENED']).validateMessageFlow()
except AssertionError, exp:
Assertion.constructAssertion(False, '{}'.format(exp))
def test_productCategory_values_search_orgNotYetSynced(
self, apiCategory, levelName, searchText):
try:
IrisHelper.updateOrgId(constant.config['reonNotSynced']['orgId'])
actualResult = ProductCategory.getLevelValuesUsingSearchText(
apiCategory, levelName, searchText)
ProductCategory.assertResponse(
actualResult,
400,
expectedErrorCode=101,
expectedErrorMessage=
'Generic error: Could not fetch attribute values using search text.'
)
finally:
IrisHelper.updateOrgId(self.actualOrgId)
def settings(self, settingInfo={}, popField=None):
Logger.log('Setting Info :', settingInfo)
campaignSettingsEndpoint = IrisHelper.constructUrl('campaignSettings')
payload = CampaignSetting.constructPayloadSetting(
settingInfo, popField)
response = Utils.makeRequest(url=campaignSettingsEndpoint,
data=payload,
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='POST')
return {
'RESPONSE': IrisHelper.constructResponse(response),
'PAYLOAD': payload
}
