class TestKoordinatesURLHandling(unittest.TestCase):
def contains_substring(self, strtosearch, strtosearchfor):
return strtosearch.lower().find(strtosearchfor) > -1
def setUp(self):
self.client = Client("koordinates.com", 'test')
self.testclient = Client("test.koordinates.com", 'test')
def test_sets_url(self):
self.assertEqual(self.client.get_url('SET', 'GET', 'single', {'id':999}),
'''https://koordinates.com/services/api/v1/sets/999/''')
def test_sets_domain_url(self):
self.assertEqual(self.testclient.get_url('SET', 'GET', 'single', {'id':999}),
'''https://test.koordinates.com/services/api/v1/sets/999/''')
def test_sets_multi_url(self):
self.assertEqual(self.client.get_url('SET', 'GET', 'multi'),
'''https://koordinates.com/services/api/v1/sets/''')
def test_layers_url(self):
self.assertEqual(self.client.get_url('LAYER', 'GET', 'single', {'id':999}),
'''https://koordinates.com/services/api/v1/layers/999/''')
def test_layers_multi_url(self):
self.assertEqual(self.client.get_url('LAYER', 'GET', 'multi'),
'''https://koordinates.com/services/api/v1/layers/''')
def test_layer_versions_url(self, layer_id=1494, version_id=4067):
self.assertEqual(self.client.get_url('VERSION', 'GET', 'single', {'layer_id':layer_id, 'version_id':version_id}),
'''https://koordinates.com/services/api/v1/layers/1494/versions/4067/''')
def test_layer_versions_multi_url(self, layer_id=1494, version_id=4067):
self.assertEqual(self.client.get_url('VERSION', 'GET', 'multi', {'layer_id':layer_id}),
'''https://koordinates.com/services/api/v1/layers/1494/versions/''')
class CatalogTests(unittest.TestCase):
def setUp(self):
self.client = Client(token='test', host='test.koordinates.com')
@responses.activate
def test_result_classes(self):
responses.add(responses.GET,
self.client.get_url('CATALOG', 'GET', 'multi'),
body=response_1,
status=200,
content_type='application/json')
results = list(self.client.catalog.list())
self.assertEqual(len(results), 14)
self.assert_(isinstance(results[0], Table))
self.assert_(isinstance(results[2], Layer))
# TODO: Document
self.assert_(isinstance(results[7], dict))
self.assert_("/documents/" in results[7]["url"])
self.assert_(isinstance(results[12], Set))
@responses.activate
def test_latest(self):
responses.add(responses.GET,
self.client.get_url('CATALOG', 'GET', 'latest'),
body=response_1,
status=200,
content_type='application/json')
results = list(self.client.catalog.list_latest())
self.assertEqual(len(results), 14)
results = list(self.client.catalog.list_latest().filter(
version__status='importing'))
self.assertEqual(len(results), 14)
def test_nocreate(self):
with self.assertRaises(TypeError):
CatalogEntry()
def test_no_get(self):
with self.assertRaises(NotImplementedError):
self.client.catalog.get(1)
class CatalogTests(unittest.TestCase):
def setUp(self):
self.client = Client(token='test', host='test.koordinates.com')
@responses.activate
def test_result_classes(self):
responses.add(responses.GET,
self.client.get_url('CATALOG', 'GET', 'multi'),
body=response_1, status=200,
content_type='application/json')
results = list(self.client.catalog.list())
self.assertEqual(len(results), 14)
self.assert_(isinstance(results[0], Table))
self.assert_(isinstance(results[2], Layer))
# TODO: Document
self.assert_(isinstance(results[7], dict))
self.assert_("/documents/" in results[7]["url"])
self.assert_(isinstance(results[12], Set))
@responses.activate
def test_latest(self):
responses.add(responses.GET,
self.client.get_url('CATALOG', 'GET', 'latest'),
body=response_1, status=200,
content_type='application/json')
results = list(self.client.catalog.list_latest())
self.assertEqual(len(results), 14)
results = list(self.client.catalog.list_latest().filter(version__status='importing'))
self.assertEqual(len(results), 14)
def test_nocreate(self):
with self.assertRaises(TypeError):
CatalogEntry()
def test_no_get(self):
with self.assertRaises(NotImplementedError):
self.client.catalog.get(1)
class TestKoordinatesURLHandling(unittest.TestCase):
def contains_substring(self, strtosearch, strtosearchfor):
return strtosearch.lower().find(strtosearchfor) > -1
def setUp(self):
self.client = Client("koordinates.com", 'test')
self.testclient = Client("test.koordinates.com", 'test')
def test_sets_url(self):
self.assertEqual(
self.client.get_url('SET', 'GET', 'single', {'id': 999}),
'''https://koordinates.com/services/api/v1/sets/999/''')
def test_sets_domain_url(self):
self.assertEqual(
self.testclient.get_url('SET', 'GET', 'single', {'id': 999}),
'''https://test.koordinates.com/services/api/v1/sets/999/''')
def test_sets_multi_url(self):
self.assertEqual(self.client.get_url('SET', 'GET', 'multi'),
'''https://koordinates.com/services/api/v1/sets/''')
def test_layers_url(self):
self.assertEqual(
self.client.get_url('LAYER', 'GET', 'single', {'id': 999}),
'''https://koordinates.com/services/api/v1/layers/999/''')
def test_layers_multi_url(self):
self.assertEqual(
self.client.get_url('LAYER', 'GET', 'multi'),
'''https://koordinates.com/services/api/v1/layers/''')
def test_layer_versions_url(self, layer_id=1494, version_id=4067):
self.assertEqual(
self.client.get_url('VERSION', 'GET', 'single', {
'layer_id': layer_id,
'version_id': version_id
}),
'''https://koordinates.com/services/api/v1/layers/1494/versions/4067/'''
)
def test_layer_versions_multi_url(self, layer_id=1494, version_id=4067):
self.assertEqual(
self.client.get_url('VERSION', 'GET', 'multi',
{'layer_id': layer_id}),
'''https://koordinates.com/services/api/v1/layers/1494/versions/'''
)
def setUp(self):
self.client = Client(token='test', host='test.koordinates.com')
class MetadataTests(unittest.TestCase):
def setUp(self):
self.client = Client(token='test', host='test.koordinates.com')
@responses.activate
def test_existing(self):
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single',
{'id': 1474}),
body=layers_version_single_good_simulated_response,
status=200,
content_type='application/json')
responses.add(
responses.GET,
"https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/dc/",
body="<dc>",
status=200,
content_type='text/xml')
responses.add(
responses.GET,
"https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/",
body="<native>",
status=200,
content_type='text/xml')
layer = self.client.layers.get(1474)
self.assert_(isinstance(layer.metadata, Metadata))
self.assertEqual(
layer.metadata.dc,
"https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/dc/"
)
self.assertEqual(set(layer.metadata.get_formats()), set(["iso", "dc"]))
self.assertEqual(layer.metadata._is_bound, True)
@responses.activate
def test_get_xml(self):
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single',
{'id': 1474}),
body=layers_version_single_good_simulated_response,
status=200,
content_type='application/json')
responses.add(
responses.GET,
"https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/dc/",
body="<dc>",
status=200,
content_type='text/xml')
responses.add(
responses.GET,
"https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/",
body="<native>",
status=200,
content_type='text/xml')
layer = self.client.layers.get(1474)
s = six.BytesIO()
layer.metadata.get_xml(s, layer.metadata.FORMAT_DC)
self.assertEqual(s.getvalue().decode("utf-8"), "<dc>")
s = six.BytesIO()
layer.metadata.get_xml(s, layer.metadata.FORMAT_NATIVE)
self.assertEqual(s.getvalue().decode("utf-8"), "<native>")
@responses.activate
def test_layer_set_xml(self):
lv_url = self.client.get_url('VERSION', 'GET', 'single', {
'layer_id': 1474,
'version_id': 4067
})
responses.add(responses.GET,
lv_url,
body=layers_version_single_good_simulated_response,
status=200,
content_type='application/json')
responses.add(responses.POST,
lv_url + 'metadata/',
body="",
status=204,
adding_headers={"Location": lv_url + 'metadata/'})
layer = self.client.layers.get_version(1474, 4067)
old_meta = layer.metadata
s = six.StringIO("<test>")
layer.set_metadata(s)
self.assertEqual(s.getvalue(), "<test>")
# load layer, set metadata, reload layer
self.assertEqual(len(responses.calls), 3)
self.assert_(isinstance(responses.calls[1].request.body, six.StringIO))
self.assertEqual(responses.calls[1].request.body.getvalue(), "<test>")
self.assert_(isinstance(layer.metadata, Metadata))
self.assert_(layer.metadata is not old_meta)
@responses.activate
def test_layer_set_xml_manager(self):
lv_url = self.client.get_url('VERSION', 'GET', 'single', {
'layer_id': 1474,
'version_id': 4067
})
responses.add(responses.GET,
lv_url,
body=layers_version_single_good_simulated_response,
status=200,
content_type='application/json')
responses.add(responses.POST,
lv_url + 'metadata/',
body="",
status=204,
adding_headers={"Location": lv_url + 'metadata/'})
s = six.StringIO("<test>")
r = self.client.layers.set_metadata(1474, 4067, s)
self.assertEqual(len(responses.calls), 1)
self.assert_(isinstance(responses.calls[0].request.body, six.StringIO))
self.assertEqual(responses.calls[0].request.body.getvalue(), "<test>")
self.assertEqual(r, None)
def setUp(self):
self.client = Client(token='test', host='test.koordinates.com')
class TestKoordinates(unittest.TestCase):
def contains_substring(self, strtosearch, strtosearchfor):
return strtosearch.lower().find(strtosearchfor) > -1
def setUp(self):
self.client = Client(token='test', host='koordinates.com')
self.test_client = Client(token='test', host="test.koordinates.com")
self.bad_client = Client(token='bad', host='koordinates.com')
def test_instantiate_group_class(self):
g = koordinates.Group(id=99, url="http//example.com", name="Group Name", country="NZ")
self.assertEqual(g.id, 99)
self.assertTrue(self.contains_substring(g.url, "example"))
self.assertEqual(g.name, "Group Name")
self.assertEqual(g.country, "NZ")
def test_instantiate_data_class(self):
d = layers.LayerData(encoding=None,
crs="EPSG:2193",
geometry_field="GEOMETRY"
)
self.assertEqual(d.encoding, None)
self.assertEqual(d.crs, "EPSG:2193")
self.assertEqual(d.geometry_field, "GEOMETRY")
@unittest.skip("FIXME")
def test_instantiate_datasource_class(self):
ds = layers.Datasource(99)
self.assertEqual(ds.id, 99)
@unittest.skip("FIXME")
def test_instantiate_field_class(self):
f = koordinates.Field("Field Name", "integer")
self.assertEqual(f.name, "Field Name")
self.assertEqual(f.type, "integer")
@responses.activate
def test_get_layerset_bad_auth_check_status(self):
the_response = '''{"detail": "Authentication credentials were not provided."}'''
responses.add(responses.GET,
self.bad_client.get_url('LAYER', 'GET', 'multi'),
body=the_response, status=401,
content_type='application/json')
with self.assertRaises(exceptions.AuthenticationError):
for layer in self.bad_client.layers.list():
pass
@responses.activate
def test_create_layer(self):
the_response = layer_create_good_simulated_response
responses.add(responses.POST,
self.client.get_url('LAYER', 'POST', 'create'),
body=the_response, status=201,
content_type='application/json')
obj_lyr = koordinates.Layer()
obj_lyr.name = "A Test Layer Name for Unit Testing"
obj_lyr.group = 263
obj_lyr.data = layers.LayerData(datasources = [144355])
result_layer = self.client.layers.create(obj_lyr)
self.assert_(result_layer is obj_lyr)
self.assertEqual(obj_lyr.created_at.year, 2015)
self.assertEqual(obj_lyr.created_at.month, 6)
self.assertEqual(obj_lyr.created_at.day, 11)
self.assertEqual(obj_lyr.created_at.hour, 11)
self.assertEqual(obj_lyr.created_at.minute, 14)
self.assertEqual(obj_lyr.created_at.second, 10)
self.assertEqual(obj_lyr.created_by, 18504)
# FIXME: API should return a full response
# self.assertEqual(obj_lyr.group.id, 263)
# self.assertEqual(obj_lyr.group.url, "https://test.koordinates.com/services/api/v1/groups/{}/".format(obj_lyr.group.id))
# self.assertEqual(obj_lyr.group.name, "Wellington City Council")
# self.assertEqual(obj_lyr.group.country, "NZ")
@responses.activate
def test_get_layerset_bad_auth_check_exception(self):
the_response = '''{"detail": "Authentication credentials were not provided."}'''
responses.add(responses.GET,
self.bad_client.get_url('LAYER', 'GET', 'multi'),
body=the_response, status=401,
content_type='application/json')
with self.assertRaises(exceptions.AuthenticationError):
for layer in self.bad_client.layers.list():
pass
@responses.activate
def test_get_layerset_returns_all_rows(self):
the_response = layers_multiple_good_simulated_response
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'multi'),
body=the_response, status=200,
content_type='application/json')
cnt_of_layers_returned = 0
#import pdb;pdb.set_trace()
for layer in self.client.layers.list():
cnt_of_layers_returned += 1
#import pdb;pdb.set_trace()
self.assertEqual(cnt_of_layers_returned, 100)
@responses.activate
def test_get_draft_layerset_returns_all_rows(self):
the_response = good_multi_layers_drafts_response
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'multidraft'),
body=the_response, status=200,
content_type='application/json')
cnt_of_draft_layers_returned = 0
for layer in self.client.layers.list_drafts():
cnt_of_draft_layers_returned += 1
self.assertEqual(cnt_of_draft_layers_returned, 12)
@responses.activate
def test_get_draft_layerset_test_characteristics_of_response(self):
the_response = good_multi_layers_drafts_response
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'multidraft'),
body=the_response, status=200,
content_type='application/json')
cnt_of_draft_layers_returned = 0
#import pdb;pdb.set_trace()
for layer in self.client.layers.list_drafts():
if cnt_of_draft_layers_returned == 0:
self.assertEqual(layer.id, 7955)
self.assertEqual(layer.name, "Built-Up Area")
self.assertEqual(layer.first_published_at.year, 2015)
self.assertEqual(layer.first_published_at.month, 4)
self.assertEqual(layer.first_published_at.day, 21)
self.assertEqual(layer.first_published_at.hour, 0)
self.assertEqual(layer.first_published_at.minute, 59)
self.assertEqual(layer.first_published_at.second, 55)
if cnt_of_draft_layers_returned == 11:
self.assertEqual(layer.id, 8113)
self.assertEqual(layer.name, "shea-test-layer-14")
cnt_of_draft_layers_returned += 1
# This test is now impossible to conduct with the change in the way the
# the URL templates are populated - part of which is that the hostname
# is picked up at a higher level than previously. I'm putting this one
# on ice until other things have stablilised at which point changes should
# be made sufficient to allow this test or one of corresponding capability
# @responses.activate
# def test_get_layerset_with_non_default_host(self):
# filter_value = str(uuid.uuid1())
# test_domain = str(uuid.uuid1()).replace("-", "")
# order_by_key = 'name'
# test_host_name = "{fakedomain}.com".format(fakedomain=test_domain)
# self.clientalthost = Client('test', test_host_name)
# self.clientalthost.layer.get_list().filter(filter_value).order_by(order_by_key)
# parsedurl = urllib.parse.urlparse(self.clientalthost.layer.url)
# self.assertTrue(self.contains_substring(parsedurl.hostname, test_host_name))
# self.assertEqual(parsedurl.hostname, test_host_name)
@responses.activate
def test_get_layerset_filter(self):
q = self.client.layers.list().filter(kind='vector')
parsedurl = urllib.parse.urlparse(q._to_url())
self.assertTrue(self.contains_substring(parsedurl.query, 'kind=vector'))
@responses.activate
def test_get_layerset_sort(self):
q = self.client.layers.list().order_by('name')
parsedurl = urllib.parse.urlparse(q._to_url())
self.assertTrue(self.contains_substring(parsedurl.query, 'sort=name'))
@responses.activate
def test_get_layer_with_timeout(self, id=1474):
the_response = "{}"
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single', {'id': id}),
body=the_response, status=504,
content_type='application/json')
with self.assertRaises(exceptions.ServiceUnvailable):
obj = self.client.layers.get(id)
@responses.activate
def test_get_layer_with_rate_limiting(self, id=1474):
the_response = "{}"
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single', {'id': id}),
body=the_response, status=429,
content_type='application/json')
with self.assertRaises(exceptions.RateLimitExceeded):
obj = self.client.layers.get(id)
@responses.activate
def test_layer_import(self):
the_response = layers_single_good_simulated_response
layer_id = 999
version_id = 998
responses.add(responses.POST,
self.test_client.get_url('VERSION', 'POST', 'import', {'version_id': version_id,'layer_id': layer_id}),
body=the_response, status=202,
content_type='application/json')
self.test_client.layers.start_import(layer_id, version_id)
@responses.activate
def test_layer_hierarchy_of_classes(self):
the_response = layers_single_good_simulated_response
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single', {'id': 1474}),
body=the_response, status=200,
content_type='application/json')
obj = self.client.layers.get(1474)
self.assertEqual(obj.categories[0]['slug'], "cadastral")
self.assertEqual(obj.data.crs, "EPSG:2193")
self.assertEqual(obj.data.fields[0]['type'], "geometry")
# The following test changes form between Python 2.x and 3.x
try:
self.assertItemsEqual(obj.tags, ['building', 'footprint', 'outline', 'structure'])
except AttributeError:
self.assertCountEqual(obj.tags, ['building', 'footprint', 'outline', 'structure'])
@responses.activate
def test_layer_date_conversion(self, id=1474):
the_response = layers_single_good_simulated_response
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single', {'id':id}),
body=the_response, status=200,
content_type='application/json')
#import pdb;pdb.set_trace()
obj = self.client.layers.get(id)
self.assertEqual(obj.first_published_at.year, 2010)
self.assertEqual(obj.first_published_at.month, 6)
self.assertEqual(obj.first_published_at.day, 21)
self.assertEqual(obj.first_published_at.hour, 5)
self.assertEqual(obj.first_published_at.minute, 5)
self.assertEqual(obj.first_published_at.second, 5)
self.assertEqual(obj.collected_at[0].year, 1996)
self.assertEqual(obj.collected_at[0].month, 12)
self.assertEqual(obj.collected_at[0].day, 31)
self.assertEqual(obj.collected_at[1].year, 2012)
self.assertEqual(obj.collected_at[1].month, 5)
self.assertEqual(obj.collected_at[1].day, 1)
self.assertEqual(obj.collected_at[1].hour, 0)
self.assertEqual(obj.collected_at[1].minute, 0)
self.assertEqual(obj.collected_at[1].second, 0)
@responses.activate
def test_get_layerset_bad_filter_and_sort(self):
with self.assertRaises(exceptions.ClientValidationError):
self.client.layers.list().filter(bad_attribute=True)
@responses.activate
def test_get_layerset_bad_sort(self):
with self.assertRaises(exceptions.ClientValidationError):
self.client.layers.list().order_by('bad_attribute')
@responses.activate
def test_get_layer_by_id_bad_auth(self, id=1474):
the_response = '''{"detail": "Authentication credentials were not provided."}'''
responses.add(responses.GET,
self.bad_client.get_url('LAYER', 'GET', 'single', {'id':id}),
body=the_response, status=401,
content_type='application/json')
try:
layer_obj = self.bad_client.layers.get(id)
except:
pass
with self.assertRaises(exceptions.AuthenticationError):
layer_obj = self.bad_client.layers.get(id)
@responses.activate
def test_get_layer_by_id(self, id=1474):
the_response = layers_single_good_simulated_response
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single', {'id':id}),
body=the_response, status=200,
content_type='application/json')
obj = self.client.layers.get(id)
self.assertEqual(obj.name,
"Wellington City Building Footprints")
#There is no way to do this test any more - it is implict
#since we started using 'raise_for_status'
#self.assertEqual(obj._raw_response.status_code,
# 200)
@responses.activate
def test_get_all_layer_version_by_layer_id(self):
the_response = single_layer_all_versions_good_response
responses.add(responses.GET,
self.client.get_url('VERSION','GET', 'multi', {'layer_id':1474}),
body=the_response, status=200,
content_type='application/json')
cnt_of_versions_returned = 0
for version in self.client.layers.list_versions(layer_id=1474):
cnt_of_versions_returned += 1
self.assertEqual(cnt_of_versions_returned, 2)
self.assertEqual(version.id, 32)
self.assertEqual(version.status, "ok")
self.assertEqual(version.created_by, 2879)
class MetadataTests(unittest.TestCase):
def setUp(self):
self.client = Client(token='test', host='test.koordinates.com')
@responses.activate
def test_existing(self):
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single', {'id': 1474}),
body=layers_version_single_good_simulated_response, status=200,
content_type='application/json')
responses.add(responses.GET,
"https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/dc/",
body="<dc>", status=200,
content_type='text/xml')
responses.add(responses.GET,
"https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/",
body="<native>", status=200,
content_type='text/xml')
layer = self.client.layers.get(1474)
self.assert_(isinstance(layer.metadata, Metadata))
self.assertEqual(layer.metadata.dc, "https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/dc/")
self.assertEqual(set(layer.metadata.get_formats()), set(["iso", "dc"]))
self.assertEqual(layer.metadata._is_bound, True)
@responses.activate
def test_get_xml(self):
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single', {'id': 1474}),
body=layers_version_single_good_simulated_response, status=200,
content_type='application/json')
responses.add(responses.GET,
"https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/dc/",
body="<dc>", status=200,
content_type='text/xml')
responses.add(responses.GET,
"https://koordinates.com/services/api/v1/layers/1474/versions/4067/metadata/",
body="<native>", status=200,
content_type='text/xml')
layer = self.client.layers.get(1474)
s = six.BytesIO()
layer.metadata.get_xml(s, layer.metadata.FORMAT_DC)
self.assertEqual(s.getvalue().decode("utf-8"), "<dc>")
s = six.BytesIO()
layer.metadata.get_xml(s, layer.metadata.FORMAT_NATIVE)
self.assertEqual(s.getvalue().decode("utf-8"), "<native>")
@responses.activate
def test_layer_set_xml(self):
lv_url = self.client.get_url('VERSION', 'GET', 'single', {'layer_id': 1474, 'version_id': 4067})
responses.add(responses.GET,
lv_url,
body=layers_version_single_good_simulated_response, status=200,
content_type='application/json')
responses.add(responses.POST,
lv_url + 'metadata/',
body="", status=204,
adding_headers={"Location": lv_url + 'metadata/'})
layer = self.client.layers.get_version(1474, 4067)
old_meta = layer.metadata
s = six.StringIO("<test>")
layer.set_metadata(s)
self.assertEqual(s.getvalue(), "<test>")
# load layer, set metadata, reload layer
self.assertEqual(len(responses.calls), 3)
self.assert_(isinstance(responses.calls[1].request.body, six.StringIO))
self.assertEqual(responses.calls[1].request.body.getvalue(), "<test>")
self.assert_(isinstance(layer.metadata, Metadata))
self.assert_(layer.metadata is not old_meta)
@responses.activate
def test_layer_set_xml_manager(self):
lv_url = self.client.get_url('VERSION', 'GET', 'single', {'layer_id': 1474, 'version_id': 4067})
responses.add(responses.GET,
lv_url,
body=layers_version_single_good_simulated_response, status=200,
content_type='application/json')
responses.add(responses.POST,
lv_url + 'metadata/',
body="", status=204,
adding_headers={"Location": lv_url + 'metadata/'})
s = six.StringIO("<test>")
r = self.client.layers.set_metadata(1474, 4067, s)
self.assertEqual(len(responses.calls), 1)
self.assert_(isinstance(responses.calls[0].request.body, six.StringIO))
self.assertEqual(responses.calls[0].request.body.getvalue(), "<test>")
self.assertEqual(r, None)
class TestSets(unittest.TestCase):
def setUp(self):
self.client = Client('koordinates.com', token='test')
@responses.activate
def test_get_set_by_id(self, id=1474):
the_response = sets_single_good_simulated_response
responses.add(responses.GET,
self.client.get_url('SET', 'GET', 'single',
{'id': 1474}),
body=the_response,
status=200,
content_type='application/json')
obj = self.client.sets.get(id)
self.assert_(isinstance(obj, Set))
self.assertEqual(obj.title, "Ultra Fast Broadband Initiative Coverage")
self.assertEqual(obj.group.name, "New Zealand Broadband Map")
self.assertEqual(
obj.url_html,
"https://koordinates.com/set/933-ultra-fast-broadband-initiative-coverage/"
)
@responses.activate
def test_get_set_set_returns_all_rows(self):
the_response = sets_multiple_good_simulated_response
responses.add(responses.GET,
self.client.get_url('SET', 'GET', 'multi'),
body=the_response,
status=200,
content_type='application/json')
cnt_of_sets_returned = 0
for layer in self.client.sets.list():
cnt_of_sets_returned += 1
self.assertEqual(cnt_of_sets_returned, 2)
@responses.activate
def test_set_create(self):
responses.add(responses.POST,
self.client.get_url('SET', 'POST', 'create'),
body=sets_single_good_simulated_response,
status=201,
adding_headers={
"Location":
"https://koordinates.com/services/api/v1/sets/933/"
})
responses.add(responses.GET,
self.client.get_url('SET', 'GET', 'single', {'id': 933}),
body=sets_single_good_simulated_response,
status=200)
s = Set()
s.title = 'test title'
s.description = 'description'
s.group = 141
s.items = [
"https://koordinates.com/services/api/v1/layers/4226/",
"https://koordinates.com/services/api/v1/layers/4228/",
"https://koordinates.com/services/api/v1/layers/4227/",
"https://koordinates.com/services/api/v1/layers/4061/",
"https://koordinates.com/services/api/v1/layers/4147/",
"https://koordinates.com/services/api/v1/layers/4148/",
]
rs = self.client.sets.create(s)
self.assert_(rs is s)
self.assert_(isinstance(s.group, Group))
self.assertEqual(s.group.id, 141)
self.assertEqual(len(responses.calls), 2)
req = json.loads(responses.calls[0].request.body)
self.assertEqual(len(req['items']), 6)
self.assertEqual(req['group'], 141)
@responses.activate
def test_set_update(self):
responses.add(responses.GET,
self.client.get_url('SET', 'GET', 'single', {'id': 933}),
body=sets_single_good_simulated_response,
status=200)
responses.add(responses.PUT,
self.client.get_url('SET', 'PUT', 'update', {'id': 933}),
body=sets_single_good_simulated_response,
status=200)
s = self.client.sets.get(933)
self.assertEqual(s.id, 933)
s.items = [
"https://koordinates.com/services/api/v1/layers/4226/",
]
s.save()
self.assertEqual(len(responses.calls), 2)
req = json.loads(responses.calls[1].request.body)
self.assertEqual(len(req['items']), 1)
# reset to the server-provided values
self.assertEqual(len(s.items), 6)
def setUp(self):
self.client = Client('koordinates.com', token='test')
class TestKoordinatesPublishing(unittest.TestCase):
def contains_substring(self, strtosearch, strtosearchfor):
return strtosearch.lower().find(strtosearchfor) > -1
def setUp(self):
self.client = Client(token='test', host='koordinates.com')
self.testclient = Client(token='test', host="test.koordinates.com")
@responses.activate
def test_publish_get_by_id(self):
the_response = publish_single_good_simulated_response
publish_id = 2054
responses.add(responses.GET,
self.client.get_url('PUBLISH', 'GET', 'single', {'id': publish_id}),
body=the_response, status=200,
content_type='application/json')
obj = self.client.publishing.get(publish_id)
self.assertEqual(obj.state, "completed")
self.assertEqual(obj.created_by.id, 18504)
self.assertEqual(len(obj.items), 1)
self.assertEqual(obj.items[0],
'https://test.koordinates.com/services/api/v1/layers/8092/versions/9822/')
self.assertEqual(obj.created_at.year, 2015)
self.assertEqual(obj.created_at.month, 6)
self.assertEqual(obj.created_at.day, 8)
self.assertEqual(obj.created_at.hour, 3)
self.assertEqual(obj.created_at.minute, 40)
self.assertEqual(obj.created_at.second, 40)
self.assertEqual(obj.created_by.id, 18504)
@responses.activate
def test_publish_get_all_rows(self):
the_response = publish_multiple_get_simulated_response
responses.add(responses.GET,
self.client.get_url('PUBLISH', 'GET', 'multi'),
body=the_response, status=200,
content_type='application/json')
cnt_of_publish_records_returned = 0
for pub_record in self.client.publishing.list():
if cnt_of_publish_records_returned == 0:
self.assertEqual(pub_record.id, 2054)
self.assertEqual(pub_record.error_strategy, 'abort')
cnt_of_publish_records_returned += 1
self.assertEqual(cnt_of_publish_records_returned, 7)
@unittest.skip("FIXME")
@responses.activate
def test_multipublish_resource_specification(self):
the_response = '''{}'''
responses.add(responses.POST,
self.testclient.get_url('PUBLISH', 'POST', 'create'),
body=the_response, status=500,
content_type='application/json')
pr = Publish()
pr.items = [
'https://test.koordinates.com/services/api/v1/layers/100/versions/1000/',
'https://test.koordinates.com/services/api/v1/layers/101/versions/1001/',
'https://test.koordinates.com/services/api/v1/layers/102/versions/1002/',
'https://test.koordinates.com/services/api/v1/tables/200/versions/2000/',
'https://test.koordinates.com/services/api/v1/tables/201/versions/2001/',
'https://test.koordinates.com/services/api/v1/tables/202/versions/2002/',
]
with self.assertRaises(exceptions.ServerError):
#the Responses mocking will result in a 999 being returned
self.testclient.publishing.create(pr)
@unittest.skip("FIXME")
@responses.activate
def test_multipublish_bad_args(self):
the_response = '''{}'''
responses.add(responses.POST,
self.testclient.get_url('PUBLISH', 'POST', 'create'),
body=the_response, status=500,
content_type='application/json')
pr = Publish()
with self.assertRaises(exceptions.ServerError):
#the Responses mocking will result in a 999 being returned
self.testclient.publishing.create(pr)
pr = Publish(publish_strategy=Publish.PUBLISH_STRATEGY_TOGETHER)
with self.assertRaises(exceptions.ServerError):
#the Responses mocking will result in a 999 being returned
self.testclient.publishing.create(pr)
pr = Publish(publish_strategy=Publish.PUBLISH_STRATEGY_TOGETHER, error_strategy=Publish.ERROR_STRATEGY_ABORT)
with self.assertRaises(exceptions.ServerError):
#the Responses mocking will result in a 999 being returned
self.testclient.publishing.create(pr)
@responses.activate
def test_publish_single_layer_version(self, layer_id=1474, version_id=4067):
the_response = layers_version_single_good_simulated_response
responses.add(responses.GET,
self.client.get_url('VERSION', 'GET', 'single', {'layer_id': layer_id, 'version_id': version_id}),
body=the_response, status=200,
content_type='application/json')
lv = self.client.layers.get_version(1474, 4067)
self.assertEqual(lv.id, 1474)
self.assertEqual(lv.version.id, 4067)
the_response = '''{"id": 2057, "url": "https://test.koordinates.com/services/api/v1/publish/2057/", "state": "publishing", "created_at": "2015-06-08T10:39:44.823Z", "created_by": {"id": 18504, "url": "https://test.koordinates.com/services/api/v1/users/18504/", "first_name": "Richard", "last_name": "Shea", "country": "NZ"}, "error_strategy": "abort", "publish_strategy": "together", "publish_at": null, "items": ["https://test.koordinates.com/services/api/v1/layers/1474/versions/4067/"]}'''
publish_url = "https://test.koordinates.com/services/api/v1/publish/2057/"
responses.add(responses.POST,
self.client.get_url('VERSION', 'POST', 'publish', {'layer_id': layer_id, 'version_id': version_id}),
body="", status=201, adding_headers={"Location": publish_url},
content_type='application/json')
responses.add(responses.GET,
publish_url,
body=the_response, status=200,
content_type='application/json')
p = lv.publish()
self.assert_(isinstance(p, Publish))
self.assertEquals(p.id, 2057)
@responses.activate
def test_cancel(self):
publish_id = 2054
responses.add(responses.GET,
self.client.get_url('PUBLISH', 'GET', 'single', {'id': publish_id}),
body=publish_single_good_simulated_response, status=200,
content_type='application/json')
responses.add(responses.DELETE,
self.client.get_url('PUBLISH', 'DELETE', 'single', {'id': publish_id}),
body="", status=204,
content_type='application/json')
obj = self.client.publishing.get(publish_id)
obj.cancel()
class TestKoordinatesPublishing(unittest.TestCase):
def contains_substring(self, strtosearch, strtosearchfor):
return strtosearch.lower().find(strtosearchfor) > -1
def setUp(self):
self.client = Client(token='test', host='koordinates.com')
self.testclient = Client(token='test', host="test.koordinates.com")
@responses.activate
def test_publish_get_by_id(self):
the_response = publish_single_good_simulated_response
publish_id = 2054
responses.add(responses.GET,
self.client.get_url('PUBLISH', 'GET', 'single',
{'id': publish_id}),
body=the_response,
status=200,
content_type='application/json')
obj = self.client.publishing.get(publish_id)
self.assertEqual(obj.state, "completed")
self.assertEqual(obj.created_by.id, 18504)
self.assertEqual(len(obj.items), 1)
self.assertEqual(
obj.items[0],
'https://test.koordinates.com/services/api/v1/layers/8092/versions/9822/'
)
self.assertEqual(obj.created_at.year, 2015)
self.assertEqual(obj.created_at.month, 6)
self.assertEqual(obj.created_at.day, 8)
self.assertEqual(obj.created_at.hour, 3)
self.assertEqual(obj.created_at.minute, 40)
self.assertEqual(obj.created_at.second, 40)
self.assertEqual(obj.created_by.id, 18504)
@responses.activate
def test_publish_get_all_rows(self):
the_response = publish_multiple_get_simulated_response
responses.add(responses.GET,
self.client.get_url('PUBLISH', 'GET', 'multi'),
body=the_response,
status=200,
content_type='application/json')
cnt_of_publish_records_returned = 0
for pub_record in self.client.publishing.list():
if cnt_of_publish_records_returned == 0:
self.assertEqual(pub_record.id, 2054)
self.assertEqual(pub_record.error_strategy, 'abort')
cnt_of_publish_records_returned += 1
self.assertEqual(cnt_of_publish_records_returned, 7)
@unittest.skip("FIXME")
@responses.activate
def test_multipublish_resource_specification(self):
the_response = '''{}'''
responses.add(responses.POST,
self.testclient.get_url('PUBLISH', 'POST', 'create'),
body=the_response,
status=500,
content_type='application/json')
pr = Publish()
pr.items = [
'https://test.koordinates.com/services/api/v1/layers/100/versions/1000/',
'https://test.koordinates.com/services/api/v1/layers/101/versions/1001/',
'https://test.koordinates.com/services/api/v1/layers/102/versions/1002/',
'https://test.koordinates.com/services/api/v1/tables/200/versions/2000/',
'https://test.koordinates.com/services/api/v1/tables/201/versions/2001/',
'https://test.koordinates.com/services/api/v1/tables/202/versions/2002/',
]
with self.assertRaises(exceptions.ServerError):
#the Responses mocking will result in a 999 being returned
self.testclient.publishing.create(pr)
@unittest.skip("FIXME")
@responses.activate
def test_multipublish_bad_args(self):
the_response = '''{}'''
responses.add(responses.POST,
self.testclient.get_url('PUBLISH', 'POST', 'create'),
body=the_response,
status=500,
content_type='application/json')
pr = Publish()
with self.assertRaises(exceptions.ServerError):
#the Responses mocking will result in a 999 being returned
self.testclient.publishing.create(pr)
pr = Publish(publish_strategy=Publish.PUBLISH_STRATEGY_TOGETHER)
with self.assertRaises(exceptions.ServerError):
#the Responses mocking will result in a 999 being returned
self.testclient.publishing.create(pr)
pr = Publish(publish_strategy=Publish.PUBLISH_STRATEGY_TOGETHER,
error_strategy=Publish.ERROR_STRATEGY_ABORT)
with self.assertRaises(exceptions.ServerError):
#the Responses mocking will result in a 999 being returned
self.testclient.publishing.create(pr)
@responses.activate
def test_publish_single_layer_version(self,
layer_id=1474,
version_id=4067):
the_response = layers_version_single_good_simulated_response
responses.add(responses.GET,
self.client.get_url('VERSION', 'GET', 'single', {
'layer_id': layer_id,
'version_id': version_id
}),
body=the_response,
status=200,
content_type='application/json')
lv = self.client.layers.get_version(1474, 4067)
self.assertEqual(lv.id, 1474)
self.assertEqual(lv.version.id, 4067)
the_response = '''{"id": 2057, "url": "https://test.koordinates.com/services/api/v1/publish/2057/", "state": "publishing", "created_at": "2015-06-08T10:39:44.823Z", "created_by": {"id": 18504, "url": "https://test.koordinates.com/services/api/v1/users/18504/", "first_name": "Richard", "last_name": "Shea", "country": "NZ"}, "error_strategy": "abort", "publish_strategy": "together", "publish_at": null, "items": ["https://test.koordinates.com/services/api/v1/layers/1474/versions/4067/"]}'''
publish_url = "https://test.koordinates.com/services/api/v1/publish/2057/"
responses.add(responses.POST,
self.client.get_url('VERSION', 'POST', 'publish', {
'layer_id': layer_id,
'version_id': version_id
}),
body="",
status=201,
adding_headers={"Location": publish_url},
content_type='application/json')
responses.add(responses.GET,
publish_url,
body=the_response,
status=200,
content_type='application/json')
p = lv.publish()
self.assert_(isinstance(p, Publish))
self.assertEquals(p.id, 2057)
@responses.activate
def test_cancel(self):
publish_id = 2054
responses.add(responses.GET,
self.client.get_url('PUBLISH', 'GET', 'single',
{'id': publish_id}),
body=publish_single_good_simulated_response,
status=200,
content_type='application/json')
responses.add(responses.DELETE,
self.client.get_url('PUBLISH', 'DELETE', 'single',
{'id': publish_id}),
body="",
status=204,
content_type='application/json')
obj = self.client.publishing.get(publish_id)
obj.cancel()
class TestTokens(unittest.TestCase):
def setUp(self):
self.client = Client(token='test', host='test.koordinates.com')
@responses.activate
def test_get_all_tokens_for_user(self):
the_response = token_get_multiple_tokens_good_response
responses.add(responses.GET,
self.client.get_url('TOKEN', 'GET', 'multi'),
body=the_response, status=200,
content_type='application/json')
cnt_of_sets_returned = 0
is_first = True
for token in self.client.tokens.list():
cnt_of_sets_returned += 1
if is_first:
is_first = False
self.assertEqual(token.name, "")
self.assertEqual(token.key_hint, "0fooxx...")
self.assertEqual(token.url, "https://test.koordinates.com/services/api/v1/tokens/987654/")
self.assert_(token._is_bound)
self.assertEqual(cnt_of_sets_returned, 1)
@responses.activate
def test_get_individual_tokens_by_id(self):
the_response = token_get_single_token_good_response
responses.add(responses.GET,
self.client.get_url('TOKEN', 'GET', 'single', {'id':987654}),
body=the_response, status=200,
content_type='application/json')
obj_tok = self.client.tokens.get(987654)
self.assert_(isinstance(obj_tok, Token))
self.assert_(obj_tok._is_bound)
self.assertEqual(obj_tok.name, "")
self.assertEqual(obj_tok.key_hint, "0fooxx...")
self.assertEqual(obj_tok.url, "https://test.koordinates.com/services/api/v1/tokens/987654/")
self.assertEqual(obj_tok.created_at.year, 2015)
self.assertEqual(obj_tok.created_at.hour, 5)
self.assertEqual(obj_tok.expires_at, None)
@responses.activate
def test_create_token_good(self):
the_response = token_good_create
responses.add(responses.POST,
self.client.get_url('TOKEN', 'POST', 'create'),
body=the_response, status=200,
content_type='application/json')
obj_tok = Token(name='Sample Token for Testing')
obj_tok.scope = "query tiles catalog wxs:wfs wxs:wms wxs:wcs documents:read documents:write layers:read layers:write sets:read sets:write sources:read sources:write users:read users:write tokens:read tokens:write"
obj_tok.expires_at = '2015-08-01T08:00:00Z'
obj_tok_new = self.client.tokens.create(obj_tok, '*****@*****.**', 'foobar')
self.assert_(isinstance(obj_tok_new, Token))
self.assertEqual(obj_tok_new.name, "Sample Token for Testing")
self.assertEqual(obj_tok_new.key_hint, "7fooxx...")
self.assertEqual(obj_tok_new.url, "https://test.koordinates.com/services/api/v1/tokens/987659/")
self.assertEqual(obj_tok_new.created_at.year, 2015)
self.assertEqual(obj_tok_new.created_at.hour, 1)
self.assertEqual(obj_tok_new.expires_at.year, 2015)
self.assertEqual(obj_tok_new.expires_at.hour, 8)
self.assertEqual(obj_tok_new.key, '77777777777777777777777777777777')
@responses.activate
def test_delete_token_good(self):
the_response = ""
responses.add(responses.DELETE,
self.client.get_url('TOKEN', 'DELETE', 'single', {'id':987654}),
body=the_response, status=204,
content_type='application/json')
self.client.tokens.delete(987654)
@responses.activate
def test_update_token(self):
the_response = token_get_single_token_good_response
responses.add(responses.GET,
self.client.get_url('TOKEN', 'GET', 'single', {'id':987654}),
body=the_response, status=200,
content_type='application/json')
responses.add(responses.PUT,
self.client.get_url('TOKEN', 'PUT', 'update', {'id':987654}),
body=the_response, status=200,
content_type='application/json')
obj_tok = self.client.tokens.get(987654)
self.assert_(isinstance(obj_tok, Token))
obj_tok.expires_at = datetime(2011, 1, 2, 3, 45)
obj_tok.scopes = ['layers:read', 'layers:write']
self.assertEqual(obj_tok.scope, 'layers:read layers:write')
obj_tok.save()
self.assertEqual(len(responses.calls), 2)
req = json.loads(responses.calls[1].request.body)
self.assertEqual(req['scope'], 'layers:read layers:write')
self.assertEqual(req['expires_at'], '2011-01-02T03:45:00')
# reset to server values
self.assertEqual(len(obj_tok.scopes), 18)
class TestTokens(unittest.TestCase):
def setUp(self):
self.client = Client(token="test", host="test.koordinates.com")
@responses.activate
def test_get_all_tokens_for_user(self):
the_response = token_get_multiple_tokens_good_response
responses.add(
responses.GET,
self.client.get_url("TOKEN", "GET", "multi"),
body=the_response,
status=200,
content_type="application/json",
)
cnt_of_sets_returned = 0
is_first = True
for token in self.client.tokens.list():
cnt_of_sets_returned += 1
if is_first:
is_first = False
self.assertEqual(token.name, "")
self.assertEqual(token.key_hint, "0fooxx...")
self.assertEqual(token.url, "https://test.koordinates.com/services/api/v1/tokens/987654/")
self.assert_(token._is_bound)
self.assertEqual(cnt_of_sets_returned, 1)
@responses.activate
def test_get_individual_tokens_by_id(self):
the_response = token_get_single_token_good_response
responses.add(
responses.GET,
self.client.get_url("TOKEN", "GET", "single", {"id": 987654}),
body=the_response,
status=200,
content_type="application/json",
)
obj_tok = self.client.tokens.get(987654)
self.assert_(isinstance(obj_tok, Token))
self.assert_(obj_tok._is_bound)
self.assertEqual(obj_tok.name, "")
self.assertEqual(obj_tok.key_hint, "0fooxx...")
self.assertEqual(obj_tok.url, "https://test.koordinates.com/services/api/v1/tokens/987654/")
self.assertEqual(obj_tok.created_at.year, 2015)
self.assertEqual(obj_tok.created_at.hour, 5)
self.assertEqual(obj_tok.expires_at, None)
@responses.activate
def test_create_token_good(self):
the_response = token_good_create
responses.add(
responses.POST,
self.client.get_url("TOKEN", "POST", "create"),
body=the_response,
status=200,
content_type="application/json",
)
obj_tok = Token(name="Sample Token for Testing")
obj_tok.scope = "query tiles catalog wxs:wfs wxs:wms wxs:wcs documents:read documents:write layers:read layers:write sets:read sets:write sources:read sources:write users:read users:write tokens:read tokens:write"
obj_tok.expires_at = "2015-08-01T08:00:00Z"
obj_tok_new = self.client.tokens.create(obj_tok, "*****@*****.**", "foobar")
self.assert_(isinstance(obj_tok_new, Token))
self.assertEqual(obj_tok_new.name, "Sample Token for Testing")
self.assertEqual(obj_tok_new.key_hint, "7fooxx...")
self.assertEqual(obj_tok_new.url, "https://test.koordinates.com/services/api/v1/tokens/987659/")
self.assertEqual(obj_tok_new.created_at.year, 2015)
self.assertEqual(obj_tok_new.created_at.hour, 1)
self.assertEqual(obj_tok_new.expires_at.year, 2015)
self.assertEqual(obj_tok_new.expires_at.hour, 8)
self.assertEqual(obj_tok_new.key, "77777777777777777777777777777777")
@responses.activate
def test_delete_token_good(self):
the_response = ""
responses.add(
responses.DELETE,
self.client.get_url("TOKEN", "DELETE", "single", {"id": 987654}),
body=the_response,
status=204,
content_type="application/json",
)
self.client.tokens.delete(987654)
@responses.activate
def test_update_token(self):
the_response = token_get_single_token_good_response
responses.add(
responses.GET,
self.client.get_url("TOKEN", "GET", "single", {"id": 987654}),
body=the_response,
status=200,
content_type="application/json",
)
responses.add(
responses.PUT,
self.client.get_url("TOKEN", "PUT", "update", {"id": 987654}),
body=the_response,
status=200,
content_type="application/json",
)
obj_tok = self.client.tokens.get(987654)
self.assert_(isinstance(obj_tok, Token))
obj_tok.expires_at = datetime(2011, 1, 2, 3, 45)
obj_tok.scopes = ["layers:read", "layers:write"]
self.assertEqual(obj_tok.scope, "layers:read layers:write")
obj_tok.save()
self.assertEqual(len(responses.calls), 2)
req = json.loads(responses.calls[1].request.body)
self.assertEqual(req["scope"], "layers:read layers:write")
self.assertEqual(req["expires_at"], "2011-01-02T03:45:00")
# reset to server values
self.assertEqual(len(obj_tok.scopes), 18)
def setUp(self):
self.client = Client("koordinates.com", 'test')
self.testclient = Client("test.koordinates.com", 'test')
def setUp(self):
self.client = Client(token="test", host="test.koordinates.com")
def setUp(self):
self.client = Client(host='test.koordinates.com',
token='test',
activate_logging=True)
self.foos = FooManager(self.client)
def setUp(self):
self.client = Client(token='test', host='koordinates.com')
self.test_client = Client(token='test', host="test.koordinates.com")
self.bad_client = Client(token='bad', host='koordinates.com')
def setUp(self):
self.client = Client(host='test.koordinates.com', token='test')
self.mgr = FooManager(self.client)
def setUp(self):
self.client = Client("koordinates.com", 'test')
self.testclient = Client("test.koordinates.com", 'test')
class LicenseTests(unittest.TestCase):
def setUp(self):
self.client = Client(token='test', host="test.koordinates.com")
@responses.activate
def test_list(self):
responses.add(responses.GET,
self.client.get_url('LICENSE', 'GET', 'multi'),
body=license_list,
status=200,
content_type='application/json')
licenses = list(self.client.licenses.list())
self.assertEqual(len(licenses), 23)
self.assertEqual(len(responses.calls), 1)
@responses.activate
def test_list_cc(self):
responses.add(responses.GET,
self.client.get_url('LICENSE', 'GET', 'cc', {
'slug': 'cc-by-nc',
'jurisdiction': ''
}),
body=license_cc_10,
status=200,
content_type='application/json')
responses.add(responses.GET,
self.client.get_url('LICENSE', 'GET', 'cc', {
'slug': 'cc-by-nc',
'jurisdiction': 'au'
}),
body=license_cc_10,
status=200,
content_type='application/json')
license = self.client.licenses.get_creative_commons('cc-by-nc')
self.assert_(isinstance(license, License))
license = self.client.licenses.get_creative_commons('cc-by-nc', 'au')
self.assert_(isinstance(license, License))
with self.assertRaises(ClientValidationError):
self.client.licenses.get_creative_commons('nc', 'au')
self.assertEqual(len(responses.calls), 2)
@responses.activate
def test_get(self):
responses.add(responses.GET,
self.client.get_url('LICENSE', 'GET', 'single',
{'id': 10}),
body=license_cc_10,
status=200,
content_type='application/json')
license = self.client.licenses.get(10)
self.assert_(isinstance(license, License))
self.assertEqual(license.id, 10)
self.assertEqual(license.type, 'cc-by-nd')
self.assertEqual(license.jurisdiction, 'nz')
self.assertEqual(
str(license),
"10 - Creative Commons Attribution-No Derivative Works 3.0 New Zealand"
)
@responses.activate
def test_layer(self):
responses.add(responses.GET,
self.client.get_url('LAYER', 'GET', 'single',
{'id': 1474}),
body=layers_version_single_good_simulated_response,
status=200,
content_type='application/json')
layer = self.client.layers.get(1474)
self.assert_(isinstance(layer.license, License))
license = layer.license
self.assertEqual(license.id, 9)
