def test_fetch_token(self, urlopen_mock): """ Test that the code can fetch a token request """ self.assertEqual(None, token.fetch_token(None, token_lambdas=[])) token_lambdas = [token.token_config] config = {'cmr.token.value': ''} self.assertEqual( None, token.fetch_token(None, token_lambdas=token_lambdas, config=config)) user = '******' config = {'cmr.token.value': 'pass'} # Setup for a good test recorded_data_file = util.resolve_full_path( '../data/edl/token_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) tokens = token.fetch_token(user, token_lambdas, config) self.assertEqual('EDL-UToken-Content', tokens, 'access token test') # Setup for a bad test recorded_data_file = util.resolve_full_path( '../data/edl/token_bad.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) tokens = token.fetch_token(user, token_lambdas, config) self.assertEqual('invalid_credentials', tokens['error'], 'Bad test')
def test_fetch_bearer_token(self, urlopen_mock): """ Test that the code can fetch a token request """ user = '******' token_lambdas = [token.token_config] config = {'cmr.token.value': 'pass'} # Setup for a good test recorded_data_file = util.resolve_full_path( '../data/edl/token_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) tokens = token.fetch_bearer_token(user, token_lambdas, config) self.assertEqual('Bearer EDL-UToken-Content', tokens['authorization'], 'access token test') tokens = token.fetch_bearer_token(user, token_lambdas) self.assertEqual({"error": "No lambda could providede a token"}, tokens, 'no token found from config when no config given') # Setup for a bad test recorded_data_file = util.resolve_full_path( '../data/edl/token_bad.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) tokens = token.fetch_bearer_token(user, token_lambdas, config) self.assertEqual('invalid_credentials', tokens['error'], 'Bad test')
def test_scroll(self, urlopen_mock): """ Test the scroll clear function to see if it returns an error or not""" recorded_file = tutil.resolve_full_path( '../data/cmr/common/scroll_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_file, 204) result = scom.clear_scroll('-1') self.assertFalse('errors' in result) recorded_file = tutil.resolve_full_path( '../data/cmr/common/scroll_bad.json') urlopen_mock.return_value = valid_cmr_response(recorded_file, 404) result = scom.clear_scroll('0') self.assertTrue('errors' in result)
def test_read_tokens(self, urlopen_mock): """ Test the read_tokens function, make sure that the data that comes back is parsed correctly and in the correct format """ # Setup for tests user = '******' token_lambdas = [token.token_config] config = {'cmr.token.value': 'pass'} self.assertEqual(None, token.read_tokens(None, token_lambdas=[])) self.assertEqual( None, token.read_tokens(None, token_lambdas=token_lambdas, config={'cmr.token.value': ''})) # Setup for a good test recorded_data_file = util.resolve_full_path( '../data/edl/token_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) result = token.read_tokens(user, token_lambdas, config) self.assertEqual(1, result['hits'], "Hits test") items = result['items'] self.assertEqual(1, len(items), "item count test") access_token = items[0]['access_token'] self.assertEqual("EDL-UToken-Content", access_token, "Access token test") experation = result['items'][0]['expiration_date'] self.assertEqual('10/31/2121', experation, "experation date test") experation_date = datetime.strptime(experation, '%m/%d/%Y') self.assertTrue(datetime.now() < experation_date, "experation date is in future") # ############################## # Now test a bad call recorded_data_file = util.resolve_full_path( '../data/edl/token_bad.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file, status=401) result = token.read_tokens(user, token_lambdas, config) self.assertEqual('invalid_credentials', result['error'], "check bad response")
def test_fetch_token_delete_path(self, now_mock, deltoken_mock, readtoken_mock, urlopen_mock): """ Test that the code can fetch expired tokens and then try to delete one """ config = {'cmr.token.value': 'pass'} epoc = datetime(2021, 12, 28, 9, 13, 20, 0) now_mock.return_value = epoc self.assertEqual(epoc, common.now(), 'time must be frozen for this to work') # create old data response - expired tokens old = util.load_relative_json_file('../data/edl/tokens_old.json') # create good data response - new tokens good = util.load_relative_json_file('../data/edl/token_good.json') # setup responses readtoken_mock.side_effect = [old, good, good] recorded_data_file_good = util.resolve_full_path( '../data/edl/create_token_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file_good) deltoken_mock.return_value = "dummy" # run test tokens = token.fetch_token("tester", [token.token_config], config) self.assertEqual('EDL-UToken-Content', tokens, 'access token test')
def test_use_bearer_token_from_url(self, urlopen_mock): """ Follow the path in the use_bearer_token() which pulls from a url """ # Setup for use bearer token config = {'cmr.token.value': 'pass'} recorded_data_file = util.resolve_full_path( '../data/edl/token_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) expected = {'cmr.token.value': 'pass', 'authorization': 'Bearer pass'} self.assertEqual(expected, token.use_bearer_token(config=config))
def test_fetch_bearer_token_with_password(self, urlopen_mock): """ Test that the code can fetch a token request """ # Setup for a good test recorded_data_file = util.resolve_full_path( '../data/edl/token_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) tokens = token.fetch_bearer_token_with_password('tester', "pass") self.assertEqual('Bearer EDL-UToken-Content', tokens['authorization'], 'access token test')
def test_compound_search_gran(self, urlopen_mock): """ Assuming that _collection_samples works and CMR work, test _granule_samples. Do this By hard coding the granule search and making sure that the remaining code correctly returns the granule information. """ # Setup recorded_file = tutil.resolve_full_path( '../data/cmr/search/combo_gran_result.json') urlopen_mock.return_value = valid_cmr_response(recorded_file) # Inputs found_collections = [ 'C179003030-ORNL_DAAC', 'C179002914-ORNL_DAAC', 'C1000000000-ORNL_DAAC', 'C1536961538-ORNL_DAAC', 'C179126725-ORNL_DAAC', 'C179003380-ORNL_DAAC', 'C179130805-ORNL_DAAC', 'C179003657-ORNL_DAAC', 'C1227811476-ORNL_DAAC', 'C179130785-ORNL_DAAC' ] filters = [ gran.granule_core_fields, gran.drop_fields('GranuleUR'), gran.drop_fields('revision-id'), gran.drop_fields('native-id') ] limit = 1 config = {} # Run test found_granules = gran._granule_samples(found_collections, filters, limit, config) expected = [{ 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }] self.assertEqual(expected, found_granules, "Compound Search - Granual Compound")
def test_post(self, urlopen_mock): """ Test the post method, POST a network resource """ # Setup recorded_data_file = tutil.resolve_full_path( '../data/cmr/search/one_cmr_result.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) data = net.post("http://cmr.earthdata.nasa.gov/search", {}) self.assertEqual(276, (data['hits'])) data = net.post("http://cmr.earthdata.nasa.gov/search", {}, accept='application/xml') self.assertEqual(276, (data['hits'])) data = net.post("http://cmr.earthdata.nasa.gov/search", {}, headers={'platforms': 'SMAP'}) self.assertEqual(276, (data['hits'])) # test that a 200 with headers will be logged urlopen_mock.return_value = valid_cmr_response(recorded_data_file, 200, [('head-a', 'value-a')]) try: net.logger.setLevel('DEBUG') with self.assertLogs(net.logger, level='DEBUG') as test_log: data = net.post("http://cmr.earthdata.nasa.gov/search", {}) self.assertEqual({"head-a": "value-a"}, data['http-headers'], "headers do not match") self.assertEqual(test_log.output, [ 'DEBUG:cmr.util.network: Headers->CMR= None', "DEBUG:cmr.util.network: POST Data= b''", "DEBUG:cmr.util.network: CMR->Headers = {'head-a': 'value-a'}" ], "log does not match") except AssertionError: self.fail('no log entry') net.logger.setLevel('ERROR') # test that a 204 can be processed urlopen_mock.return_value = valid_cmr_response(recorded_data_file, 204, [('head-a', 'value-a')]) data = net.post("http://cmr.earthdata.nasa.gov/search", {}) self.assertEqual({'http-headers': {"head-a": "value-a"}}, data) # test an error urlopen_mock.side_effect = urlerr.HTTPError(Mock(status=500), "500", "Unprocessable Entity", None, None) data = net.post("http://cmr.earthdata.nasa.gov/search/fake", {}) expected = { 'code': '500', 'reason': 'Unprocessable Entity', 'errors': ['Unprocessable Entity'] } self.assertEqual(expected, data)
def test_token(self, urlopen_mock): """ Test that the code can fetch a token request """ token_lambdas = [token.token_config] config = {'cmr.token.value': 'EDL-UToken-Content'} # Setup for a good test recorded_data_file = util.resolve_full_path( '../data/edl/token_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) tokens = token.token(token_lambdas, config) self.assertEqual('EDL-UToken-Content', tokens, 'access token test')
def test__make_search_request(self, urlopen_mock): """ Test the inner function which performs the first half of a search """ recorded_file = tutil.resolve_full_path( '../data/cmr/common/scroll_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_file, 204) page_state = scom.create_page_state() page_state['CMR-Scroll-Id'] = 'abcd' response = scom._make_search_request('search', {'keyword': 'water'}, page_state, {'env': 'sit'}) self.assertEqual({'http-headers': {}}, response, 'test that the scroll id code gets touched')
def test_delete_token(self, urlopen_mock): """ Test that the code can send a delete token request to EDL """ self.assertEqual(None, token.delete_token(None, None, token_lambdas=[])) user = '******' token_lambdas = [token.token_config] config = {'cmr.token.value': ''} self.assertEqual( None, token.delete_token(None, None, token_lambdas=[], config=config), "empty password") self.assertEqual( None, token.delete_token(None, None, token_lambdas=[token.token_config], config=config), "empty password - lambda") config = {'cmr.token.value': 'pass'} # Setup for a good test recorded_data_file = util.resolve_full_path( '../data/edl/revoke_token_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) tokens = token.delete_token('EDL-UToken-Content', user, token_lambdas, config) self.assertEqual({'http-headers': {}}, tokens, 'access token test') # Setup for a bad test recorded_data_file = util.resolve_full_path( '../data/edl/create_token_bad.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) tokens = token.delete_token('EDL-UToken-Content', user, token_lambdas, config) self.assertEqual('invalid_credentials', tokens['error'], 'Bad test')
def test_experimental_search(self, urlopen_mock): """ def search(query=None, filters=None, limit=None, options=None): """ # Setup urlopen_mock.return_value = valid_cmr_response( tutil.resolve_full_path( '../data/cmr/search/one_granule_cmr_result.json')) # Basic generator = gran.experimental_search_generator({'provider': 'SEDAC'}, limit=1) for item in generator: self.assertEqual('G1527288030-SEDAC', item['meta']['concept-id'])
def test_limited_search(self, urlopen_mock): """ Test that the limit parameter will not allow more data to be returned. CMR may return more data on the last page if a page value is specified. For this test, 10 results are returned and the API will opt to return fewer to the caller """ # Setup recorded_file = tutil.resolve_full_path( '../data/cmr/search/ten_results_from_ghrc.json') urlopen_mock.return_value = valid_cmr_response(recorded_file) # tests for index in [1, 2, 5, 10]: result = coll.search({'provider': 'GHRC_CLOUD'}, limit=index) self.assertEqual(index, len(result))
def test_experimental_search(self, urlopen_mock): """ def search(query=None, filters=None, limit=None, options=None): """ # Setup recorded_file = tutil.resolve_full_path( '../data/cmr/search/ten_results_from_ghrc.json') # Basic urlopen_mock.return_value = valid_cmr_response(recorded_file, 200) generator = scom.experimental_search_by_page_generator( 'collections', {'provider': 'SEDAC'}) for item in generator: self.assertEqual("ORNL_DAAC", item['meta']['provider-id'], 'basic test') # page state uses scroll urlopen_mock.return_value = valid_cmr_response( recorded_file, 200, [('CMR-Scroll-Id', 'abcd')]) page_state = scom.create_page_state(limit=4000) page_state['CMR-Scroll-Id'] = 'abcd' generator = scom.experimental_search_by_page_generator( 'collections', {'provider': 'SEDAC'}, page_state=page_state) for item in generator: self.assertEqual("ORNL_DAAC", item['meta']['provider-id'], 'trigger scrloll id check') # error processing writes to log urlopen_mock.side_effect = urlerr.HTTPError(Mock(status=500), "500", "Server Error", None, None) generator = None try: with self.assertLogs(scom.logger, level='ERROR') as test_log: try: end_point = 'collections' query = {'provider': 'ORNL_DAAC'} generator = scom.experimental_search_by_page_generator( end_point, query) _ = next(generator) #consume generator to force action except StopIteration: pass #self.assertTrue(True, "generator should be empty") self.assertEqual(test_log.output, [ "ERROR:cmr.search.common:Error in generator: Server Error." ], "logs not matching") except AssertionError: self.fail('no log entry')
def test_logged_search(self, urlopen_mock): """ Test that search still runs as expected when logging is turned on """ # Setup recorded_file = tutil.resolve_full_path( '../data/cmr/search/ten_results_from_ghrc.json') urlopen_mock.return_value = valid_cmr_response(recorded_file) # Test with self.assertLogs(coll.scom.logger, level='DEBUG') as log_collector: coll.set_logging_to("DEBUG") expected = [ 'INFO:cmr.search.common: - POST: https://cmr.earthdata.' 'nasa.gov/search/collections?page_size=1', 'INFO:cmr.search.common:Total records downloaded was 10' ' of 2038 which took 10ms.' ] coll.search({'provider': 'GHRC_CLOUD'}, limit=1) self.assertEqual(expected, log_collector.output)
def test_compound_search_collection(self, urlopen_mock): """ Test the compound test works """ # Setup recorded_file = tutil.resolve_full_path( '../data/cmr/search/ten_results_from_ghrc.json') urlopen_mock.return_value = valid_cmr_response(recorded_file) # tests for limit in [1, 2, 5, 10]: result = gran._collection_samples({'provider': 'GHRC_CLOUD'}, limit, {}) self.assertEqual(limit, len(result), "limit check") # last call was the full 10, use that going forward self.assertEqual([ 'C179003030-ORNL_DAAC', 'C179002914-ORNL_DAAC', 'C1000000000-ORNL_DAAC', 'C1536961538-ORNL_DAAC', 'C179126725-ORNL_DAAC', 'C179003380-ORNL_DAAC', 'C179130805-ORNL_DAAC', 'C179003657-ORNL_DAAC', 'C1227811476-ORNL_DAAC', 'C179130785-ORNL_DAAC' ], result, "list matches")
def test_fetch_token2(self, readtoken_mock, urlopen_mock): """ Test that the code can fetch a token request """ self.assertEqual(None, token.fetch_token(None, token_lambdas=[])) token_lambdas = [token.token_config] config = {'cmr.token.value': ''} self.assertEqual( None, token.fetch_token(None, token_lambdas=token_lambdas, config=config)) user = '******' config = {'cmr.token.value': 'pass'} # Setup for an empty test readtoken_mock.return_value = {'hits': 0, 'items': []} recorded_data_file = util.resolve_full_path( '../data/edl/create_token_good.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) tokens = token.fetch_token(user, token_lambdas, config) self.assertEqual('EDL-UToken-Content', tokens, 'access token test')
def test_search(self, urlopen_mock): """ def search(query=None, filters=None, limit=None, config=None): """ # Setup recorded_file = tutil.resolve_full_path( '../data/cmr/search/one_cmr_result.json') urlopen_mock.return_value = valid_cmr_response(recorded_file) full_result = coll.search({'provider': 'SEDAC'}, limit=1) self.assertEqual(1, len(full_result)) # Unfiltered Test unfiltered_result = coll.search({'provider': 'SEDAC'}, filters=[coll.all_fields], limit=1) self.assertEqual(full_result, unfiltered_result) # Meta filter Test meta_results = coll.search({'provider': 'SEDAC'}, filters=[coll.meta_fields], limit=1) expected = [{ 'revision-id': 31, 'deleted': False, 'format': 'application/dif10+xml', 'provider-id': 'SEDAC', 'user-id': 'mhansen', 'has-formats': False, 'has-spatial-subsetting': False, 'native-id': '2000 Pilot Environmental Sustainability Index (ESI)', 'has-transforms': False, 'has-variables': False, 'concept-id': 'C179001887-SEDAC', 'revision-date': '2019-07-26T18:37:52.861Z', 'granule-count': 0, 'has-temporal-subsetting': False, 'concept-type': 'collection' }] self.assertEqual(expected, meta_results) # UMM filter Test umm_results = coll.search({'provider': 'SEDAC'}, filters=[coll.umm_fields], limit=1) expected = '2000 Pilot Environmental Sustainability Index (ESI)' self.assertEqual(expected, umm_results[0]['EntryTitle']) self.assertEqual(28, len(umm_results[0].keys())) # Collection ID Filter Test cid_results = coll.search({'provider': 'SEDAC'}, filters=[coll.concept_id_fields], limit=1) expected = [{'concept-id': 'C179001887-SEDAC'}] self.assertEqual(expected, cid_results) # Drop Filter Test drop_results = coll.search( {'provider': 'SEDAC'}, filters=[ coll.meta_fields, coll.drop_fields('has-temporal-subsetting'), coll.drop_fields('revision-date'), coll.drop_fields('has-spatial-subsetting') ], limit=1) expected = [{'concept-id': 'C179001887-SEDAC'}] meta_count = len(meta_results[0].keys()) #from test above drop_count = len(drop_results[0].keys()) self.assertEqual(3, meta_count - drop_count) #IDs Filter Test ids_results = coll.search({'provider': 'SEDAC'}, filters=[coll.collection_core_fields], limit=1) expected = [{ 'concept-id': 'C179001887-SEDAC', 'ShortName': 'CIESIN_SEDAC_ESI_2000', 'Version': '2000.00', 'EntryTitle': '2000 Pilot Environmental Sustainability Index (ESI)' }] self.assertEqual(expected, ids_results) # Granule IDs Filter Tests gids_results = coll.search( {'provider': 'SEDAC'}, filters=[coll.collection_ids_for_granules_fields], limit=1) expected = [{ 'provider-id': 'SEDAC', 'concept-id': 'C179001887-SEDAC', 'ShortName': 'CIESIN_SEDAC_ESI_2000', 'Version': '2000.00', 'EntryTitle': '2000 Pilot Environmental Sustainability Index (ESI)' }] self.assertEqual(expected, gids_results)
def test_search_by_page(self, clr_scroll_mock, urlopen_mock): """ Test the inner function which performs the first half of a search """ recorded_file = tutil.resolve_full_path( '../data/cmr/search/ten_results_from_ghrc.json') urlopen_mock.return_value = valid_cmr_response(recorded_file, 200) query = {'keyword': 'water'} response = scom.search_by_page('collections', query) self.assertEqual(10, len(response), 'assumed page_state') # page state uses scroll page_state = scom.create_page_state(limit=4000) urlopen_mock.return_value = valid_cmr_response( recorded_file, 200, [('CMR-Scroll-Id', 'si-01')]) page_state['CMR-Scroll-Id'] = 'abcd' response = scom.search_by_page('collections', query, page_state=page_state) self.assertEqual(20, len(response), 'assumed page_state') # error processing 1 urlopen_mock.return_value = tutil.MockResponse("I'm a tea pot", 418) response = scom.search_by_page('collections', query, config={'debug': True}) expected = { 'errors': ['unknown response: I\'m a tea pot'], 'code': 0, 'reason': 'unknown response: I\'m a tea pot' } self.assertEqual(expected, response, "exeption") # error processing 2 urlopen_mock.return_value = valid_cmr_response('{"errors":["Error"]}', 500) urlopen_mock.side_effect = urlerr.HTTPError(Mock(status=500), "500", "Server Error", None, None) response = scom.search_by_page('collections', query) expected = { 'code': '500', 'reason': 'Server Error', 'errors': ['Server Error'] } self.assertEqual(expected, response, "exeption") # bad clear response is logged recorded_file = tutil.resolve_full_path( '../data/cmr/search/ten_results_from_ghrc.json') clr_scroll_mock.return_value = {'errors': ['bad scroll id']} urlopen_mock.return_value = valid_cmr_response(recorded_file, 200) urlopen_mock.side_effect = None response = scom.search_by_page('collections', query, page_state=page_state) self.assertEqual(10, len(response), "bad scroll id") # takes to long recorded_file = tutil.resolve_full_path( '../data/cmr/search/ten_results_from_ghrc.json') page_state['took'] = 300001 page_state['page_size'] = 1 urlopen_mock.return_value = valid_cmr_response(recorded_file, 200) response = scom.search_by_page('collections', query, page_state=page_state) self.assertEqual(10, len(response), "bad scroll id")
def test_compound_search(self, urlopen_mock, coll_mock): """ Do a full test of the compound search, assuming that the component pieces work. Assume the response of the collection samples and hard code the CMR response for the granule search. """ coll_mock.return_value = [ 'C179003030-ORNL_DAAC', 'C179002914-ORNL_DAAC', 'C1000000000-ORNL_DAAC', 'C1536961538-ORNL_DAAC', 'C179126725-ORNL_DAAC', 'C179003380-ORNL_DAAC', 'C179130805-ORNL_DAAC', 'C179003657-ORNL_DAAC', 'C1227811476-ORNL_DAAC', 'C179130785-ORNL_DAAC' ] # Setup recorded_file = tutil.resolve_full_path( '../data/cmr/search/combo_gran_result.json') urlopen_mock.return_value = valid_cmr_response(recorded_file) collection_query = {'provider': 'GHRC_CLOUD'} filters = [ gran.granule_core_fields, gran.drop_fields('GranuleUR'), gran.drop_fields('revision-id'), gran.drop_fields('native-id') ] # cut down the function parameters to assume all the parts that will not change runner = partial(gran.sample_by_collections, collection_query, filters=filters) # pylint: disable=C0301 # lambda must be on one line tester = lambda expected, limit, msg: self.assertEqual( expected, runner(limits=limit), msg) expected = [{ 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }, { 'concept-id': 'G1527288030-SEDAC' }] tester(expected, 10, "at most 10, default collection, using int") tester(expected, [10, 1], "at most 10, one collection, array") tester(expected[:5], { "granule": 5, "collection": 1 }, "at most five, using dictionary") tester(expected, { "granule": 1, "collection": None }, "defaulting with dictionary")
def test_search(self, urlopen_mock): """ def search(query=None, filters=None, limit=None, options=None): """ # Setup urlopen_mock.return_value = valid_cmr_response( tutil.resolve_full_path( '../data/cmr/search/one_granule_cmr_result.json')) # Basic full_result = gran.search({'provider': 'SEDAC'}, limit=1) self.assertEqual(1, len(full_result)) # Unfiltered Test unfiltered_result = gran.search({'provider': 'SEDAC'}, filters=[gran.all_fields], limit=1) self.assertEqual(full_result, unfiltered_result) # Meta filter Test meta_results = gran.search({'provider': 'SEDAC'}, filters=[gran.meta_fields], limit=1) expected = [{ 'concept-type': 'granule', 'concept-id': 'G1527288030-SEDAC', 'revision-id': 2, 'native-id': 'urbanspatial-hist-urban-pop-3700bc-ad2000-xlsx.xlsx', 'provider-id': 'SEDAC', 'format': 'application/echo10+xml', 'revision-date': '2020-08-11T13:54:58.567Z' }] self.assertEqual(expected, meta_results) # UMM filter Test umm_results = gran.search({'provider': 'SEDAC'}, filters=[gran.umm_fields], limit=1) expected = 'urbanspatial-hist-urban-pop-3700bc-ad2000-xlsx.xlsx' self.assertEqual(expected, umm_results[0]['GranuleUR']) self.assertEqual(11, len(umm_results[0].keys())) # Collection ID Filter Test cid_results = gran.search({'provider': 'SEDAC'}, filters=[gran.concept_id_fields], limit=1) expected = [{'concept-id': 'G1527288030-SEDAC'}] self.assertEqual(expected, cid_results) # Drop Filter Test drop_results = gran.search({'provider': 'SEDAC'}, filters=[ gran.meta_fields, gran.drop_fields('concept-type'), gran.drop_fields('revision-date'), gran.drop_fields('format') ], limit=1) expected = [{'concept-id': 'G1527288030-SEDAC'}] meta_count = len(meta_results[0].keys()) #from test above drop_count = len(drop_results[0].keys()) self.assertEqual(3, meta_count - drop_count) #IDs Filter Test ids_results = gran.search({'provider': 'SEDAC'}, filters=[gran.granule_core_fields], limit=1) expected = [{ 'concept-id': 'G1527288030-SEDAC', 'revision-id': 2, 'native-id': 'urbanspatial-hist-urban-pop-3700bc-ad2000-xlsx.xlsx', 'GranuleUR': 'urbanspatial-hist-urban-pop-3700bc-ad2000-xlsx.xlsx' }] self.assertEqual(expected, ids_results)
def test_get(self, urlopen_mock): """ Test the get method, get a network resource """ # Setup recorded_data_file = tutil.resolve_full_path( '../data/cmr/search/one_cmr_result.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) data = net.get("http://cmr.earthdata.nasa.gov/search") self.assertEqual(276, (data['hits']), "only required parameters") data = net.get("http://cmr.earthdata.nasa.gov/search", accept='application/xml') self.assertEqual(276, (data['hits']), "with an accept") data = net.get("http://cmr.earthdata.nasa.gov/search", headers={'platforms': 'SMAP'}) self.assertEqual(276, (data['hits']), "with a header") # test that a 200 can be processed with headers by writing to log urlopen_mock.return_value = valid_cmr_response(recorded_data_file, 200, [('key', 'value')]) try: net.logger.setLevel('DEBUG') with self.assertLogs(net.logger, level='DEBUG') as test_log: data = net.get("http://cmr.earthdata.nasa.gov/search") self.assertEqual(test_log.output, [ 'DEBUG:cmr.util.network: Headers->CMR= None', "DEBUG:cmr.util.network: CMR->Headers = {'key': 'value'}" ]) except AssertionError: self.fail("no log entry") net.logger.setLevel('ERROR') # test that a 204 can be processed urlopen_mock.return_value = valid_cmr_response(recorded_data_file, 204, [('key', 'value')]) data = net.get("http://cmr.earthdata.nasa.gov/search") self.assertEqual({'http-headers': { 'key': 'value' }}, data, "a 204 response") # standard tea pot test : error handling urlopen_mock.return_value = tutil.MockResponse("I'm a tea pot", 416, [('key', 'value')]) data = net.get("http://cmr.earthdata.nasa.gov/search") self.assertEqual("I'm a tea pot", data, "a 416 response") # exception handling urlopen_mock.side_effect = urlerr.HTTPError(Mock(status=500), "500", "Server Error", None, None) data = net.get("http://cmr.earthdata.nasa.gov/search") expected = { 'code': '500', 'reason': 'Server Error', 'errors': ['Server Error'] } self.assertEqual(expected, data, "exception was not caught") # test an error urlopen_mock.side_effect = urlerr.HTTPError(Mock(status=500), "500", "Unprocessable Entity", None, None) data = net.get("http://cmr.earthdata.nasa.gov/search/fake") expected = { 'code': '500', 'reason': 'Unprocessable Entity', 'errors': ['Unprocessable Entity'] } self.assertEqual(expected, data, "an exeption") urlopen_mock.side_effect = None # test list response such as the provider list from ingest recorded_data_file = tutil.resolve_full_path( '../data/cmr/ingest/providers.json') urlopen_mock.return_value = valid_cmr_response(recorded_data_file) data = net.get( "http://cmr.earthdata.nasa.gov/ingest/providers?pretty=true") self.assertEqual(110, len(data['items']))