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/''' )
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 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 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 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)
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 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)