def preRequisitesForVenenoLine(testControlType='org'):
userData = []
for eachUser in constant.config['line']['user']:
userData.append('Test,Automation,{}'.format(eachUser['userId']))
campaignResponse, campaignPayload = campaigns.createCampaign({
'name':
'IRIS_' + str(int(time.time() * 100000)),
'goalId':
constant.irisGenericValues['goalId'],
'objectiveId':
constant.irisGenericValues['objectiveId'],
'testControl': {
'type': testControlType.upper(),
'test': 90
}
})
listResponse, listPayload, campaignId = campaignList.createList(
{
'customTagCount': 0,
'name': 'IRIS_LIST_' + str(int(time.time() * 100000))
},
campaignId=campaignResponse['json']['entity']['campaignId'])
addRecipientResponse, addRecipientPayload = campaignList.addRecipient(
{
'data': userData,
'schema': 'firstName,lastName,userId'
},
campaignId,
listResponse['json']['entity']['listId'],
newUser=False)
responseCoupon, payloadCoupon, campaignId = coupons.createCoupons(
campaignId=campaignId)
return {
'campaignName':
campaignPayload['name'],
'campaignId':
campaignId,
'listId':
listResponse['json']['entity']['listId'],
'voucherId':
responseCoupon['json']['entity']['voucherSeriesId'],
'strategy':
None,
'programeId':
None,
'allocationStrategyId':
None,
'expiryStrategyId':
None,
'bucketId':
dbCallsList.getGroupVersionDetailsWithGroupId(
listResponse['json']['entity']['listId'])['TEST']['bucket_id'],
'groupVersionResult':
dbCallsList.getGroupVersionDetailsWithGroupId(
listResponse['json']['entity']['listId']),
'groupName':
listPayload['name']
}
def setup_class(self):
if 'storeType' in constant.payload['createmessage']:
constant.payload['createmessage'].pop('storeType')
campaignResponse, campaignPayload = campaigns.createCampaign({
'name':
'IRIS_' + str(int(time.time() * 100000)),
'goalId':
constant.irisGenericValues['goalId'],
'objectiveId':
constant.irisGenericValues['objectiveId'],
'testControl': {
'type': 'ORG',
'test': 90
}
})
listResponse, listPayload, campaignId = campaignList.createList(
{
'customTagCount': 1,
'name': 'IRIS_LIST_' + str(int(time.time() * 100000))
},
campaignId=campaignResponse['json']['entity']['campaignId'])
addRecipientResponse, addRecipientPayload = campaignList.addRecipient(
{},
campaignId,
listResponse['json']['entity']['listId'],
'mobile',
10,
1,
newUser=False)
responseCoupon, payloadCoupon, campaignId = coupons.createCoupons(
campaignId=campaignId)
self.campaignId = campaignId
self.listId = listResponse['json']['entity']['listId']
self.voucherId = responseCoupon['json']['entity']['voucherSeriesId']
self.strategy = construct.constructStrategyIds()
self.programeId = self.strategy['programeId']
self.allocationStrategyId = self.strategy['allocationStrategyId']
self.expiryStrategyId = self.strategy['expirationStrategyId']
self.bucketId = dbCallsList.getGroupVersionDetailsWithGroupId(
listResponse['json']['entity']['listId'])['TEST']['bucket_id']
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(
listResponse['json']['entity']['listId'])
Logger.log(
'Veneno Setup Details --> campaignId:{} ,ListId:{} ,voucherId:{} ,strategy:{}, bucketId:{}, groupVersionDetail:{}'
.format(self.campaignId, self.listId, self.voucherId,
self.strategy, self.bucketId, self.groupVersionResult))
def setup_class(self):
Logger.logSuiteName(str(self).split('.')[-1])
nsPort = constant.config['nsMasterPort']
self.nsHelper = NSAdminHelper(constant.config['orgId'], 'SMS')
luciPort = constant.config['luciPort'].next()
self.luciObj = LuciThrift(luciPort)
self.constructObj = LuciObject()
constant.config['requestId'] = 'requestId_IRIS_LUCI'
createListresponse, createListPayload, campaignId = campaignList.createList({'customTagCount':0, 'name':'IRIS_LIST_' + str(int(time.time() * 100000))}, campaignType=['LIVE', 'ORG', 'List', 'TAGS', 0])
campaignList.assertCreateList(createListresponse, 200)
groupVersionDetailResult, bucketId = campaignList.assertCreateListDbCalls(createListresponse['json']['entity']['listId'], createListPayload, 'ORG')
Logger.log('GroupVersionId : {}, bucketId : {}'.format(groupVersionDetailResult, bucketId))
addRecipientResponse, addRecipientPayload = campaignList.addRecipient({}, campaignId, createListresponse['json']['entity']['listId'], 'mobile', 10, 0, newUser=False)
campaignList.assertAddRecipient(addRecipientResponse, 200)
campaignList.assertAddRecipientDbCalls(addRecipientResponse, addRecipientPayload, createListresponse, campaignId, bucketId, {'TEST':groupVersionDetailResult['TEST'], 'CONTROL':groupVersionDetailResult['CONTROL']}, 'mobile')
self.bucketId = bucketId
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(createListresponse['json']['entity']['listId'])
responseCoupon, payloadCoupon, campaignId = coupons.createCoupons(campaignId=campaignId)
self.strategy = construct.constructStrategyIds()
self.programeId = self.strategy['programeId']
self.allocationStrategyId = self.strategy['allocationStrategyId']
self.expiryStrategyId = self.strategy['expirationStrategyId']
if 'errors' not in responseCoupon['json']:
self.voucherId = responseCoupon['json']['entity']['voucherSeriesId']
else:
self.voucherId = dbCallsCoupons.getVoucherSeriesIdUsingCampaignId(campaignId)
self.campaignId = campaignId
self.listId = createListresponse['json']['entity']['listId']
Logger.log('Using CampaignId : {} , listId : {} for Execution of Create Message'.format(self.campaignId, self.listId))
def test_veneno_skippedUser_unsubscribed_ProdSanity(self):
originalListId = self.listId
originalBucketId = self.bucketId
originalGroupVersionDetail = self.groupVersionResult
try:
messagePayloadToUpdate = {
'senderDetails':{
'domainGatewayMapId':constant.config['message_senders']['domainGatewayMapId'],
'gsmSenderId':constant.config['message_senders']['gsmSenderId'],
'useSystemDefaults':False,
'cdmaSenderId':constant.config['message_senders']['cdmaSenderId']
},
'message' : 'This Message is Going to Skip Due Unsubscribe User : {{optout}}'
}
cusObj = InTouchAPI(Customer.Add())
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList({'name': 'IRIS_LIST_' + str(int(time.time() * 100000)), 'recipients':{'dataSource':'CSV', 'schema':'firstName,lastName,mobile', 'data':['TestX,AutomationX,{}'.format(cusObj.params['mobile'])]}}, campaignId=self.campaignId)
self.listId = mergeListresponse['json']['entity']['listId']
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(mergeListresponse['json']['entity']['listId'])
self.bucketId = self.groupVersionResult['TEST']['bucket_id']
unsubscribeObj = InTouchAPI(Customer.unsubscribe(body={'root':{'subscription':{'mobile':cusObj.params['mobile']}}}))
if unsubscribeObj.status_code == 200:
messageResponse, messagePayload = campaignMessage.createMessage(self, payloadData=messagePayloadToUpdate)
authorizeResponse = authorize.makeAuthorizeRequest(self.campaignId, messageResponse['json']['entity']['messageId'])
authorizeResult = self.getAuthorizeResultBody(self.campaignId, self.listId, self.groupVersionResult, self.bucketId, self.voucherId, self.strategy, messagePayload, str(messageResponse['json']['entity']['messageId']), authorizeResponse)
communicationDetailId , communicationDetailBucketId, communicationDetailExpectedCount = authorize.assertMessageQueueAndGetCommunicationDetailsForReferenceMessageQueueId(self.campaignId, self.groupVersionResult['TEST']['id'], authorizeResult['messageId'])
VenenoDBAssertion(self.campaignId, 'SMS', communicationDetailId, self.groupVersionResult['TEST']['customer_count'], self.groupVersionResult['TEST']['id'], authorizeResult['payload']['message'], testControlType='skip', skippedReasons=['Captured mobile for user seems to be unsubscribed']).check()
authorize.assertUserPresenceInSkippedTable(communicationDetailId, communicationDetailBucketId, constant.config['skipped_errors']['UNSUBSCRIBED'], 'Captured mobile for user seems to be unsubscribed')
else :
raise Exception('Not Able To Unsubscribe using Intouch Call')
except Exception, exp:
Assertion.constructAssertion(False, exp)
def validateErrorStatusAsync(groupId):
groupDetailsVersionInfo = dbCallsList.getGroupVersionDetailsWithGroupId(
groupId, expectedStatus='ERROR')
Assertion.constructAssertion(
groupDetailsVersionInfo['TEST']['status'] == 'ERROR',
'Mark Error Status :{} and Expected :{} in GVD'.format(
groupDetailsVersionInfo['TEST']['status'], 'ERROR'))
def test_veneno_skippedUser_invalidMobile(self):
originalListId = self.listId
originalBucketId = self.bucketId
originalGroupVersionDetail = self.groupVersionResult
try:
messagePayloadToUpdate = {
'senderDetails':{
'domainGatewayMapId':constant.config['message_senders']['domainGatewayMapId'],
'gsmSenderId':constant.config['message_senders']['gsmSenderId'],
'useSystemDefaults':False,
'cdmaSenderId':constant.config['message_senders']['cdmaSenderId']
},
'message' : 'This Message is Going to Skip Due Invalid User : {{optout}}'
}
invalidUserData = 'ndncFirstName,ndncLastName,{}'.format(dbCallsMessage.getInvalidUserMobileNumber()[0])
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList({'name': 'IRIS_LIST_' + str(int(time.time() * 100000)), 'recipients':{'dataSource':'CSV', 'schema':'firstName,lastName,mobile', 'data':[invalidUserData]}}, campaignId=self.campaignId)
self.listId = mergeListresponse['json']['entity']['listId']
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(mergeListresponse['json']['entity']['listId'])
self.bucketId = self.groupVersionResult['TEST']['bucket_id']
messageResponse, messagePayload = campaignMessage.createMessage(self, payloadData=messagePayloadToUpdate)
authorizeResponse = authorize.makeAuthorizeRequest(self.campaignId, messageResponse['json']['entity']['messageId'])
authorizeResult = self.getAuthorizeResultBody(self.campaignId, self.listId, self.groupVersionResult, self.bucketId, self.voucherId, self.strategy, messagePayload, str(messageResponse['json']['entity']['messageId']), authorizeResponse)
communicationDetailId , communicationDetailBucketId, communicationDetailExpectedCount = authorize.assertMessageQueueAndGetCommunicationDetailsForReferenceMessageQueueId(self.campaignId, self.groupVersionResult['TEST']['id'], authorizeResult['messageId'])
VenenoDBAssertion(self.campaignId, 'SMS', communicationDetailId, self.groupVersionResult['TEST']['customer_count'], self.groupVersionResult['TEST']['id'], authorizeResult['payload']['message'], testControlType='skip', skippedReasons=['Captured mobile for user seems to be invalid']).check()
authorize.assertUserPresenceInSkippedTable(communicationDetailId, communicationDetailBucketId, constant.config['skipped_errors']['INVALID_MOBILE'], 'Captured mobile for user seems to be invalid')
except Exception, exp:
Assertion.constructAssertion(False, exp)
def test_veneno_skippedUser_noCouponForUser_ProdSanity(self):
try:
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList(campaignId=self.campaignId, numberOfUsers=2)
self.listId = mergeListresponse['json']['entity']['listId']
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(mergeListresponse['json']['entity']['listId'])
self.bucketId = self.groupVersionResult['TEST']['bucket_id']
self.couponConfigChange({'max_create':1,'max_redeem':1})
time.sleep(70)
messagePayloadToUpdate = {
'incentive':{
'type':'COUPONS',
'voucherSeriesId':self.voucherId
},
'senderDetails':{
'domainGatewayMapId':constant.config['message_senders']['domainGatewayMapId'],
'gsmSenderId':constant.config['message_senders']['gsmSenderId'],
'useSystemDefaults':False,
'cdmaSenderId':constant.config['message_senders']['cdmaSenderId']
},
'message' : 'This Message is Going to Skip Due to number of Issued coupon is 1 and users are 2 : {{voucher}} {{optout}}'
}
messageResponse, messagePayload = campaignMessage.createMessage(self, payloadData=messagePayloadToUpdate)
authorizeResponse = authorize.makeAuthorizeRequest(self.campaignId, messageResponse['json']['entity']['messageId'])
authorizeResult = self.getAuthorizeResultBody(self.campaignId, self.listId, self.groupVersionResult, self.bucketId, self.voucherId, self.strategy, messagePayload, str(messageResponse['json']['entity']['messageId']), authorizeResponse)
communicationDetailId , communicationDetailBucketId, communicationDetailExpectedCount = authorize.assertMessageQueueAndGetCommunicationDetailsForReferenceMessageQueueId(self.campaignId, self.groupVersionResult['TEST']['id'], authorizeResult['messageId'])
VenenoDBAssertion(self.campaignId, 'SMS', communicationDetailId, self.groupVersionResult['TEST']['customer_count'], self.groupVersionResult['TEST']['id'], authorizeResult['payload']['message'], testControlType='skip', skippedReasons=['max create for series exceeded']).check()
authorize.assertUserPresenceInSkippedTable(communicationDetailId, communicationDetailBucketId, constant.config['skipped_errors']['MAX_COUPON_ISSUAL_PER_SERIES_EXCEEDED'], 'max create for series exceeded')
except Exception, exp:
Assertion.constructAssertion(False, exp)
def assertAddRecipientDbCalls(addRecipientresponse, payload,
createListResponse, campaignId, bucketId,
groupVersionDetail, userType):
userType = str(userType.split(',')[0])
hashId = ''
if userType.lower() == 'mobile':
hashId = dbCallsList.getHashLookUp()['INSTORE__DEFAULT__MOBILE']
elif userType.lower() == 'email':
hashId = dbCallsList.getHashLookUp()['INSTORE__DEFAULT__EMAIL']
testControlType = campaignList.assertTestControlUsers(
addRecipientresponse, payload, campaignId, userType)
campaignList.assertGroupVersionDetail(
dbCallsList.getGroupVersionDetailsWithGroupId(
createListResponse['json']['entity']['listId']),
testConstrolType=testControlType,
expectedTestUsers=int(
addRecipientresponse['json']['entity']['test']),
expectedControlUsers=int(
addRecipientresponse['json']['entity']['control']))
if addRecipientresponse['json']['entity']['test'] > 0:
campaignList.assertCampaignGroupRecipient(
addRecipientresponse, 'test', bucketId,
groupVersionDetail['TEST']['id'], hashId, 'SUBSCRIBED')
if 'customTag' in payload['schema']:
campaignList.assertCampaignGroupRecipientCustomTag(
payload, addRecipientresponse, bucketId,
groupVersionDetail['TEST']['id'])
if addRecipientresponse['json']['entity']['control'] > 0:
campaignList.assertCampaignGroupRecipient(
addRecipientresponse, 'control', bucketId,
groupVersionDetail['CONTROL']['id'], hashId, 'SUBSCRIBED')
def constructFilterData(data):
data.update({
'groupDetails':
dbCallsList.getGroupDetailsWithListName(data['groupLabel'],
data['uuid'])
})
data.update({
'groupVersionDetails':
dbCallsList.getGroupVersionDetailsWithGroupId(
data['groupDetails']['id'])
})
camapignGroupRecipientsData = {
'TEST':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
data['groupVersionDetails']['TEST']['bucket_id'],
data['groupVersionDetails']['TEST']['id'])
}
if 'CONTROL' in data['groupVersionDetails']:
camapignGroupRecipientsData.update({
'CONTROL':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
data['groupVersionDetails']['CONTROL']['bucket_id'],
data['groupVersionDetails']['CONTROL']['id'])
})
data.update({'campaignGroupRecipients': camapignGroupRecipientsData})
Logger.log(
'Constructed Filter Data , Returned Finally To Test Class :{}'.
format(data))
return data
def test_veneno_skippedUser_noStore_ProdSanity(self, storeType, errorType, errorMessage):
originalListId = self.listId
originalBucketId = self.bucketId
originalGroupVersionDetail = self.groupVersionResult
try:
messagePayloadToUpdate = {
'senderDetails':{
'domainGatewayMapId':constant.config['message_senders']['domainGatewayMapId'],
'gsmSenderId':constant.config['message_senders']['gsmSenderId'],
'useSystemDefaults':False,
'cdmaSenderId':constant.config['message_senders']['cdmaSenderId']
},
'message' : 'This Message is Going to Skip Due to Store Name Tag used :{{store_name}} {{optout}}',
'storeType' : storeType
}
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList({}, campaignId=self.campaignId)
self.listId = mergeListresponse['json']['entity']['listId']
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(mergeListresponse['json']['entity']['listId'])
self.bucketId = self.groupVersionResult['TEST']['bucket_id']
messageResponse, messagePayload = campaignMessage.createMessage(self, payloadData=messagePayloadToUpdate)
authorizeResponse = authorize.makeAuthorizeRequest(self.campaignId, messageResponse['json']['entity']['messageId'])
authorizeResult = self.getAuthorizeResultBody(self.campaignId, self.listId, self.groupVersionResult, self.bucketId, self.voucherId, self.strategy, messagePayload, str(messageResponse['json']['entity']['messageId']), authorizeResponse)
communicationDetailId , communicationDetailBucketId, communicationDetailExpectedCount = authorize.assertMessageQueueAndGetCommunicationDetailsForReferenceMessageQueueId(self.campaignId, self.groupVersionResult['TEST']['id'], authorizeResult['messageId'])
VenenoDBAssertion(self.campaignId, 'SMS', communicationDetailId, self.groupVersionResult['TEST']['customer_count'], self.groupVersionResult['TEST']['id'], authorizeResult['payload']['message'], testControlType='skip', skippedReasons=[errorMessage]).check()
authorize.assertUserPresenceInSkippedTable(communicationDetailId, communicationDetailBucketId, errorType, errorMessage)
except Exception, exp:
Assertion.constructAssertion(False, exp)
def test_campaignShardThrift_AudienceGroup_Async_CreateAudience_Reload_Sanity(
self, audienceType):
createAudienceRequest = campaignShardObject.createAudienceRequest(
audienceType=audienceType)
audiencecGroupEntity = self.connObj.createAudienceGroup(
createAudienceRequest).__dict__
createAudienceWithGroupId = campaignShardObject.createAudienceRequest(
{'groupId': audiencecGroupEntity['id']}, audienceType=audienceType)
createAudienceResponse = self.connObj.createAudience(
createAudienceWithGroupId).__dict__
groupDetailsVersionInfo = dbCallsList.getGroupVersionDetailsWithGroupId(
audiencecGroupEntity['id'])
s3InfoForUsedList = CampaignShardHelper.getS3Info(
createAudienceResponse['uuId'])
thriftCampaignGroup = lambda campaignTargetType: campaignShardObject(
).CampaignGroup({
'groupId':
audiencecGroupEntity['id'],
'groupLabel':
createAudienceResponse['label'],
'params':
str(),
'campaignGroupType':
'FILTER_BASED',
'campaignTargetType':
'TEST',
'customerCount':
groupDetailsVersionInfo['TEST']['customer_count'],
'uuId':
createAudienceResponse['uuId'],
'versionNumber':
1,
's3Path':
s3InfoForUsedList['response']['data']['s3Path'],
's3Headers':
s3InfoForUsedList['response']['data']['s3Header'],
's3BucketTag':
s3InfoForUsedList['response']['data']['s3Path'].split('/')[2]
})
for eachTargetType in ['TEST']:
if not self.connObj.reloadGroup(
thriftCampaignGroup(eachTargetType)):
Logger.log(
'For TargetType :{} , reload was unsuccesfull'.format(
eachTargetType))
userPayloadInfo = CampaignShardHelper.loyaltyUserDataConstructHelper()
CampaignShardDBAssertion(99999,
'org',
'FILTER_BASED',
createAudienceResponse['label'],
audiencecGroupEntity['id'],
'firstName,lastName,mobile',
userPayloadInfo,
newFlow=True).check()
def test_veneno_skippedUser_nonLoyaltyCustomer(self):
originalListId = self.listId
originalBucketId = self.bucketId
originalGroupVersionDetail = self.groupVersionResult
try:
messagePayloadToUpdate = {
'senderDetails': {
'domainGatewayMapId':
constant.config['message_senders']['domainGatewayMapId'],
'gsmSenderId':
constant.config['message_senders']['gsmSenderId'],
'useSystemDefaults':
False,
'cdmaSenderId':
constant.config['message_senders']['cdmaSenderId']
},
'message':
'This Message is Going to Skip Due to Loyalty Tag used :{{loyalty_points}} {{optout}}'
}
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList(
{}, campaignId=self.campaignId)
self.listId = mergeListresponse['json']['entity']['listId']
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(
mergeListresponse['json']['entity']['listId'])
self.bucketId = self.groupVersionResult['TEST']['bucket_id']
messageResponse, messagePayload = campaignMessage.createMessage(
self, payloadData=messagePayloadToUpdate)
authorizeResponse = authorize.makeAuthorizeRequest(
self.campaignId,
messageResponse['json']['entity']['messageId'])
authorizeResult = self.getAuthorizeResultBody(
self.campaignId, self.listId, self.groupVersionResult,
self.bucketId, self.voucherId, self.strategy, messagePayload,
str(messageResponse['json']['entity']['messageId']),
authorizeResponse)
communicationDetailId, communicationDetailBucketId, communicationDetailExpectedCount = authorize.assertMessageQueueAndGetCommunicationDetailsForReferenceMessageQueueId(
self.campaignId, self.groupVersionResult['TEST']['id'],
authorizeResult['messageId'])
VenenoDBAssertion(
self.campaignId,
'SMS',
communicationDetailId,
self.groupVersionResult['TEST']['customer_count'],
self.groupVersionResult['TEST']['id'],
authorizeResult['payload']['message'],
skippedReasons=['Users are not registered in loyalty program'
]).check()
authorize.assertUserPresenceInSkippedTable(
communicationDetailId, communicationDetailBucketId,
constant.config['skipped_errors']['NON_LOYALTY_CUSTOMER'],
'Users are not registered in loyalty program')
except Exception, exp:
Assertion.constructAssertion(False, exp)
def validateBucketIdWhenBucketUpdated(groupId, expectedBucketDetails):
Logger.log(
'Checking for Bucket Id with groupId :{} and expectedBucketDetails:'
.format(groupId, expectedBucketDetails))
groupVersionDetailslatest = dbCallsList.getGroupVersionDetailsWithGroupId(
groupId)
latestBucketId = groupVersionDetailslatest['TEST']['bucket_id']
Assertion.constructAssertion(
int(latestBucketId) == expectedBucketDetails,
'Expected Bucket Id :{} but actually in DB :{}'.format(
expectedBucketDetails, latestBucketId))
def validateGroupStatusAsync_database_groupVersionDetails(
audiencecGroupEntity, status, audienceType):
groupDetailsVersionInfo = dbCallsList.getGroupVersionDetailsWithGroupId(
audiencecGroupEntity['id'])
Assertion.constructAssertion(
groupDetailsVersionInfo['TEST']['status'] == status,
'In Status :{} and Expected :{} in GVD'.format(
groupDetailsVersionInfo['TEST']['status'], status))
if 'CONTROL' in groupDetailsVersionInfo:
Assertion.constructAssertion(
True,
'For createorUpdateGroup Call CONTROL entry should be present in new Flow As Well'
)
def createListForSocial(campaignInfo,
campaignType,
numberOfUsers=5,
newUser=False):
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList(
{},
campaignId=campaignInfo[campaignType],
campaignType=['LIVE', campaignType, 'List', 'TAGS', 0],
userType='mobile',
numberOfUsers=numberOfUsers,
numberOfCustomTags=0,
newUser=newUser)
return dbCallsList.getGroupVersionDetailsWithGroupId(
mergeListresponse['json']['entity']
['listId'])['TEST']['id'], mergeListPayload['name']
def preRequisitesForVeneno(testControlType='org'):
if 'storeType' in constant.payload['createmessage']:
constant.payload['createmessage'].pop('storeType')
campaignResponse, campaignPayload = campaigns.createCampaign({
'name':
'IRIS_' + str(int(time.time() * 100000)),
'goalId':
constant.irisGenericValues['goalId'],
'objectiveId':
constant.irisGenericValues['objectiveId'],
'testControl': {
'type': testControlType.upper(),
'test': 90
}
})
listResponse, listPayload, campaignId = campaignList.createList(
{
'customTagCount': 1,
'name': 'IRIS_LIST_' + str(int(time.time() * 100000))
},
campaignId=campaignResponse['json']['entity']['campaignId'])
addRecipientResponse, addRecipientPayload = campaignList.addRecipient(
{},
campaignId,
listResponse['json']['entity']['listId'],
'mobile,email',
10,
1,
newUser=False)
responseCoupon, payloadCoupon, campaignId = coupons.createCoupons(
campaignId=campaignId)
strategyDict = construct.constructStrategyIds()
groupVersionDict = dbCallsList.getGroupVersionDetailsWithGroupId(
listResponse['json']['entity']['listId'])
return {
'campaignId': campaignId,
'listId': listResponse['json']['entity']['listId'],
'voucherId': responseCoupon['json']['entity']['voucherSeriesId'],
'strategy': strategyDict,
'programeId': strategyDict['programeId'],
'allocationStrategyId': strategyDict['allocationStrategyId'],
'expiryStrategyId': strategyDict['expirationStrategyId'],
'bucketId': groupVersionDict['TEST']['bucket_id'],
'groupVersionResult': groupVersionDict,
'groupName': listPayload['name']
}
def test_veneno_inboxUser_GroupTagPresent(self):
messagePayloadToUpdate = {
'senderDetails': {
'domainGatewayMapId':
constant.config['message_senders']['domainGatewayMapId'],
'gsmSenderId':
constant.config['message_senders']['gsmSenderId'],
'useSystemDefaults':
False,
'cdmaSenderId':
constant.config['message_senders']['cdmaSenderId']
},
'message':
'This Message is Going to Inbox Due to group Tag Present in List :{{group_tag_1}} {{optout}}'
}
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList(
{
'groupTags':
['TestAutomation_GroupTag1', 'TestAutomation_GroupTag2']
},
campaignId=self.campaignId)
self.listId = mergeListresponse['json']['entity']['listId']
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(
mergeListresponse['json']['entity']['listId'])
self.bucketId = self.groupVersionResult['TEST']['bucket_id']
messageResponse, messagePayload = campaignMessage.createMessage(
self, payloadData=messagePayloadToUpdate)
authorizeResponse = authorize.makeAuthorizeRequest(
self.campaignId, messageResponse['json']['entity']['messageId'])
authorizeResult = self.getAuthorizeResultBody(
self.campaignId, self.listId, self.groupVersionResult,
self.bucketId, self.voucherId, self.strategy, messagePayload,
str(messageResponse['json']['entity']['messageId']),
authorizeResponse)
communicationDetailId, communicationDetailBucketId, communicationDetailExpectedCount = authorize.assertMessageQueueAndGetCommunicationDetailsForReferenceMessageQueueId(
self.campaignId, self.groupVersionResult['TEST']['id'],
authorizeResult['messageId'])
VenenoDBAssertion(self.campaignId, 'SMS', communicationDetailId,
self.groupVersionResult['TEST']['customer_count'],
self.groupVersionResult['TEST']['id'],
authorizeResult['payload']['message']).check()
authorize.assertUserPresenceInNsAdminTable(
communicationDetailId, communicationDetailBucketId, 1)
def assertCreateListDbCalls(listId,
payload,
testControlType,
listType='CAMPAIGN_USERS',
expectedTestUsers=0,
expectedControlUsers=0):
Logger.log('ListId Recieved to Validate is :', listId)
Logger.log('Payload to Assert With :', payload)
groupDetailResult = dbCallsList.getGroupDetailsWithListId(listId)
groupVersionDetailResult = dbCallsList.getGroupVersionDetailsWithGroupId(
listId)
campaignList.assertGroupDetail(groupDetailResult, payload, listType)
campaignList.assertGroupVersionDetail(groupVersionDetailResult,
expectedTestUsers,
expectedControlUsers,
testConstrolType=testControlType)
return groupVersionDetailResult, groupVersionDetailResult['TEST'][
'bucket_id']
def assertCreateMessageDbCalls(messageId, campaignId, payload):
messageQueueResult = dbCallsMessage.getMessageQueueFromMessageId(messageId, payload)
Assertion.constructAssertion(int(messageQueueResult['id']) == int(messageId), 'Matching MessageId with DBResult Id')
Assertion.constructAssertion(int(messageQueueResult['campaign_id']) == int(campaignId), 'CampaignId Passed :{} and in MessageQueue :{}'.format(campaignId, messageQueueResult['campaign_id']))
Assertion.constructAssertion(int(messageQueueResult['group_id']) == int(dbCallsList.getGroupVersionDetailsWithGroupId(payload['listId'])['TEST']['id']), 'GroupVersionId passed :{} and in MessageQueue:{}'.format(payload['listId'], messageQueueResult['group_id']))
Assertion.constructAssertion(str(messageQueueResult['status']) == 'OPEN', 'Matching Status should always be open')
if 'message' in payload:
Assertion.constructAssertion(messageQueueResult['param']['message'] == payload['message'], 'Message Queue Result:{} and payload Message is :{}'.format(str(messageQueueResult['param']['message']), str(payload['message'])))
Assertion.constructAssertion(int(messageQueueResult['Approved']) == 0, 'Matching Approved in Message Queue as 0')
if 'sms' in payload['channel'].lower():
if 'targetNdnc' in payload['additionalInfo'] :Assertion.constructAssertion((json.loads(messageQueueResult['default_arguments'])['sendToNdnc'] != 'false') == payload['additionalInfo']['targetNdnc'], 'Matching Default Argument with Additional Info for NDNC')
if 'useTinyUrl' in payload['additionalInfo'] :Assertion.constructAssertion((json.loads(messageQueueResult['default_arguments'])['useTinyUrl'] != 'false') == payload['additionalInfo']['useTinyUrl'], 'Matching Default Argument with Additional Info for useTinyUrl')
# if 'storeType' in payload : Assertion.constructAssertion(str(json.loads(messageQueueResult['default_arguments'])['store_type']) == str(payload['storeType']).lower(), 'Matching Default Argument with storeType')
Assertion.constructAssertion(str(json.loads(messageQueueResult['default_arguments'])['sender_cdma']) == str(payload['senderDetails']['cdmaSenderId']), 'Matching Default Argument with storeType')
Assertion.constructAssertion(str(json.loads(messageQueueResult['default_arguments'])['sender_gsm']) == str(payload['senderDetails']['gsmSenderId']), 'Matching Default Argument with storeType')
if 'domainGatewayMapId' in payload['senderDetails'] : Assertion.constructAssertion(str(json.loads(messageQueueResult['default_arguments'])['domain_gateway_map_id']) == str(payload['senderDetails']['domainGatewayMapId']), 'Matching Default Argument with storeType')
if 'wechat' in payload['channel'].lower():
Assertion.constructAssertion(str(json.loads(messageQueueResult['default_arguments'])['AppId']) == str(payload['accountDetails']['appId']), 'Matching Default Argument with AccountDetails')
Assertion.constructAssertion(str(json.loads(messageQueueResult['default_arguments'])['AppSecret']) == str(payload['accountDetails']['appSecret']), 'Matching Default Argument with AccountDetails')
Assertion.constructAssertion(str(json.loads(messageQueueResult['default_arguments'])['OriginalId']) == str(payload['accountDetails']['originalId']), 'Matching Default Argument with AccountDetails')
if payload['schedule']['type'] == 'IMMEDIATELY':
Assertion.constructAssertion(str(messageQueueResult['type']) == payload['channel'], 'Channel Passed in payload :{} and messageQueue :{}'.format(payload['channel'], messageQueueResult['type']))
Assertion.constructAssertion(str(messageQueueResult['scheduled_type']) == str(payload['schedule']['type']), 'ScheduleType Passed :{} and in MessageQueue :{}'.format(payload['schedule']['type'], messageQueueResult['scheduled_type']))
elif payload['schedule']['type'] == 'PARTICULAR_DATE':
Assertion.constructAssertion(str(messageQueueResult['type']) == payload['channel'], 'Channel Passed in payload :{} and messageQueue :{}'.format(payload['channel'], messageQueueResult['type']))
Assertion.constructAssertion(str(messageQueueResult['scheduled_type']) == str(payload['schedule']['type']), 'ScheduleType Passed :{} and in MessageQueue :{}'.format(payload['schedule']['type'], messageQueueResult['scheduled_type']))
remindersTableResult = dbCallsMessage.getReminderDataFromMessageId(messageId, 'iris')
campaignMessage.assertReminderTable(remindersTableResult, payload['listId'], payload['schedule']['datetime'])
elif payload['schedule']['type'] == 'RECURRING':
Assertion.constructAssertion(str(messageQueueResult['type']) == 'SMS_REMINDER', 'Channel Passed in payload :{} and messageQueue :{}'.format(payload['channel'], messageQueueResult['type']))
Assertion.constructAssertion(str(messageQueueResult['scheduled_type']) == 'SCHEDULED', 'ScheduleType Passed :{} and in MessageQueue :{}'.format(payload['schedule']['type'], messageQueueResult['scheduled_type']))
remindersTableResult = dbCallsMessage.getReminderDataFromMessageId(messageId, 'iris')
campaignMessage.assertReminderTable(remindersTableResult, payload['listId'], payload['schedule']['pattern'])
if 'incentive' in payload:
if payload['incentive']['type'] == 'GENERIC':
incentiveDbResult = dbCallsMessage.getGenericIncentiveId(messageQueueResult['id'])
incentiveIdForGeneric = dbCallsMessage.getIncentiveMetaDetails()['GENERIC']
Assertion.constructAssertion(int(incentiveDbResult['incentive_type_id']) == int(incentiveIdForGeneric), 'Incentive Type Id :{}'.format(incentiveIdForGeneric))
Assertion.constructAssertion(int(incentiveDbResult['campaign_id']) == int(campaignId), 'Campaign Id in Incentive Table :{}'.format(campaignId))
def setup_class(self):
campaignMessage.getWeCRMTemplates()
self.nonWechatOrgId = construct.updateOrgId(
constant.config['wechat_org_id'])
self.templateIdDict = campaignMessage.setupTemplateId()
createListresponse, createListPayload, campaignId = campaignList.createList(
{
'customTagCount': 0,
'name': 'IRIS_LIST_' + str(int(time.time() * 100000))
},
campaignId=Test_Wechat_CreateMessage.createCampaign())
campaignList.assertCreateList(createListresponse, 200)
groupVersionDetailResult, bucketId = campaignList.assertCreateListDbCalls(
createListresponse['json']['entity']['listId'], createListPayload,
'ORG')
Logger.log('GroupVersionId : {}, bucketId : {}'.format(
groupVersionDetailResult, bucketId))
addRecipientResponse, addRecipientPayload = campaignList.addRecipient(
Test_Wechat_CreateMessage.addRecipientPayload(), campaignId,
createListresponse['json']['entity']['listId'])
campaignList.assertAddRecipient(addRecipientResponse, 200)
responseCoupon, payloadCoupon, campaignId = coupons.createCoupons(
campaignId=campaignId)
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(
createListresponse['json']['entity']['listId'])
self.bucketId = bucketId
self.strategy = construct.constructStrategyIds()
self.programeId = self.strategy['programeId']
self.allocationStrategyId = self.strategy['allocationStrategyId']
self.expiryStrategyId = self.strategy['expirationStrategyId']
self.voucherId = responseCoupon['json']['entity']['voucherSeriesId']
self.campaignId = campaignId
self.listId = createListresponse['json']['entity']['listId']
campaignMessage.updateDefaultMessageJson(self.campaignId, self.listId,
self.voucherId, self.strategy,
self.bucketId,
self.groupVersionResult)
constant.messagesDefault['updated'] = True
Logger.log(
'Using CampaignId : {} , listId : {} for Execution of Create Message'
.format(self.campaignId, self.listId))
def test_veneno_skippedUser_couponReedemed_ProdSanity(self):
try:
cusObj = InTouchAPI(Transaction.Add())
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList({'name': 'IRIS_LIST_' + str(int(time.time() * 100000)), 'recipients':{'dataSource':'CSV', 'schema':'firstName,lastName,mobile', 'data':['TestX,AutomationX,{}'.format(cusObj.params['mobile'])]}}, campaignId=self.campaignId)
self.listId = mergeListresponse['json']['entity']['listId']
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(mergeListresponse['json']['entity']['listId'])
self.bucketId = self.groupVersionResult['TEST']['bucket_id']
self.couponConfigChange({'allow_multiple_vouchers_per_user':False,'same_user_multiple_redeem':False,'multiple_use':False})
time.sleep(70)
messagePayloadToUpdate = {
'incentive':{
'type':'COUPONS',
'voucherSeriesId':self.voucherId
},
'senderDetails':{
'domainGatewayMapId':constant.config['message_senders']['domainGatewayMapId'],
'gsmSenderId':constant.config['message_senders']['gsmSenderId'],
'useSystemDefaults':False,
'cdmaSenderId':constant.config['message_senders']['cdmaSenderId']
},
'message' : 'This Message is Going to Skip Due to Coupon has already been redeemed : {{voucher}} {{optout}}'
}
messageResponse, messagePayload = campaignMessage.createMessage(self, payloadData=messagePayloadToUpdate)
authorizeResponse = authorize.makeAuthorizeRequest(self.campaignId, messageResponse['json']['entity']['messageId'])
custObjResponse = cusObj.response # json.loads(cusObj.response.replace("'", "\""))
couponCode = dbCallsCoupons.getCouponCode(self.voucherId, custObjResponse['response']['transactions']['transaction'][0]['customer']['user_id'])
coupObj = InTouchAPI(Coupon.Redeem(body={'root':{'coupon':{'transaction':{'number':cusObj.params['transactionId'], 'amount':100}}}}, mobile=cusObj.params['mobile'], code=couponCode))
messageResponse, messagePayload = campaignMessage.createMessage(self, payloadData=messagePayloadToUpdate)
authorizeResponse = authorize.makeAuthorizeRequest(self.campaignId, messageResponse['json']['entity']['messageId'])
authorizeResult = self.getAuthorizeResultBody(self.campaignId, self.listId, self.groupVersionResult, self.bucketId, self.voucherId, self.strategy, messagePayload, str(messageResponse['json']['entity']['messageId']), authorizeResponse)
communicationDetailId , communicationDetailBucketId, communicationDetailExpectedCount = authorize.assertMessageQueueAndGetCommunicationDetailsForReferenceMessageQueueId(self.campaignId, self.groupVersionResult['TEST']['id'], authorizeResult['messageId'])
VenenoDBAssertion(self.campaignId, 'SMS', communicationDetailId, self.groupVersionResult['TEST']['customer_count'], self.groupVersionResult['TEST']['id'], authorizeResult['payload']['message'], testControlType='skip', skippedReasons=['Coupon For user was already redeemed.']).check()
authorize.assertUserPresenceInSkippedTable(communicationDetailId, communicationDetailBucketId, constant.config['skipped_errors']['COUPON_REDEEMED'], 'Coupon For user was already redeemed.')
except Exception, exp:
Assertion.constructAssertion(False, exp)
def setupCampaignShardThriftObjectWithDBDetails(campaignType, listType,
groupIdsOfListCreated):
for eachGroupId in groupIdsOfListCreated:
data = {}
data.update({'groupId': eachGroupId})
data.update({
'groupDetails':
dbCallsList.getGroupDetailsWithListId(eachGroupId)
})
data.update({
'groupLabel': data['groupDetails']['group_label'],
'uuid': None
})
data.update({
'groupVersionDetails':
dbCallsList.getGroupVersionDetailsWithGroupId(
data['groupDetails']['id'])
})
camapignGroupRecipientsData = {
'TEST':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
data['groupVersionDetails']['TEST']['bucket_id'],
data['groupVersionDetails']['TEST']['id'])
}
if 'CONTROL' in data['groupVersionDetails']:
camapignGroupRecipientsData.update({
'CONTROL':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
data['groupVersionDetails']['CONTROL']['bucket_id'],
data['groupVersionDetails']['CONTROL']['id'])
})
data.update(
{'campaignGroupRecipients': camapignGroupRecipientsData})
constant.thiriftCampaignShardTestReferenceObject[
campaignType.lower()]['campaign']['lists'][listType].append(
data)
def test_veneno_inboxUser_CustomFiledValue_ProdSanity(self):
obj = InTouchAPI(Customer.Add(body={'root':{'customer':{'custom_fields':{'field':{'name':'gender', 'value':'Male'}}}}}))
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList({'name': 'IRIS_LIST_' + str(int(time.time() * 100000)), 'recipients':{'dataSource':'CSV', 'schema':'firstName,lastName,mobile', 'data':['TestX,AutomationX,{}'.format(obj.params['mobile'])]}}, campaignId=self.campaignId)
self.listId = mergeListresponse['json']['entity']['listId']
self.groupVersionResult = dbCallsList.getGroupVersionDetailsWithGroupId(mergeListresponse['json']['entity']['listId'])
self.bucketId = self.groupVersionResult['TEST']['bucket_id']
messagePayloadToUpdate = {
'senderDetails':{
'domainGatewayMapId':constant.config['message_senders']['domainGatewayMapId'],
'gsmSenderId':constant.config['message_senders']['gsmSenderId'],
'useSystemDefaults':False,
'cdmaSenderId':constant.config['message_senders']['cdmaSenderId']
},
'message' : 'This Message is Going to Inbox Due to custom Field Value : {{custom_field.gender}} {{optout}}'
}
messageResponse, messagePayload = campaignMessage.createMessage(self, payloadData=messagePayloadToUpdate)
authorizeResponse = authorize.makeAuthorizeRequest(self.campaignId, messageResponse['json']['entity']['messageId'])
authorizeResult = self.getAuthorizeResultBody(self.campaignId, self.listId, self.groupVersionResult, self.bucketId, self.voucherId, self.strategy, messagePayload, str(messageResponse['json']['entity']['messageId']), authorizeResponse)
communicationDetailId , communicationDetailBucketId , communicationDetailExpectedCount = authorize.assertMessageQueueAndGetCommunicationDetailsForReferenceMessageQueueId(self.campaignId, self.groupVersionResult['TEST']['id'], authorizeResult['messageId'])
VenenoDBAssertion(self.campaignId, 'SMS', communicationDetailId, self.groupVersionResult['TEST']['customer_count'], self.groupVersionResult['TEST']['id'], authorizeResult['payload']['message'], testControlType='skip').check()
authorize.assertUserPresenceInNsAdminTable(communicationDetailId , communicationDetailBucketId, 1)
def preRequisitesForVenenoMobilePush(commChannelType,
testControlType='org'):
singleUserProfile = dbCallsAuthorize.getUserForMobilePush(
commChannelType)[0]
secondUserProfile = dbCallsAuthorize.getUserForMobilePush(
commChannelType)[1]
userData = [
'Test,Automation,' + str(singleUserProfile['userId']),
'Test,Automation,' + str(secondUserProfile['userId'])
]
if 'storeType' in constant.payload['createmessage']:
constant.payload['createmessage'].pop('storeType')
campaignResponse, campaignPayload = campaigns.createCampaign({
'name':
'IRIS_' + str(int(time.time() * 100000)),
'goalId':
constant.irisGenericValues['goalId'],
'objectiveId':
constant.irisGenericValues['objectiveId'],
'testControl': {
'type': testControlType.upper(),
'test': 90
}
})
listResponse, listPayload, campaignId = campaignList.createList(
{
'customTagCount': 0,
'name': 'IRIS_LIST_' + str(int(time.time() * 100000))
},
campaignId=campaignResponse['json']['entity']['campaignId'])
addRecipientResponse, addRecipientPayload = campaignList.addRecipient(
{
'data': userData,
'schema': 'firstName,lastName,userId'
},
campaignId,
listResponse['json']['entity']['listId'],
newUser=False)
responseCoupon, payloadCoupon, campaignId = coupons.createCoupons(
campaignId=campaignId)
groupVersionDetails = dbCallsList.getGroupVersionDetailsWithGroupId(
listResponse['json']['entity']['listId'])
camapignGroupRecipientsData = {
'TEST':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
groupVersionDetails['TEST']['bucket_id'],
groupVersionDetails['TEST']['id'])
}
if 'CONTROL' in groupVersionDetails:
camapignGroupRecipientsData.update({
'CONTROL':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
groupVersionDetails['CONTROL']['bucket_id'],
groupVersionDetails['CONTROL']['id'])
})
return {
'campaignName':
campaignPayload['name'],
'campaignId':
campaignId,
'listId':
listResponse['json']['entity']['listId'],
'voucherId':
responseCoupon['json']['entity']['voucherSeriesId'],
'strategy':
None,
'programeId':
None,
'allocationStrategyId':
None,
'expiryStrategyId':
None,
'groupDetails':
dbCallsList.getGroupDetailsWithListId(
listResponse['json']['entity']['listId']),
'campaignGroupRecipient':
camapignGroupRecipientsData,
'bucketId':
groupVersionDetails['TEST']['bucket_id'],
'groupVersionResult':
groupVersionDetails,
'groupName':
listPayload['name'],
'addRecipientPayload':
addRecipientPayload
}
def setupUploadList(eachCampaignType,
campaignName,
campaignId,
nameOfFilterLists,
newUser=False,
setupObjectForCampaignShard=True,
channel='mobile'):
try:
Logger.log(
'Setting up Upload List :{} for campaignName :{} , campaignId :{}'
.format(nameOfFilterLists, campaignName, campaignId))
mergeListresponse, mergeListPayload, campaignId = campaignList.mergeList(
{},
campaignId=campaignId,
campaignType=['LIVE', eachCampaignType, 'List', 'TAGS', 0],
userType=channel,
numberOfUsers=10,
numberOfCustomTags=0,
newUser=newUser)
groupDetails = dbCallsList.getGroupDetailsWithListId(
mergeListresponse['json']['entity']['listId'])
groupVersionDetails = dbCallsList.getGroupVersionDetailsWithGroupId(
mergeListresponse['json']['entity']['listId'])
camapignGroupRecipientsData = {
'TEST':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
groupVersionDetails['TEST']['bucket_id'],
groupVersionDetails['TEST']['id'])
}
if 'CONTROL' in groupVersionDetails:
camapignGroupRecipientsData.update({
'CONTROL':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
groupVersionDetails['CONTROL']['bucket_id'],
groupVersionDetails['CONTROL']['id'])
})
if setupObjectForCampaignShard:
constant.thiriftCampaignShardTestReferenceObject[
eachCampaignType.lower(
)]['campaign']['lists']['UPLOADED'].append({
'addRecipientPayload':
mergeListPayload['recipients'],
'groupLabel':
mergeListPayload['name'],
'groupDetails':
groupDetails,
'groupVersionDetails':
groupVersionDetails,
'campaignGroupRecipients':
camapignGroupRecipientsData
})
else:
return {
'addRecipientPayload': mergeListPayload['recipients'],
'groupLabel': mergeListPayload['name'],
'groupDetails': groupDetails,
'groupVersionDetails': groupVersionDetails,
'campaignGroupRecipients': camapignGroupRecipientsData
}
except Exception, exp:
raise Exception(
'Upload Setup Failed with Exception :{}'.format(exp))
def getDBInformationRelatedToCampaignShard(self):
self.hashLookupDetails = dbCallsList.getHashLookUp()
self.groupDetailResult = dbCallsList.getGroupDetailsWithListId(
self.listId)
self.groupVersionDetailResult = dbCallsList.getGroupVersionDetailsWithGroupId(
self.listId)
def preRequisitesForVenenoWechat(userData=[], testControlType='org'):
if len(userData) == 0:
for eachUser in constant.config['wechat']['user']:
userData.append(eachUser['firstName'] + ',' +
eachUser['lastName'] + ',' + eachUser['email'])
if 'storeType' in constant.payload['createmessage']:
constant.payload['createmessage'].pop('storeType')
campaignResponse, campaignPayload = campaigns.createCampaign({
'name':
'IRIS_' + str(int(time.time() * 100000)),
'goalId':
constant.irisGenericValues['goalId'],
'objectiveId':
constant.irisGenericValues['objectiveId'],
'testControl': {
'type': testControlType.upper(),
'test': 90
}
})
listResponse, listPayload, campaignId = campaignList.createList(
{
'customTagCount': 0,
'name': 'IRIS_LIST_' + str(int(time.time() * 100000))
},
campaignId=campaignResponse['json']['entity']['campaignId'])
addRecipientResponse, addRecipientPayload = campaignList.addRecipient(
{
'data': userData,
'schema': 'firstName,lastName,email'
},
campaignId,
listResponse['json']['entity']['listId'],
newUser=False)
responseCoupon, payloadCoupon, campaignId = coupons.createCoupons(
campaignId=campaignId)
groupVersionDetails = dbCallsList.getGroupVersionDetailsWithGroupId(
listResponse['json']['entity']['listId'])
camapignGroupRecipientsData = {
'TEST':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
groupVersionDetails['TEST']['bucket_id'],
groupVersionDetails['TEST']['id'])
}
if 'CONTROL' in groupVersionDetails:
camapignGroupRecipientsData.update({
'CONTROL':
dbCallsList.getAllUsersFromCampaignGroupRecipient(
groupVersionDetails['CONTROL']['bucket_id'],
groupVersionDetails['CONTROL']['id'])
})
return {
'campaignName':
campaignPayload['name'],
'campaignId':
campaignId,
'listId':
listResponse['json']['entity']['listId'],
'voucherId':
responseCoupon['json']['entity']['voucherSeriesId'],
'strategy':
None,
'programeId':
None,
'allocationStrategyId':
None,
'expiryStrategyId':
None,
'groupDetails':
dbCallsList.getGroupDetailsWithListId(
listResponse['json']['entity']['listId']),
'campaignGroupRecipient':
camapignGroupRecipientsData,
'bucketId':
groupVersionDetails['TEST']['bucket_id'],
'groupVersionResult':
groupVersionDetails,
'groupName':
listPayload['name'],
'addRecipientPayload':
addRecipientPayload
}
