def initSamples(self):
self.partnerSample = PartnerSample(serverUrl)
self.partySample = PartySample(serverUrl)
self.subscriptionSample = SubscriptionSample(serverUrl)
self.ipRangeSample = IpRangeSample(serverUrl)
self.uriPatternSample = UriPatternSample(serverUrl)
self.accessTypeSample = AccessTypeSample(serverUrl)
self.accessRuleSample = AccessRuleSample(serverUrl)
self.credentialSample = CredentialSample()
class PostPaymentHandlingTest(GenericTest, TestCase):
partnerSample = PartnerSample(serverUrl)
subscriptionTermSample = SubscriptionTermSample(serverUrl)
def setUp(self):
super(PostPaymentHandlingTest, self).setUp()
Partner.objects.filter(
partnerId=self.partnerSample.data['partnerId']).delete()
self.partnerId = self.partnerSample.forcePost(self.partnerSample.data)
self.subscriptionTermSample.data['partnerId'] = self.partnerId
self.subscriptionTermId = self.subscriptionTermSample.forcePost(
self.subscriptionTermSample.data)
def test_for_postPaymentSubscription(self):
activationCodeArray = PaymentControl.postPaymentHandling(
self.subscriptionTermId, 5)
for activationCode in activationCodeArray:
self.assertIsNotNone(
PyTestGenerics.forceGet(ActivationCode, 'activationCode',
activationCode))
PyTestGenerics.forceDelete(ActivationCode, 'activationCode',
activationCode)
def tearDown(self):
super(PostPaymentHandlingTest, self).tearDown()
PyTestGenerics.forceDelete(self.partnerSample.model,
self.partnerSample.pkName, self.partnerId)
PyTestGenerics.forceDelete(self.subscriptionTermSample.model,
self.subscriptionTermSample.pkName,
self.subscriptionTermId)
class SubscriptionTransactionCRUD(GenericCRUDTest, TestCase):
sample = SubscriptionTransactionSample(serverUrl)
partySample = PartySample(serverUrl)
partnerSample = PartnerSample(serverUrl)
subscriptionSample = SubscriptionSample(serverUrl)
def setUp(self):
super(SubscriptionTransactionCRUD, self).setUp()
self.partyId = self.partySample.forcePost(self.partySample.data)
Partner.objects.filter(
partnerId=self.partnerSample.data['partnerId']).delete()
self.partnerId = self.partnerSample.forcePost(self.partnerSample.data)
self.subscriptionSample.data['partyId'] = self.partyId
self.subscriptionSample.data['partnerId'] = self.partnerId
self.subscriptionId = self.subscriptionSample.forcePost(
self.subscriptionSample.data)
self.sample.data['subscriptionId'] = self.sample.updateData[
'subscriptionId'] = self.subscriptionId
def tearDown(self):
super(SubscriptionTransactionCRUD, self).tearDown()
PyTestGenerics.forceDelete(self.partySample.model,
self.partySample.pkName, self.partyId)
PyTestGenerics.forceDelete(self.partnerSample.model,
self.partnerSample.pkName, self.partnerId)
PyTestGenerics.forceDelete(self.subscriptionSample.model,
self.subscriptionSample.pkName,
self.subscriptionId)
class CheckLimitTest(GenericTest, TestCase):
successIpAddressCountSample = IpAddressCountSample(serverUrl)
failIpAddressCountSample = IpAddressCountSample(serverUrl)
limitValueSample = LimitValueSample(serverUrl)
partnerSample = PartnerSample(serverUrl)
successIp = '123.45.6.7'
failIp = '123.45.6.8'
def setUp(self):
super(CheckLimitTest, self).setUp()
Partner.objects.filter(
partnerId=self.partnerSample.data['partnerId']).delete()
self.partnerId = self.partnerSample.forcePost(self.partnerSample.data)
self.successIpAddressCountSample.data['partnerId'] = self.partnerId
self.successIpAddressCountSample.data['count'] = 1
self.successIpAddressCountSample.data['ip'] = self.successIp
self.successIpAddressCountId = self.successIpAddressCountSample.forcePost(
self.successIpAddressCountSample.data)
self.failIpAddressCountSample.data['partnerId'] = self.partnerId
self.failIpAddressCountSample.data['ip'] = self.failIp
self.failIpAddressCountSample.data['count'] = 10000
self.failIpAddressCountId = self.failIpAddressCountSample.forcePost(
self.failIpAddressCountSample.data)
self.limitValueSample.data['partnerId'] = self.partnerId
self.limitValueId = self.limitValueSample.forcePost(
self.limitValueSample.data)
def test_for_check_limit(self):
url = '%smeters/ip/%s/limit/?partnerId=%s' % (
serverUrl, self.successIp, self.partnerId)
cookies = {'apiKey': self.apiKey}
req = requests.get(url, cookies=cookies)
self.assertEqual(req.json()['status'], 'OK')
url = '%smeters/ip/%s/limit/?partnerId=%s' % (serverUrl, self.failIp,
self.partnerId)
req = requests.get(url, cookies=cookies)
self.assertEqual(req.json()['status'], 'Block')
def tearDown(self):
super(CheckLimitTest, self).tearDown()
PyTestGenerics.forceDelete(self.partnerSample.model,
self.partnerSample.pkName, self.partnerId)
PyTestGenerics.forceDelete(self.successIpAddressCountSample.model,
self.successIpAddressCountSample.pkName,
self.successIpAddressCountId)
PyTestGenerics.forceDelete(self.failIpAddressCountSample.model,
self.failIpAddressCountSample.pkName,
self.failIpAddressCountId)
PyTestGenerics.forceDelete(self.limitValueSample.model,
self.limitValueSample.pkName,
self.limitValueId)
def test_for_update(self):
subscriptionSample = SubscriptionSample(serverUrl)
partnerSample = PartnerSample(serverUrl)
partySample = PartySample(serverUrl)
Partner.objects.filter(partnerId=partnerSample.data['partnerId']).delete()
partnerId = partnerSample.forcePost(partnerSample.data)
partyId = partySample.forcePost(partySample.data)
subscriptionSample.data['partnerId']=subscriptionSample.updateData['partnerId']=partnerId
subscriptionSample.data['partyId']=subscriptionSample.updateData['partyId']=partyId
subscriptionId = subscriptionSample.forcePost(subscriptionSample.data)
url = serverUrl + 'subscriptions/' + str(subscriptionId) + '/renewal?apiKey=%s' % self.apiKey
cookies = {'apiKey':self.apiKey}
req = requests.put(url, data=subscriptionSample.updateData,cookies=cookies)
self.assertEqual(req.status_code, 200)
transactionId = req.json()['subscriptionTransactionId']
self.assertIsNotNone(PyTestGenerics.forceGet(SubscriptionTransaction,'subscriptionTransactionId',transactionId))
PyTestGenerics.forceDelete(SubscriptionTransaction, 'subscriptionTransactionId', transactionId)
PyTestGenerics.forceDelete(subscriptionSample.model,subscriptionSample.pkName,subscriptionId)
PyTestGenerics.forceDelete(partnerSample.model,partnerSample.pkName,partnerId)
PyTestGenerics.forceDelete(partySample.model,partySample.pkName,partyId)
def test_for_update(self):
subscriptionSample = SubscriptionSample(serverUrl)
partnerSample = PartnerSample(serverUrl)
partySample = PartySample(serverUrl)
Partner.objects.filter(
partnerId=partnerSample.data['partnerId']).delete()
partnerId = partnerSample.forcePost(partnerSample.data)
partyId = partySample.forcePost(partySample.data)
subscriptionSample.data['partnerId'] = subscriptionSample.updateData[
'partnerId'] = partnerId
subscriptionSample.data['partyId'] = subscriptionSample.updateData[
'partyId'] = partyId
subscriptionId = subscriptionSample.forcePost(subscriptionSample.data)
url = serverUrl + 'subscriptions/' + str(
subscriptionId) + '/renewal?apiKey=%s' % self.apiKey
cookies = {'apiKey': self.apiKey}
req = requests.put(url,
data=subscriptionSample.updateData,
cookies=cookies)
self.assertEqual(req.status_code, 200)
transactionId = req.json()['subscriptionTransactionId']
self.assertIsNotNone(
PyTestGenerics.forceGet(SubscriptionTransaction,
'subscriptionTransactionId',
transactionId))
PyTestGenerics.forceDelete(SubscriptionTransaction,
'subscriptionTransactionId', transactionId)
PyTestGenerics.forceDelete(subscriptionSample.model,
subscriptionSample.pkName, subscriptionId)
PyTestGenerics.forceDelete(partnerSample.model, partnerSample.pkName,
partnerId)
PyTestGenerics.forceDelete(partySample.model, partySample.pkName,
partyId)
class LimitValueCRUD(GenericCRUDTest, TestCase):
sample = LimitValueSample(serverUrl)
partnerSample = PartnerSample(serverUrl)
def setUp(self):
super(LimitValueCRUD, self).setUp()
Partner.objects.filter(
partnerId=self.partnerSample.data['partnerId']).delete()
self.partnerId = self.partnerSample.forcePost(self.partnerSample.data)
self.sample.partnerId = self.sample.data[
'partnerId'] = self.sample.updateData['partnerId'] = self.partnerId
def tearDown(self):
super(LimitValueCRUD, self).tearDown()
PyTestGenerics.forceDelete(self.partnerSample.model,
self.partnerSample.pkName, self.partnerId)
class AccessRuleCRUD(GenericCRUDTest, TestCase):
sample = AccessRuleSample(serverUrl)
partnerSample = PartnerSample(serverUrl)
patternSample = UriPatternSample(serverUrl)
accessTypeSample = AccessTypeSample(serverUrl)
def setUp(self):
super(AccessRuleCRUD,self).setUp()
Partner.objects.filter(partnerId=self.partnerSample.data['partnerId']).delete()
self.partnerId = self.partnerSample.forcePost(self.partnerSample.data)
self.patternId = self.patternSample.forcePost(self.patternSample.data)
self.accessTypeId = self.accessTypeSample.forcePost(self.accessTypeSample.data)
self.sample.partnerId=self.sample.data['partnerId']=self.sample.updateData['partnerId']=self.partnerId
self.sample.data['patternId']=self.sample.updateData['patternId']=self.patternId
self.sample.data['accessTypeId']=self.sample.updateData['accessTypeId']=self.accessTypeId
def tearDown(self):
super(AccessRuleCRUD,self).tearDown()
PyTestGenerics.forceDelete(self.partnerSample.model, self.partnerSample.pkName, self.partnerId)
PyTestGenerics.forceDelete(self.patternSample.model, self.patternSample.pkName, self.patternId)
PyTestGenerics.forceDelete(self.accessTypeSample.model, self.accessTypeSample.pkName, self.accessTypeId)
class ActivationCodeCRUD(GenericCRUDTest, TestCase):
sample = ActivationCodeSample(serverUrl)
partnerSample = PartnerSample(serverUrl)
def setUp(self):
super(ActivationCodeCRUD, self).setUp()
Partner.objects.filter(
partnerId=self.partnerSample.data['partnerId']).delete()
self.partnerId = self.partnerSample.forcePost(self.partnerSample.data)
self.sample.data['partnerId'] = self.sample.updateData[
'partnerId'] = self.partnerId
# delete activationCode entries that will be used for test
ActivationCode.objects.filter(
activationCode=self.sample.data['activationCode']).delete()
ActivationCode.objects.filter(
activationCode=self.sample.updateData['activationCode']).delete()
def tearDown(self):
super(ActivationCodeCRUD, self).tearDown()
PyTestGenerics.forceDelete(self.partnerSample.model,
self.partnerSample.pkName, self.partnerId)
class IncrementMeteringCountTest(GenericTest, TestCase):
ipAddressCountSample = IpAddressCountSample(serverUrl)
limitValueSample = LimitValueSample(serverUrl)
partnerSample = PartnerSample(serverUrl)
def setUp(self):
super(IncrementMeteringCountTest, self).setUp()
Partner.objects.filter(
partnerId=self.partnerSample.data['partnerId']).delete()
self.partnerId = self.partnerSample.forcePost(self.partnerSample.data)
self.ipAddressCountSample.data['partnerId'] = self.partnerId
self.ipAddressCountSample.data['count'] = 1
self.ipAddressCountId = self.ipAddressCountSample.forcePost(
self.ipAddressCountSample.data)
self.limitValueSample.data['partnerId'] = self.partnerId
self.limitValueId = self.limitValueSample.forcePost(
self.limitValueSample.data)
def test_for_increment(self):
currentCount = self.ipAddressCountSample.data['count']
url = '%smeters/ip/%s/increment/?partnerId=%s' % (
serverUrl, self.ipAddressCountSample.data['ip'], self.partnerId)
cookies = {'apiKey': self.apiKey}
req = requests.post(url, cookies=cookies)
newCount = IpAddressCount.objects.get(id=self.ipAddressCountId).count
self.assertEqual(currentCount + 1, newCount)
def tearDown(self):
super(IncrementMeteringCountTest, self).tearDown()
PyTestGenerics.forceDelete(self.partnerSample.model,
self.partnerSample.pkName, self.partnerId)
PyTestGenerics.forceDelete(self.ipAddressCountSample.model,
self.ipAddressCountSample.pkName,
self.ipAddressCountId)
PyTestGenerics.forceDelete(self.limitValueSample.model,
self.limitValueSample.pkName,
self.limitValueId)
class AuthorizationTestBase(GenericTest, TestCase):
# should be consistent with IpRangeSample object
successIp = '120.1.0.0'
failIp = '12.2.3.4'
# should be consistent with SubscriptionSample object
successSubscriptionData = {
'startDate':'2012-04-12T00:00:00Z',
'endDate':'2018-04-12T00:00:00Z',
'partnerId':None, # To be populated after Partner is created
'partyId':None, # To be populated after Party is created
}
failSubscriptionData = {
'startDate':'2012-04-12T00:00:00Z',
'endDate':'2014-04-12T00:00:00Z',
'partnerId':None,
'partyId':None,
}
def initSamples(self):
self.partnerSample = PartnerSample(serverUrl)
self.partySample = PartySample(serverUrl)
self.subscriptionSample = SubscriptionSample(serverUrl)
self.ipRangeSample = IpRangeSample(serverUrl)
self.uriPatternSample = UriPatternSample(serverUrl)
self.accessTypeSample = AccessTypeSample(serverUrl)
self.accessRuleSample = AccessRuleSample(serverUrl)
self.credentialSample = CredentialSample()
def createSamples(self):
# create independent objects
self.accessTypeId = self.accessTypeSample.forcePost(self.accessTypeSample.data)
self.uriPatternId = self.uriPatternSample.forcePost(self.uriPatternSample.data)
Partner.objects.filter(partnerId=self.partnerSample.data['partnerId']).delete()
self.partnerId = self.partnerSample.forcePost(self.partnerSample.data)
self.partyId = self.partySample.forcePost(self.partySample.data)
# create AccessRule based on AccessType, Pattern, and Partner objects created
self.accessRuleSample.data['accessTypeId']=self.accessTypeId
self.accessRuleSample.data['patternId']=self.uriPatternId
self.accessRuleSample.data['partnerId'] = self.partnerId
self.accessRuleId = self.accessRuleSample.forcePost(self.accessRuleSample.data)
# create Subscription object based on Party and Partner objects created
self.subscriptionSample.data['partyId'] = self.partyId
self.subscriptionSample.data['partnerId'] = self.partnerId
self.subscriptionId = self.subscriptionSample.forcePost(self.subscriptionSample.data)
# create IpRange object based on data Party created
self.ipRangeSample.data['partyId'] = self.partyId
self.ipRangeId = self.ipRangeSample.forcePost(self.ipRangeSample.data)
# create Credential object based on Party created
PyTestGenerics.forceDelete(self.credentialSample.model, 'username', self.credentialSample.data['username'])
self.credentialSample.data['partyId'] = self.partyId
self.credentialSample.data['partnerId'] = self.partnerId
self.credentialId = self.credentialSample.forcePost(self.credentialSample.data)
def deleteSamples(self):
PyTestGenerics.forceDelete(self.subscriptionSample.model, self.subscriptionSample.pkName, self.subscriptionId)
PyTestGenerics.forceDelete(self.ipRangeSample.model, self.ipRangeSample.pkName, self.ipRangeId)
PyTestGenerics.forceDelete(self.partySample.model, self.partySample.pkName, self.partyId)
PyTestGenerics.forceDelete(self.partnerSample.model, self.partnerSample.pkName, self.partnerId)
PyTestGenerics.forceDelete(self.accessTypeSample.model, self.accessTypeSample.pkName, self.accessTypeId)
PyTestGenerics.forceDelete(self.uriPatternSample.model, self.uriPatternSample.pkName, self.uriPatternId)
PyTestGenerics.forceDelete(self.accessRuleSample.model, self.accessRuleSample.pkName, self.accessRuleId)
PyTestGenerics.forceDelete(self.credentialSample.model, self.credentialSample.pkName, self.credentialId)
class SubscriptionCRUD(GenericCRUDTest, TestCase):
sample = SubscriptionSample(serverUrl)
partySample = PartySample(serverUrl)
partnerSample = PartnerSample(serverUrl)
activationCodeSample = ActivationCodeSample(serverUrl)
def setUp(self):
super(SubscriptionCRUD, self).setUp()
self.partyId = self.partySample.forcePost(self.partySample.data)
Partner.objects.filter(
partnerId=self.partnerSample.data['partnerId']).delete()
self.partnerId = self.partnerSample.forcePost(self.partnerSample.data)
ActivationCode.objects.filter(activationCode=self.activationCodeSample.
data['activationCode']).delete()
self.activationCodeId = self.activationCodeSample.forcePost(
self.activationCodeSample.data)
self.sample.data['partyId'] = self.sample.updateData[
'partyId'] = self.partyId
self.sample.partnerId = self.sample.data[
'partnerId'] = self.sample.updateData['partnerId'] = self.partnerId
# post request for subscription is not generic. It creates a SubscriptionTransaction
# object in addition to a Subscription object.
def test_for_create(self):
sample = self.sample
url = sample.url
cookies = {'apiKey': self.apiKey}
# Creation via basic CRUD format
req = requests.post(url, data=sample.data, cookies=cookies)
self.assertEqual(req.status_code, status.HTTP_201_CREATED)
self.assertIsNotNone(
PyTestGenerics.forceGet(sample.model, sample.pkName,
req.json()[sample.pkName]))
transactionId = req.json()['subscriptionTransactionId']
self.assertIsNotNone(
PyTestGenerics.forceGet(SubscriptionTransaction,
'subscriptionTransactionId',
transactionId))
PyTestGenerics.forceDelete(SubscriptionTransaction,
'subscriptionTransactionId', transactionId)
PyTestGenerics.forceDelete(sample.model, sample.pkName,
req.json()[sample.pkName])
# Creationg via activation code
activationCode = ActivationCode.objects.get(
activationCodeId=self.activationCodeId).activationCode
data = {"partyId": self.partyId, "activationCode": activationCode}
req = requests.post(url, data=data, cookies=cookies)
self.assertEqual(req.status_code, status.HTTP_201_CREATED)
self.assertIsNotNone(
PyTestGenerics.forceGet(sample.model, sample.pkName,
req.json()[sample.pkName]))
transactionId = req.json()['subscriptionTransactionId']
self.assertIsNotNone(
PyTestGenerics.forceGet(SubscriptionTransaction,
'subscriptionTransactionId',
transactionId))
PyTestGenerics.forceDelete(SubscriptionTransaction,
'subscriptionTransactionId', transactionId)
PyTestGenerics.forceDelete(sample.model, sample.pkName,
req.json()[sample.pkName])
def tearDown(self):
super(SubscriptionCRUD, self).tearDown()
PyTestGenerics.forceDelete(self.partySample.model,
self.partySample.pkName, self.partyId)
PyTestGenerics.forceDelete(self.partnerSample.model,
self.partnerSample.pkName, self.partnerId)
PyTestGenerics.forceDelete(self.activationCodeSample.model,
self.activationCodeSample.pkName,
self.activationCodeId)