def test_new_list(self, mock_requests):
mock_requests.register_uri(
'GET',
("https://api.chartmogul.com/v1/invoices"
"?external_id=INV0001&customer_uuid=cus_f466e33d-ff2b-4a11-8f85-417eb02157a7"),
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
headers={'Content-Type': 'application/json'},
status_code=200,
text=newInvoiceListExample
)
config = Config("token", "secret") # is actually checked in mock
result = Invoice.all(config,
customer_uuid='cus_f466e33d-ff2b-4a11-8f85-417eb02157a7',
external_id='INV0001').get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
cu = []
cu.append('cus_f466e33d-ff2b-4a11-8f85-417eb02157a7')
ei = []
ei.append('inv0001')
self.assertEqual(mock_requests.last_request.qs, {'customer_uuid': cu,'external_id': ei})
# Struct too complex to do 1:1 comparison
self.assertTrue(isinstance(result, Invoice._many))
self.assertEqual(len(result.invoices), 1)
self.assertEqual(result.invoices[0].customer_uuid, 'cus_f466e33d-ff2b-4a11-8f85-417eb02157a7')
self.assertEqual(result.current_page, 1)
self.assertEqual(result.total_pages, 1)
def test_connectSubscriptions(self, mock_requests):
mock_requests.register_uri(
'POST',
"https://api.chartmogul.com/v1/customers/cus_5915ee5a-babd-406b-b8ce-d207133fb4cb/connect_subscriptions",
status_code=202)
jsonRequest = {
'subscriptions': [{
"data_source_uuid":
"ds_ade45e52-47a4-231a-1ed2-eb6b9e541213",
"external_id":
"d1c0c885-add0-48db-8fa9-0bdf5017d6b0"
}, {
"data_source_uuid":
"ds_ade45e52-47a4-231a-1ed2-eb6b9e541213",
"external_id":
"9db5f4a1-1695-44c0-8bd4-de7ce4d0f1d4"
}]
}
config = Config("token", "secret")
result = Customer.connectSubscriptions(
config,
uuid='cus_5915ee5a-babd-406b-b8ce-d207133fb4cb',
data=jsonRequest).get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(), jsonRequest)
self.assertEqual(result, None)
def test_add(self, mock_requests):
mock_requests.register_uri(
'POST',
'https://api.chartmogul.com/v1/customers/CUSTOMER_UUID/attributes/custom',
status_code=200,
json=simpleJSONResult)
expected = CustomAttributes(**simpleJSONResult)
config = Config('token', 'secret')
result = CustomAttributes.add(config,
uuid='CUSTOMER_UUID',
data=jsonData).get()
self.assertEqual(mock_requests.call_count, 1, 'expected call')
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(), jsonData)
self.assertTrue(isinstance(result, CustomAttributes))
self.assertEqual(result.custom['CAC'], expected.custom['CAC'])
self.assertEqual(result.custom['utmCampaign'],
expected.custom['utmCampaign'])
self.assertEqual(result.custom['convertedAt'],
expected.custom['convertedAt'])
self.assertEqual(result.custom['pro'], expected.custom['pro'])
self.assertEqual(result.custom['salesRep'],
expected.custom['salesRep'])
def test_all(self, mock_requests):
mock_requests.register_uri(
'GET',
("https://api.chartmogul.com/v1/metrics/all?start-date=2015-01-01"
"&end-date=2015-11-24&interval=month&geo=GB&plans=PRO+Plan"),
status_code=200,
json=allMetricsJSON)
config = Config("token", "secret")
result = Metrics.all(config,
start_date='2015-01-01',
end_date='2015-11-24',
interval='month',
geo='GB',
plans='PRO Plan').get()
expected = Metrics._many(parsedEntries)
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(
mock_requests.last_request.qs, {
'end-date': ['2015-11-24'],
'geo': ['gb'],
'interval': ['month'],
'plans': ['pro plan'],
'start-date': ['2015-01-01']
})
self.assertEqual(mock_requests.last_request.text, None)
self.assertEqual(str(result), str(expected))
def test_all_plan_groups(self, mock_requests):
expected_plan_groups = {
"plan_groups": [
{
"uuid": u"whatever_uuid",
"name": u"good_plan",
"plans_count": 2
},
{
"uuid": u"my_uuid",
"name": u"best_plan",
"plans_count": 5
},
],
"current_page":
1,
"total_pages":
1
}
mock_requests.register_uri('GET',
"https://api.chartmogul.com/v1/plan_groups",
status_code=200,
json=expected_plan_groups)
config = Config("token", "secret")
result = PlanGroup.all(config).get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.text, None)
self.assertTrue(isinstance(result.plan_groups[0], PlanGroup))
self.assertEqual(result.plan_groups[0].uuid, "whatever_uuid")
self.assertEqual(result.plan_groups[1].uuid, "my_uuid")
def test_modify_plan_group_name(self, mock_requests):
expected_plan_group_dict = {
"uuid": u"whatever_uuid",
"name": u"new_name",
"plans_count": 2
}
mock_requests.register_uri(
'PATCH',
"https://api.chartmogul.com/v1/plan_groups/whatever_uuid",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json=expected_plan_group_dict)
config = Config("token", "secret") # is actually checked in mock
result = PlanGroup.modify(config,
uuid="whatever_uuid",
data={
"name": "new_name"
}).get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(),
{"name": u"new_name"})
self.assertEqual(result.uuid, "whatever_uuid")
self.assertEqual(result.name, "new_name")
self.assertEqual(result.plans_count, 2)
def test_create_plan_group(self, mock_requests):
expected_plan_group_dict = {
"uuid": u"whatever_uuid",
"name": u"Gold Plan Group",
"plans_count": 2
}
sent = {
"name":
"Gold Plan Group",
"plans": [
"pl_fe0824c8-4738-11ea-a26c-3b021eb4c733",
"pl_fe160a70-4738-11ea-a26c-e38e12dbd8be"
]
}
mock_requests.register_uri(
'POST',
"https://api.chartmogul.com/v1/plan_groups",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json=expected_plan_group_dict)
config = Config("token", "secret") # is actually checked in mock
plan_group = PlanGroup.create(config, data=sent).get()
expected = PlanGroup(**expected_plan_group_dict)
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(), sent)
self.assertEqual(str(plan_group), str(expected))
def test_retrieve_invoice(self, mock_requests):
mock_requests.register_uri('GET', (
"https://api.chartmogul.com/v1/invoices/inv_22910fc6-c931-48e7-ac12-90d2cb5f0059"
),
request_headers={
'Authorization':
'Basic dG9rZW46c2VjcmV0'
},
headers={
'Content-Type': 'application/json'
},
status_code=200,
text=retrieveInvoiceExample)
config = Config("token", "secret") # is actually checked in mock
result = Invoice.retrieve(
config, uuid='inv_22910fc6-c931-48e7-ac12-90d2cb5f0059').get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
# Struct too complex to do 1:1 comparison
self.assertTrue(isinstance(result, Invoice))
self.assertEqual(result.uuid,
'inv_22910fc6-c931-48e7-ac12-90d2cb5f0059')
def test_all(self, mock_requests):
mock_requests.register_uri(
'GET',
"https://api.chartmogul.com/v1/customers",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json=docsListSample)
config = Config("token", "secret")
customers = Customer.all(config).get()
expected = Customer._many(entries=[deserializedCustomer],
has_more=True,
per_page=50,
page=1,
current_page=1,
total_pages=4)
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.text, None)
# Complete comparing too complicated, would need to:
# 1) sort all dictionaries,
# 2) use special class/library for timezones (Python has no default)
# self.assertEqual(str(customers), str(expected))
# => check only first level fields are OK
self.assertEqual(sorted(dir(customers)), sorted(dir(expected)))
self.assertEqual(sorted(customers.entries[0].attributes.stripe),
sorted(expected.entries[0].attributes.stripe))
self.assertEqual(sorted(customers.entries[0].attributes.clearbit),
sorted(expected.entries[0].attributes.clearbit))
self.assertTrue(isinstance(customers.entries[0], Customer))
def test_list_imported_subscriptions(self, mock_requests):
""" Test listing (get) subscriptions.
"""
mock_requests.register_uri(
'GET',
"https://api.chartmogul.com/v1/import/customers/some_uuid/subscriptions",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json={
"customer_uuid": "some_uuid",
"subscriptions":[
{
"uuid": "sub_e6bc5407-e258-4de0-bb43-61faaf062035",
"external_id": "sub_0001",
"plan_uuid": "pl_eed05d54-75b4-431b-adb2-eb6b9e543206",
"data_source_uuid": "ds_fef05d54-47b4-431b-aed2-eb6b9e545430",
"cancellation_dates":[]
}
],
"current_page": 1,
"total_pages": 1
}
)
config = Config("token", "secret") # is actually checked in mock
result = Subscription.list_imported(config, uuid="some_uuid").get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(result.__class__.__name__, Subscription._many.__name__)
self.assertEqual(result.customer_uuid, "some_uuid")
def test_all(self, mock_requests):
mock_requests.register_uri(
'GET',
"https://api.chartmogul.com/v1/data_sources",
status_code=200,
json={
"data_sources": [{
"name": "test",
"uuid": "my_uuid",
"created_at": "2016-01-10T15:34:05Z",
"status": "never_imported"
}]
})
config = Config("token", "secret")
ds = DataSource.all(config).get()
expected = DataSource._many(data_sources=[
DataSource(
**{
"name": u"test",
"uuid": u"my_uuid",
"created_at": datetime(2016, 1, 10, 15, 34, 5),
"status": u"never_imported"
})
])
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.text, None)
self.assertTrue(isinstance(ds.data_sources[0], DataSource))
def test_modify_subscription(self, mock_requests):
""" Test modify (patch) subscription (cancellation_dates).
"""
mock_requests.register_uri(
'PATCH',
"https://api.chartmogul.com/v1/import/subscriptions/some_uuid",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json={
"uuid": "some_uuid",
"external_id": "sub_0001",
"customer_uuid": "cus_f466e33d-ff2b-4a11-8f85-417eb02157a7",
"plan_uuid": "pl_eed05d54-75b4-431b-adb2-eb6b9e543206",
"cancellation_dates": [],
"data_source_uuid": "ds_fef05d54-47b4-431b-aed2-eb6b9e545430"
}
)
config = Config("token", "secret") # is actually checked in mock
result = Subscription.modify(config, uuid="some_uuid", data={
"cancellation_dates": []}).get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(),
{"cancellation_dates": []})
self.assertEqual(result.__class__, Subscription)
self.assertEqual(result.__dict__, Subscription(**{
"cancellation_dates": [],
"customer_uuid": u"cus_f466e33d-ff2b-4a11-8f85-417eb02157a7",
"data_source_uuid": u"ds_fef05d54-47b4-431b-aed2-eb6b9e545430",
"uuid": u"some_uuid",
"external_id": u"sub_0001",
"plan_uuid": u"pl_eed05d54-75b4-431b-adb2-eb6b9e543206"
}).__dict__)
def test_cancel_subscription(self, mock_requests):
""" Test cancel (patch) subscription (cancelled_at).
"""
mock_requests.register_uri(
'PATCH',
"https://api.chartmogul.com/v1/import/subscriptions/some_uuid",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json={
"uuid": "some_uuid",
"external_id": "sub_0001",
"customer_uuid": "cus_f466e33d-ff2b-4a11-8f85-417eb02157a7",
"plan_uuid": "pl_eed05d54-75b4-431b-adb2-eb6b9e543206",
"cancellation_dates": ["2016-01-15T00:00:00.000Z"],
"data_source_uuid": "ds_fef05d54-47b4-431b-aed2-eb6b9e545430"
}
)
config = Config("token", "secret") # is actually checked in mock
result = Subscription.cancel(config,
uuid="some_uuid",
data={
"cancelled_at": datetime(2016, 1, 15, 0, 0, 0)
}).get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(), {
"cancelled_at": "2016-01-15T00:00:00"})
self.assertTrue(isinstance(result, Subscription))
self.assertEqual(result.uuid, "some_uuid")
def test_create_plan(self, mock_requests):
expected_plan_dict = {
"uuid": u"whatever_uuid",
"data_source_uuid": u"some_uuid",
"name": u"new_name",
"interval_count": 2,
"interval_unit": u"moonshines",
"external_id": u"custom_filter"
}
sent = {
"data_source_uuid": "ds_9bb53a1e-edfd-11e6-bf83-af49e978cb11",
"name": "Gold Plan",
"interval_count": 1,
"interval_unit": "month",
"external_id": "plan_0002"
}
mock_requests.register_uri(
'POST',
"https://api.chartmogul.com/v1/plans",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json=expected_plan_dict)
config = Config("token", "secret") # is actually checked in mock
plan = Plan.create(config, data=sent).get()
expected = Plan(**expected_plan_dict)
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(), sent)
self.assertEqual(str(plan), str(expected))
def test_modify_plan(self, mock_requests):
expected_plan_dict = {
"uuid": u"whatever_uuid",
"data_source_uuid": u"some_uuid",
"name": u"new_name",
"interval_count": 2,
"interval_unit": u"moonshines",
"external_id": u"custom_filter"
}
mock_requests.register_uri(
'PATCH',
"https://api.chartmogul.com/v1/plans/whatever_uuid",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json=expected_plan_dict)
config = Config("token", "secret") # is actually checked in mock
plan = Plan.modify(config,
uuid="whatever_uuid",
data={
"name": "new_name"
}).get()
expected = Plan(**expected_plan_dict)
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(),
{"name": u"new_name"})
self.assertEqual(str(plan), str(expected))
def test_create(self, mock_requests):
mock_requests.register_uri('POST',
"https://api.chartmogul.com/v1/customers",
status_code=200,
json=docsListSample["entries"][0])
config = Config("token", "secret")
Customer.create(config, data=createCustomer).get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(), sentCreateExpected)
def test_destroy_plan_group(self, mock_requests):
mock_requests.register_uri(
'DELETE',
"https://api.chartmogul.com/v1/plan_groups/my_uuid",
status_code=204)
config = Config("token", "secret")
result = PlanGroup.destroy(config, uuid="my_uuid").get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.text, None)
self.assertEqual(result, None)
def test_delete(self, mock_requests):
mock_requests.register_uri(
'DELETE', ("https://api.chartmogul.com/v1/invoices"
"/inv_f466e33d-ff2b-4a11-8f85-417eb02157a7"),
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=204)
config = Config("token", "secret") # is actually checked in mock
result = Invoice.destroy(
config, uuid='inv_f466e33d-ff2b-4a11-8f85-417eb02157a7').get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertTrue(result is None)
def test_retrieve(self, mock_requests):
mock_requests.register_uri(
'GET',
"https://api.chartmogul.com/v1/account",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json=jsonResponse)
config = Config("token", "secret") # is actually checked in mock
account = Account.retrieve(config).get()
self.assertTrue(isinstance(account, Account))
self.assertEqual(account.name, "Example Test Company")
self.assertEqual(account.currency, "EUR")
self.assertEqual(account.time_zone, "Europe/Berlin")
self.assertEqual(account.week_start_on, "sunday")
def test_search(self, mock_requests):
mock_requests.register_uri(
'GET',
"https://api.chartmogul.com/v1/customers/[email protected]",
status_code=200,
json=docsListSample)
config = Config("token", "secret")
result = Customer.search(config, email='*****@*****.**').get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs,
{'email': ['*****@*****.**']})
self.assertEqual(mock_requests.last_request.text, None)
self.assertTrue(isinstance(result, Customer._many))
self.assertTrue(isinstance(result.entries[0], Customer))
def test_add_to_email(self, mock_requests):
mock_requests.register_uri(
'POST',
'https://api.chartmogul.com/v1/customers/CUSTOMER_UUID/attributes/custom',
status_code=200,
json=jsonResponse2)
config = Config('token', 'secret')
result = CustomAttributes.add(config,
uuid='CUSTOMER_UUID',
data=jsonRequest2).get()
self.assertEqual(mock_requests.call_count, 1, 'expected call')
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(), jsonRequest2)
def test_ping(self, mock_requests):
mock_requests.register_uri(
'GET',
"https://api.chartmogul.com/v1/ping",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json={"data": "pong!"}
)
config = Config("token", "secret") # is actually checked in mock
pong = Ping.ping(config).get()
expected = Ping(**{"data": u"pong!"})
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.text, None)
self.assertEqual(str(pong), str(expected))
def test_delete_not_found(self, mock_requests):
mock_requests.register_uri(
'DELETE', ("https://api.chartmogul.com/v1/invoices"
"/inv_f466e33d-ff2b-4a11-8f85-417eb02157a7"),
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
headers={'Content-Type': 'application/json'},
status_code=404,
json={'error': 'Invoice not found'})
config = Config("token", "secret") # is actually checked in mock
with self.assertRaises(APIError) as context:
result = Invoice.destroy(
config, uuid='inv_f466e33d-ff2b-4a11-8f85-417eb02157a7').get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
def test_create(self, mock_requests):
mock_requests.register_uri(
'POST',
"https://api.chartmogul.com/v1/import/customers/UUID/invoices",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json=responseData)
config = Config("token", "secret") # is actually checked in mock
result = Invoice.create(config, uuid="UUID", data=requestData).get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(), requestSerialized)
# Struct too complex to do 1:1 comparison
self.assertTrue(isinstance(result, Invoice._many))
self.assertEqual(len(result.invoices), 1)
def test_api_incorrect(self, mock_requests):
mock_requests.register_uri(
'POST',
"https://api.chartmogul.com/v1/data_sources",
status_code=400,
json={
"code": 400,
"message": "Parameter \"name\" is missing",
"param": "name"
})
config = Config("token", "secret")
try:
DataSource.create(config, data={"xname": "abc"}).get()
except APIError as err:
self.assertTrue(isinstance(err.__cause__, HTTPError))
else:
self.fail('ArgumentMissingError not raised')
def test_forget_uuid_destroy(self, mock_requests):
mock_requests.register_uri(
'DELETE',
"https://api.chartmogul.com/v1/data_sources/my_uuid",
status_code=204)
mock_requests.register_uri(
'DELETE',
"https://api.chartmogul.com/v1/data_sources",
status_code=404,
text="Not found")
config = Config("token", "secret")
try:
res = DataSource.destroy(config).get()
except ArgumentMissingError:
pass
else:
self.fail('ArgumentMissingError not raised')
def test_delete_all(self, mock_requests):
mock_requests.register_uri(
'DELETE', ("https://api.chartmogul.com/v1/data_sources"
"/ds_f466e33d-ff2b-4a11-8f85-417eb02157a7/customers"
"/cus_f466e33d-ff2b-4a11-8f85-417eb02157a7/invoices"),
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
headers={'Content-Type': 'application/json'},
status_code=204)
config = Config("token", "secret") # is actually checked in mock
result = Invoice.destroy_all(
config,
data_source_uuid='ds_f466e33d-ff2b-4a11-8f85-417eb02157a7',
customer_uuid='cus_f466e33d-ff2b-4a11-8f85-417eb02157a7').get()
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertTrue(result is None)
def test_date_serialization(self, mock_requests):
mock_requests.register_uri(
'POST',
"https://api.chartmogul.com/v1/data_sources",
status_code=200, # whatever, not testing this
json={'data_sources': []})
config = Config("token", "secret")
DataSource.create(config, data={"test_date": date(2015, 1, 1)}).get()
self.assertEqual(mock_requests.last_request.json(),
{"test_date": u"2015-01-01"})
DataSource.create(config,
data={
"test_datetime": datetime(2015, 1, 1, 1, 2, 3)
}).get()
self.assertEqual(mock_requests.last_request.json(),
{'test_datetime': u'2015-01-01T01:02:03'})
def test_add(self, mock_requests):
requestData = {"tags": ["important", "Prio1"]}
expected_dict = {
"tags":
[u"engage", u"unit loss", u"discountable", u"important", u"Prio1"]
}
mock_requests.register_uri(
'POST',
"https://api.chartmogul.com/v1/customers/UUID/attributes/tags",
request_headers={'Authorization': 'Basic dG9rZW46c2VjcmV0'},
status_code=200,
json=expected_dict)
config = Config("token", "secret") # is actually checked in mock
tags = Tags.add(config, uuid="UUID", data=requestData).get()
expected = Tags(**expected_dict)
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(mock_requests.last_request.qs, {})
self.assertEqual(mock_requests.last_request.json(), requestData)
self.assertEqual(str(tags), str(expected))
def test_cursor_list_plans(self, mock_requests):
expected_plan_dict = {
"uuid": u"whatever_uuid",
"data_source_uuid": u"some_uuid",
"name": u"some plan",
"interval_count": 2,
"interval_unit": u"moonshines",
"external_id": u"custom_filter"
}
mock_requests.register_uri('GET', (
"https://api.chartmogul.com/v1/plans?page=5"
"&per_page=12&data_source_uuid=some_uuid&external_id=custom_filter"
),
request_headers={
'Authorization':
'Basic dG9rZW46c2VjcmV0'
},
status_code=200,
json={
"plans": [expected_plan_dict],
"current_page": 5,
"total_pages": 18
})
config = Config("token", "secret") # is actually checked in mock
plan = Plan.all(config,
page=5,
per_page=12,
data_source_uuid="some_uuid",
external_id="custom_filter").get()
expected = Plan._many([Plan(**expected_plan_dict)],
current_page=5,
total_pages=18)
self.assertEqual(mock_requests.call_count, 1, "expected call")
self.assertEqual(
mock_requests.last_request.qs, {
'data_source_uuid': ['some_uuid'],
'external_id': ['custom_filter'],
'page': ['5'],
'per_page': ['12']
})
self.assertEqual(mock_requests.last_request.text, None)
self.assertEqual(str(plan), str(expected))
