def verifyListCreated(self, campaignId, listName):
Assertion.constructAssertion(
self.getListNameCreated(listName),
'List name Displayed on Recipient List Page')
Logger.log('Checking DB Group Details and Group Version Details')
groupId = DBCallsCampaigns.getGroupDetail(campaignId, listName)
maxNumberOfTry = 5
groupVersionIdTEST = None
while True:
allTargetTypes = DBCallsCampaigns.getGroupVersionDetail(
campaignId, groupId)
if len(allTargetTypes) >= 2 or maxNumberOfTry == 0:
break
else:
maxNumberOfTry = maxNumberOfTry - 1
Assertion.constructAssertion(
len(allTargetTypes) >= 2, 'Target Types are less than 2')
for eachTargetType in allTargetTypes:
if eachTargetType[1] == 'TEST':
groupVersionIdTEST = eachTargetType[0]
Assertion.constructAssertion(
eachTargetType[1] in ['TEST', 'CONTROL'],
'Group Version Details have value:{}'.format(
eachTargetType[0]))
return groupVersionIdTEST
def getNewGroupVersionForList(self, campaignId, listName):
Logger.log('Getting new group version for list :{}'.format(listName))
groupId = DBCallsCampaigns.getGroupDetail(campaignId, listName)
targetType = DBCallsCampaigns.getGroupVersionDetail(campaignId,
groupId,
versionNumber=1)
groupVersionIdTEST = None
for eachTargetType in targetType:
if eachTargetType[1] == 'TEST':
groupVersionIdTEST = eachTargetType[0]
return groupVersionIdTEST
def checkCurrentMilestonContextErrorUsers(self):
try:
temporalEngineMarkedErrorUsers = DBCallsCampaigns.getCurrentMilestoneContext(self.timelineDB)
self.listOfErrorUserFromTemporal = []
for eachErrorUser in temporalEngineMarkedErrorUsers:
self.listOfErrorUserFromTemporal.append(eachErrorUser[0])
Logger.log('List of Error Users from Timeline :{}'.format(self.listOfErrorUserFromTemporal))
except Exception, exp:
raise Exception('Current Milestone Context Failure :{}'.format(exp))
def assertSkipped(self):
try:
skippedInfo = DBCallsCampaigns.getSkippedDetails(self.bucketId, self.communicationDetailsId)
self.numberOfSkippedUsers = len(skippedInfo)
self.skippedDetails = {}
for eachUser in skippedInfo:
self.skippedDetails[eachUser[0]] = eachUser[1]
Logger.log('Skipped Details are :{}'.format(self.skippedDetails))
except Exception, exp:
raise Exception('Skipped Failure :{}'.format(exp))
def assertInboxes(self):
try:
inboxInfo = DBCallsCampaigns.getInboxDetails(self.bucketId, self.communicationDetailsId)
self.numberOfExecutedUsers = len(inboxInfo)
self.inboxDetails = {}
for eachExecutedUser in inboxInfo:
self.inboxDetails[eachExecutedUser[0]] = eachExecutedUser[1]
Logger.log('Inbox Details are :{}'.format(self.inboxDetails))
except Exception, exp:
raise Exception('Inboxes Failure :{}'.format(exp))
def assertActivityContextHistory(self):
try:
self.activityContextHistory = DBCallsCampaigns.getActivityContextHistory(self.timelineDB)
self.countOfAllUsersInActiivty = 0
self.countOfExpiredUserInActivity = 0
self.countOfExecutingUsers = 0
self.countOfControlUserInActivity = 0
self.countOfErrorUserInActivity = 0
self.countOfErrorUserInActivityFromTemporal = 0
self.countofExecutedUserInActivity = 0
for eachRecord in self.activityContextHistory:
self.countOfAllUsersInActiivty = self.countOfAllUsersInActiivty + 1
user_id, status, status_context = eachRecord
Logger.log('Checking for UserId:{} '.format(user_id))
if status.lower() == 'expired':
Assertion.constructAssertion(False, 'Getting status For users as Expired ,Active Time has crossed / Please check manually', verify=True)
self.countOfExpiredUserInActivity = self.countOfExpiredUserInActivity + 1
elif status.lower() == 'executing':
Logger.log('UserId :{} is marked as Executing in activity Context history')
self.countOfExecutingUsers = self.countOfExecutingUsers + 1
elif status.lower() == 'skipped':
Logger.log('UserId :{} is marked as Skipped in activity Context history , user is control user with status Context :{}'.format(user_id, status_context))
self.countOfControlUserInActivity = self.countOfControlUserInActivity + 1
elif status.lower() == 'error':
Logger.log('UserId :{} is marked as Error in activity Context history with status Context :{},checking in Skipped recipient'.format(user_id, status_context))
if status_context in ['User Does not have any mobile']:
Logger.log('User Got Error From Temporal Engine as User Does not have any mobile')
self.countOfErrorUserInActivityFromTemporal = self.countOfErrorUserInActivityFromTemporal + 1
else:
self.countOfErrorUserInActivity = self.countOfErrorUserInActivity + 1
Assertion.constructAssertion(self.skippedDetails[user_id] == status_context, 'In Skipped Recipient user :{} got skipped due to :{} and in tempoaral due to :{}'.format(user_id, self.skippedDetails[user_id], status_context))
elif status.lower() == 'executed':
Logger.log('UserId :{} is marked as Executed in activity Context history, checking with Inboxes Table'.format(user_id))
self.countofExecutedUserInActivity = self.countofExecutedUserInActivity + 1
Assertion.constructAssertion(user_id in self.inboxDetails, 'userId :{} found in Inboxes'.format(user_id))
else:
Assertion.constructAssertion(False, 'New Status type :{} , add in Automation'.format(status))
Assertion.constructAssertion(False, 'In Activity Context History, Total Number of Users are :{} of which Expired Users are :{}, Executing Users are:{},Skipped(Control) Users are :{},Error Generated From Temporal Engine :{}, Error From Veneno/SkippedRecipient :{}, Executed Users are:{}'.format(self.countOfAllUsersInActiivty, self.countOfExpiredUserInActivity, self.countOfExecutingUsers, self.countOfControlUserInActivity, self.countOfErrorUserInActivityFromTemporal, self.countOfErrorUserInActivity, self.countofExecutedUserInActivity), verify=True)
if self.numberOfUsers == self.countOfExpiredUserInActivity:
Assertion.constructAssertion(False, 'All Users got Expried')
if self.countOfExecutingUsers == 0 :
Assertion.constructAssertion(self.countofExecutedUserInActivity == self.numberOfExecutedUsers, 'Executing Count is 0 , Executed Count :{} and in Inboxes User Count :{}'.format(self.countofExecutedUserInActivity, self.numberOfExecutedUsers))
else:
Assertion.constructAssertion(self.countofExecutedUserInActivity <= self.numberOfExecutedUsers, 'Executing Count is {} , Executed Count :{} and in Inboxes User Count :{}'.format(self.countOfExecutingUsers, self.countofExecutedUserInActivity, self.numberOfExecutedUsers))
Assertion.constructAssertion(self.countOfErrorUserInActivity == self.numberOfSkippedUsers , 'Count of Error Users in Activity :{} and number Of Skipped Recipeints :{}'.format(self.countOfErrorUserInActivity , self.numberOfSkippedUsers))
Assertion.constructAssertion(self.countOfControlUserInActivity == self.numberOfControlUsers, 'NumberOfControlUsers Check :{}'.format(self.countOfControlUserInActivity))
self.assertpercentageOfUsersGotExecuting()
except Exception, exp:
raise Exception('Activity Context History Failure :{}'.format(exp))
def validateDBForTemplate(self, channel, templateName):
if channel == 'Mobile Push': channel = 'MOBILEPUSH'
try:
if templateName != '':
templateJson = DBCallsCampaigns.getTemplateDetails(
channel, templateName)
Assertion.constructAssertion(
len(templateJson) == 1,
'With Name :{} there is only 1 active template in this org'
.format(templateName))
else:
Assertion.constructAssertion(
False,
'TemplateName is blank , not able to check in Mongo',
verify=True)
except Exception, exp:
raise Exception('MongoException :{}'.format(exp))
def verifyCampaignCreation(self, campaignName):
Logger.log(
'Verifying Campaign Creation with Campaign Name Text On Overview Page'
)
self.waitForElement(self.txt_verfiy_campaignNameOnOverview_id)
if campaignName[:10] in self.getElement(
self.txt_verfiy_campaignNameOnOverview_id).text:
campaignId = DBCallsCampaigns.getCampaignIdFromCampaignName(
campaignName)
constant.config['campaign'].update({
'name': campaignName,
'id': campaignId
})
Logger.log('Campaign Info Set as :', constant.config['campaign'])
return True
else:
Assertion.constructAssertion(
False, 'Campaign Name Not Displayed on Overview Page')
def verifyAuthorizeCampaignPreviewAndTest(self, channel, campaignId):
try:
Logger.log(
'verifyAuthorizeCampaignPreviewAndTest woth channel :{} and campaignId :{}'
.format(channel, campaignId))
actualMessageId = dbCallsMessage.getMessageQueueIdForPreviewTest(
campaignId)[0]
cdResult = DBCallsCampaigns.getCommunicationDetailsForPreviewAndTest(
channel)
Assertion.constructAssertion(
cdResult['state'] == 'CLOSED',
'Communication Details state is closed')
Assertion.constructAssertion(
str(cdResult['message_queue_id']) == str(actualMessageId),
'Actual MessageId :{} and in CD MessageId :{}'.format(
actualMessageId, cdResult['message_queue_id']))
except Exception, exp:
raise Exception('DB Validation Exception :{}'.format(exp))
def verifyAuthorizeCampaign(self,
campaignId,
groupVersionId,
scheduleType='',
listName=None):
if scheduleType.lower() == 'recurring':
lists = listPage(self.driver, newFilterEnabled=True)
groupVersionId = lists.getNewGroupVersionForList(
campaignId, listName)
try:
actualMessageId = self.getMessageIdForExecutedCampaign(
campaignId, groupVersionId)
cdResult = DBCallsCampaigns.getCommunicationDetailsWithListDetails(
campaignId, groupVersionId)
Assertion.constructAssertion(
cdResult['state'] == 'CLOSED',
'Communication Details state is closed')
Assertion.constructAssertion(
str(cdResult['message_queue_id']) == str(actualMessageId),
'Actual MessageId :{} and in CD MessageId :{}'.format(
actualMessageId, cdResult['message_queue_id']))
except Exception, exp:
raise Exception('DB Validation Exception :{}'.format(exp))
class BaseState():
@staticmethod
def initializeConstants(args):
module = constant.config['module'] = args.module.lower()
runId = args.runId
collectOnly = constant.config['collectOnly'] = args.collectOnly
tcFilter = args.tcFilter
cluster = constant.config['cluster'] = args.cluster.lower()
if collectOnly:
if 'cluster' in args.cluster.lower():
cluster = constant.config['cluster'] = 'nightly'
constant.config['campaignId'] = 1
if module.lower() == 'nsadmin':
if tcFilter != '':
tcFilter += ' and'
if cluster.lower() in ['nightly', 'staging']:
tcFilter += ' not Prod'
else:
tcFilter += ' Prod and ' + str(cluster.title())
if args.prodEmail1 != '':
constant.prodNumbers['prodEmail1'] = args.prodEmail1
constant.config['tcFilter'] = tcFilter
if not module in runId.lower():
runId = module.title() + '_' + runId
msg = 'Initializing Suite for Cluster: ' + cluster + ' Module: ' + module
if tcFilter != '':
msg += ' Filter: ' + tcFilter
print msg
constant.config['runId'] = runId
constant.config['logDir'] = constant.logDirectory + runId
constant.config['currentTimestamp'] = datetime.today().strftime('%Y-%m-%d %H:%M:%S')
constant.config.update(constant.portsUsed[cluster])
constant.config.update(constant.clusterUrl[cluster])
constant.config.update(constant.auth[cluster])
constant.config.update(constant.intouchEndpoints)
constant.config.update(constant.endpoints)
BaseState.updateOrgDetails(module)
if module in ['iris','irisv2', 'veneno', 'darknight', 'campaign_shard', 'campaignsui', 'social']:
constant.config.update(constant.wechatMobilepush[cluster])
if constant.config['cluster'] in ['nightly', 'staging', 'china']: constant.config['wecrm_details'] = \
constant.config['wechat']['wecrm_details']
constant.config.update(constant.aryaEndpoints)
constant.config.update({'campaignDefaultObjectCopy': copy.deepcopy(constant.campaignDefaultValues)})
try:
authResponse = auth.authLogin()
if authResponse['cookies'].get_dict() != {}:
constant.config['aryaCookiesDict'] = authResponse['cookies'].get_dict()
constant.config['token'] = authResponse['json']['token']
else:
raise Exception('')
except:
print '------------------------------Arya Cookies Not Set------------------------------'
if module in ['emf', 'peb']:
orgId = constant.config['orgId']
constant.config.update(constant.emfConstants[cluster][orgId])
if module in ['luci', 'veneno', 'social']:
constant.config['requestId'] = 'requestId_' + str(randValues.randomInteger(5))
constant.config['dateTime'] = DracarysHelper.getValueOfDay()
if not collectOnly:
Utils.createFolder(constant.config['logDir'])
Logger.configureLogging(constant.config['logDir'])
if constant.config['os'] != 'windows':
dbHelper.getIntouchShardNameForOrg(module)
dbHelper.buildDBToTunnelPortMapping()
if module == 'veneno' and not collectOnly:
if constant.config['cluster'] == 'nightly': VenenoHelper.updateStartegyForRateLimit()
if module == 'irisv2':
constant.irisGenericValues = {'goalId': '1', 'objectiveId': '1', 'existingUserId': '1',
'existingUserExternalId': '1'}
if module in ['iris', 'veneno', 'campaign_shard', 'campaignsui', 'darknight', 'social']:
constant.config['skipped_errors'] = dbCallsList.getSkippedErrorTypes()
constant.config.update(constant.irisDetails[cluster])
if collectOnly:
constant.irisGenericValues = {'goalId': '1', 'objectiveId': '1', 'existingUserId': '1',
'existingUserExternalId': '1'}
else:
try:
goalId = str(dbCallsCampaign.getValidGoalId())
objectiveId = str(dbCallsCampaign.getValidObjectiveId())
existingUserDetail = dbCallsMessage.getUsersInformation(1)[0]
constant.irisGenericValues = {'goalId': goalId, 'objectiveId': objectiveId,
'existingUserId': existingUserDetail[0],
'existingUserExternalId': existingUserDetail[5]}
except Exception, exp:
constant.irisGenericValues = {'goalId': '1', 'objectiveId': '1', 'existingUserId': '1',
'existingUserExternalId': '1'}
Logger.log(
'Exception :{} occured while setting irisGeneric Values , so setting the values by Default as :{}'.format(
exp, constant.irisGenericValues))
if module == 'campaignsui':
constant.config.update(constant.irisDetails[cluster])
constant.config.update(constant.wechatMobilepush[cluster])
if constant.config['cluster'] in ['nightly', 'staging', 'china']: constant.config['wecrm_details'] = \
constant.config['wechat']['wecrm_details']
constant.config.update({'headlessMode': args.headlessMode})
constant.config.update(constant.campaignuiDetails)
constant.config.update({'apiTesterDB': constant.dbNames[cluster]})
constant.config.update({'shard': DBCallsCampaigns.getShardGettingUsed()})
if collectOnly:
constant.campaignuiUserInfo.update({'loyalty': {'name': 'name', 'email': 'email', 'mobile': 'mobile'}})
else:
fileHandle = FileHelper(constant.userFileMobile)
existingUserDetail = DBCallsCampaigns.getLoyaltyUserInfo(1)[0]
constant.campaignuiUserInfo.update({'loyalty': {'name': existingUserDetail[1],
'email': existingUserDetail[4],
'mobile': existingUserDetail[3]}})
fileHandle.eraseContentFromFile()
fileHandle.appendToFile('mobile,name')
fileHandle.appendToFile(str(existingUserDetail[3]) + ',' + str(existingUserDetail[1]))
if module == 'nsadmin':
constant.config.update(constant.prodNumbers)
constant.config.update({"clusterFileHandle": constant.clusterFileHandle[cluster]})
constant.config.update({"dlrUrl": constant.dlrUrl[cluster]})
if module == 'irisv2':
constant.config.update({'node': copy.deepcopy(constant.node)})
if not collectOnly:
sortesListOfLogFiles = Utils.sorted_ls(constant.logDirectory)
if len(sortesListOfLogFiles) > constant.maxNumberOfLogFiles:
try:
Utils.deleteFolder(constant.logDirectory + '/' + sortesListOfLogFiles[0])
except Exception as e:
Logger.log(str(e))
BaseState.setBaseState()
def assertCommunicationDetails(self):
try:
self.communicationDetailsId, self.bucketId, self.targetType, self.expectedCount, self.overallCount, self.state = DBCallsCampaigns.getCommunicationDetails(self.campaignId)
self.numberOfTestUsers = self.overallCount
self.numberOfControlUsers = self.numberOfUsers - self.numberOfTestUsers
Logger.log('Number Of Test users :{} and number of Control users :{}'.format(self.numberOfTestUsers, self.numberOfControlUsers))
Assertion.constructAssertion(self.state == 'OPENED', 'State of Timeline in CD is :{}'.format(self.state))
Assertion.constructAssertion(self.targetType == 'TIMELINE', 'TargetType for Timeline in CD is :{}'.format(self.targetType))
except Exception, exp:
raise Exception('Communication Details Failure :{}'.format(exp))
def assertUsersInitialized(self):
try:
self.numberOfUsers = DBCallsCampaigns.getUserInitializedInTimeline(self.timelineDB)
Logger.log('Number Of Users in user_initialization_histroy:{}'.format(self.numberOfUsers))
except Exception, exp:
raise Exception('User Initialization History Failure :{}'.format(exp))
def updateTimelineDBAsInactive(self):
DBCallsCampaigns.markCampaignAsInactive(self.configId)
def getTemplateInfo(self):
if self.channel == 'Mobile Push': self.channel = 'MOBILEPUSH'
self.templateInMongo = DBCallsCampaigns.getTemplateDetails(
self.channel, self.templateName)
def getTimelineDetails(self):
try:
self.timelineDB, self.campaignId, self.configId = DBCallsCampaigns.getTimelineDB(self.timelineName)
Logger.log('For Timeline :{} , timelineDB :{} and campaignId :{}'.format(self.timelineName, self.timelineDB, self.campaignId))
except Exception, exp:
raise Exception('GetTimelineDetails Failure :{}'.format(exp))
def otpVerify(self):
otpElement = self.getElement(self.otp_id)
if otpElement != None:
otpValue = DBCallsCampaigns.getOTP()
self.sendKeys(otpValue, self.otp_id)
self.elementClick(self.submit_btn_id)
