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