def test_gmdbplot_service(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the gmdbplot API service.'''
inputdic = testdata.readyaml(self.request_filename)
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 200
assert areequal(resp1.json(), resp2.json())
json_no_sel = resp1.json()
# Now provide a filtering:
selexpr = '(vs30 >= 730) & ((magnitude <=4) | (magnitude>=7))'
inputdic_sel = dict(inputdic, sel=selexpr)
resp2 = client.post(self.url,
data=inputdic_sel,
content_type='application/json')
resp1 = client.get(querystring(inputdic_sel, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 200
assert areequal(resp1.json(), resp2.json())
json_sel = resp1.json()
# test that the selection worked
assert len(json_no_sel['xvalues']) > len(json_sel['xvalues'])
# test that magnitudes are what we expect:
assert any(_ <= 4 or _ >= 7 for _ in json_sel['yvalues'])
def test_residuals_service_err(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests errors in the residuals API service.'''
inputdic = testdata.readyaml(self.request_filename)
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 400
assert areequal(resp1.json(), resp2.json())
json_ = resp1.json()
exp_json = {
'error': {
'code':
400,
'message':
'Invalid input in plot_type',
'errors': [{
'domain': 'plot_type',
'message': 'This field is required.',
'reason': 'required'
}]
}
}
assert areequal(json_, exp_json)
# FIXME: better test, check more in the errors!
inputdic = dict(inputdic)
for ddd in ['dist', 'distance_type']:
inputdic.pop('dist', None)
inputdic['plot_type'] = 'dist'
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 400
# test selexpr errors:
inputdic = dict(inputdic)
inputdic['selexpr'] = '(magnitude >5'
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 400
def test_testing_service(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the gmdbplot API service.'''
inputdic = testdata.readyaml(self.request_filename)
# pass two gsims that have records with the current test gmdb:
inputdic['gsim'] = ['Atkinson2015', 'BindiEtAl2014RhypEC8NoSOF']
inputdic['selexpr'] = ''
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 200
assert areequal(resp1.json(), resp2.json())
json_ = resp1.json()
assert isinstance(json_, dict) and \
all(isinstance(_, dict) for _ in json_.values())
# test text format:
resp2 = client.post(self.url,
data=dict(inputdic, format='text'),
content_type='text/csv')
assert resp2.status_code == 200
exp_str = b'measure of fit,imt,gsim,value,db records used\r\n'
assert resp2.content.startswith(exp_str)
assert len(resp2.content) > len(exp_str)
def test_residuals_service_err(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests errors in the testing API service.'''
inputdic = testdata.readyaml(self.request_filename)
inputdic.pop('fit_measure')
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 400
assert areequal(resp1.json(), resp2.json())
json_ = resp1.json()
exp_json = {
'error': {
'code':
400,
'message':
'Invalid input in fit_measure',
'errors': [{
'domain': 'fit_measure',
'message': 'This field is required.',
'reason': 'required'
}]
}
}
assert areequal(json_, exp_json)
def test_testing_service_zero_records(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the gmdbplot API service.'''
inputdic = testdata.readyaml(self.request_filename)
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 200
assert areequal(resp1.json(), resp2.json())
json_ = resp1.json()
assert isinstance(json_, dict) and \
all(isinstance(_, dict) for _ in json_.values())
# test text format:
resp2 = client.post(self.url,
data=dict(inputdic, format='text'),
content_type='text/csv')
assert resp2.status_code == 200
assert resp2.content == (b'measure of fit,imt,gsim,value,'
b'db records used\r\n')
# test with no selexpr. Unfortunately, no matching db rows
# found. FIXME: try with some other gsim?
resp2 = client.post(self.url,
data=dict(inputdic, format='text', selexpr=''),
content_type='text/csv')
assert resp2.status_code == 200
assert resp2.content == (b'measure of fit,imt,gsim,value,'
b'db records used\r\n')
def test_gsims_service_no_lat_or_lon_provided(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the gsims API service with missing lat or lon'''
for key in ['latitude', 'longitude']:
inputdic = testdata.readyaml(self.request_filename)
inputdic.pop(key)
# use a key which is not in the defined sets of OpenQuake's TRTs:
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == 400
expected_json = {
"error": {
"code":
400,
"message":
"Invalid input in %s" % key,
"errors": [{
"domain": key,
"message": "missing value",
"reason": "missing"
}]
}
}
assert areequal(resp1.json(), expected_json)
def test_residuals_service_(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the residuals API service.'''
expected_txt = \
re.compile(b'^imt,type,gsim,mean,stddev,median,slope,'
b'intercept,pvalue,,*\r\n')
base_inputdic = testdata.readyaml(self.request_filename)
for restype in ResidualplottypeField._base_choices:
inputdic = dict(base_inputdic,
plot_type=restype,
sel='(vs30 > 800) & (vs30 < 1200)')
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 200
assert areequal(resp1.json(), resp2.json())
json_ = resp1.json()
# FIXME: IMPROVE TESTS? what to assert?
# test text format:
resp2 = client.post(self.url,
data=dict(inputdic, format='text'),
content_type='text/csv')
assert resp2.status_code == 200
assert expected_txt.search(resp2.content)
assert len(resp2.content) > len(expected_txt.pattern)
def test_trellis_dist(self,
# pytest fixtures:
client, testdata, areequal, trellis_type):
'''test trellis distance and distance stdev'''
inputdic = dict(testdata.readyaml(self.request_filename),
plot_type=trellis_type)
resp1 = client.get(querystring(inputdic, baseurl=self.url))
resp2 = client.post(self.url, data=inputdic,
content_type='application/json')
result = resp1.json()
assert resp1.status_code == 200
assert areequal(result, resp2.json())
form = TrellisForm(data=inputdic)
assert form.is_valid()
input_ = form.cleaned_data
assert sorted(result.keys()) == ['PGA', 'PGV', 'SA(0.2)', 'imts',
'xlabel', 'xvalues']
xvalues = result['xvalues']
assert len(xvalues) == len(input_['distance']) + 1 # FIXME: should be len(distance)!!!
figures = self.get_figures(result)
assert len(figures) == len(input_['magnitude']) * len(input_['imt'])
for fig in figures:
yvalues = fig['yvalues']
assert all(len(yval) == len(xvalues) for yval in yvalues.values())
assert sorted(yvalues.keys()) == sorted(input_['gsim'])
# test the text response:
resp2 = client.post(self.url, data=dict(inputdic, format='text'),
content_type='text/csv')
assert resp2.status_code == 200
assert re.search(self.csv_expected_text, resp2.content)
def test_mismatching_imt_gsim(
self,
# pytest fixtures:
areequal,
client):
'''tests a special case whereby a GSIM is empty (this case raised
before a PR to smtk repository)'''
inputdic = {
"gsim": ["AkkarEtAlRjb2014"],
"imt": ["CAV"],
"magnitude": "3:4",
"distance": "10:12",
"dip": "60",
"aspect": "1.5",
"rake": "0.0",
"ztor": "0.0",
"strike": "0.0",
"msr": "WC1994",
"initial_point": "0 0",
"hypocentre_location": "0.5 0.5",
"vs30": "760.0",
"vs30_measured": True,
"line_azimuth": "0.0",
"stdev": True,
"plot_type": "d"
}
resp1 = client.get(querystring(inputdic, baseurl=self.url))
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
result = resp1.json()
assert resp1.status_code == 400
assert areequal(result, resp2.json())
expected_json = {
'error': {
'code':
400,
'message':
'Invalid input in gsim, imt',
'errors': [{
'domain':
'gsim',
'message': ('1 gsim(s) not defined for '
'all supplied imt(s)'),
'reason':
'invalid'
}, {
'domain':
'imt',
'message': ('1 imt(s) not defined for all '
'supplied gsim(s)'),
'reason':
'invalid'
}]
}
}
assert areequal(resp1.json(), expected_json)
def test_gsims_service_imt_no_match(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the gsims API service with no match for imt provided with
wildcards'''
inputdic = testdata.readyaml(self.request_filename)
# use a key which is not in the defined sets of OpenQuake's IMTs.
inputdic.update(imt='*KW?,[]')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
# use another key which is not in the defined sets of OpenQuake's IMTs:
inputdic.update(imt='KW?')
resp2 = client.get(querystring(inputdic, baseurl=self.url))
assert areequal(resp1.json(), resp2.json())
# no gsim found:
assert resp1.status_code == resp2.status_code == 200
# no gsim found:
assert resp1.json() == resp2.json() == []
def test_error(
self,
# pytest fixtures:
client,
areequal):
'''tests a special case where we supply a deprecated gsim (not in
EGSIM list)'''
inputdic = {
"gsim": ["AkkarEtAl2013", "AkkarEtAlRepi2014"],
"imt": ["PGA", "PGV"],
"magnitude": "3:4",
"distance": "10:12",
"dip": "60",
"aspect": "1.5",
"rake": "0.0",
"ztor": "0.0",
"strike": "0.0",
"msr": "WC1994",
"initial_point": "0 0",
"hypocentre_location": "0.5 0.5",
"vs30": "760.0",
"vs30_measured": True,
"line_azimuth": "0.0",
"stdev": True,
"plot_type": "d"
}
resp1 = client.get(querystring(inputdic, baseurl=self.url))
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
result = resp1.json()
assert resp1.status_code == 400
assert areequal(result, resp2.json())
expected_err_json = {
'error': {
'code':
400,
'message':
'Invalid input in gsim',
'errors': [{
'domain':
'gsim',
'message': ('Select a valid choice. AkkarEtAl2013 is '
'not one of the available choices.'),
'reason':
'invalid_choice'
}]
}
}
assert areequal(result, expected_err_json)
def test_empty_gsim(self,
# pytest fixtures:
areequal, client):
'''tests a special case whereby a GSIM is empty (this case raised
before a PR to smtk repository)'''
inputdic = {
"gsim": [
"AbrahamsonEtAl2014",
"AbrahamsonEtAl2014NSHMPLower",
"AbrahamsonEtAl2014NSHMPMean",
"AbrahamsonEtAl2014NSHMPUpper",
"AbrahamsonEtAl2014RegCHN",
"AbrahamsonEtAl2014RegJPN",
"AbrahamsonEtAl2014RegTWN",
"AkkarBommer2010SWISS01",
"AkkarBommer2010SWISS04",
"AkkarBommer2010SWISS08",
"AkkarEtAlRepi2014"
],
"imt": ["PGA", "PGV"],
"magnitude": "3:4",
"distance": "10:12",
"dip": "60",
"aspect": "1.5",
"rake": "0.0",
"ztor": "0.0",
"strike": "0.0",
"msr": "WC1994",
"initial_point": "0 0",
"hypocentre_location": "0.5 0.5",
"vs30": "760.0",
"vs30_measured": True,
"line_azimuth": "0.0",
"plot_type": "ds"
}
resp1 = client.get(querystring(inputdic, baseurl=self.url))
resp2 = client.post(self.url, data=inputdic,
content_type='application/json')
result = resp1.json()
assert resp1.status_code == 200
assert areequal(result, resp2.json())
# form = TrellisForm(in)
# assert form.is_valid()
# result = get_trellis(form.cleaned_data)
figures = self.get_figures(result)
assert any(_['yvalues']['AkkarBommer2010SWISS01'] == []
for _ in figures)
def test_trellis_spectra(self,
# pytest fixtures:
client, testdata, areequal, trellis_type):
'''test trellis magnitude-distance spectra and magnitude-distance
stdev'''
inputdic = dict(testdata.readyaml(self.request_filename),
plot_type=trellis_type)
resp1 = client.get(querystring(inputdic, baseurl=self.url))
resp2 = client.post(self.url, data=inputdic,
content_type='application/json')
result = resp1.json()
assert resp1.status_code == 200
assert areequal(result, resp2.json())
form = TrellisForm(data=inputdic)
assert form.is_valid()
input_ = form.cleaned_data
assert sorted(result.keys()) == ['SA', 'imts', 'xlabel', 'xvalues']
xvalues = result['xvalues']
assert len(xvalues) == len(_default_periods_for_spectra())
figures = self.get_figures(result)
assert len(figures) == \
len(input_['distance']) * len(input_['magnitude'])
for fig in figures:
yvalues = fig['yvalues']
assert all(len(yval) == len(xvalues) for yval in yvalues.values())
assert sorted(yvalues.keys()) == sorted(input_['gsim'])
# test the text response:
resp2 = client.post(self.url, data=dict(inputdic, format='text'),
content_type='text/csv')
assert resp2.status_code == 200
assert re.search(self.csv_expected_text, resp2.content)
# test for the frontend: supply SA incorrectly but check that it's
# ignored
resp1 = client.post(self.url, data=dict(inputdic, imt='SA',
sa_period='(set'),
content_type='application/json')
result = resp1.json()
assert resp1.status_code == 200
# supply also wrong imt (ignored, SA is used):
resp1 = client.post(self.url, data=dict(inputdic, imt='PGV',
sa_period='(set'),
content_type='application/json')
result = resp1.json()
assert resp1.status_code == 200
def test_querystring():
value = 'abc'
with pytest.raises(AttributeError): # @UndefinedVariable
querystring(value)
value = {'abc': {'a': 9}}
with pytest.raises(ValueError): # @UndefinedVariable
querystring(value)
ddd = datetime(2016, 1, 3, 4, 5, 6, 345)
value = {'abc': ddd}
patt = querystring(value)
assert patt == "abc=2016-01-03T04:05:06.000345"
for ddd in [date(2011, 4, 5), datetime(2011, 4, 5)]:
assert querystring({'abc': ddd}) == "abc=2011-04-05"
value = {'abc': [1, 'a', 1.1, '&invalid']}
patt = querystring(value)
assert patt == 'abc=1,a,1.1,%26invalid'
def test_gmdbplot_service_dists(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the gmdbplot API service iterating on all distances'''
for dist in DISTANCE_LABEL.keys():
inputdic = testdata.readyaml(self.request_filename)
inputdic['distance_type'] = dist
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 200
assert areequal(resp1.json(), resp2.json())
json_ = resp1.json()
assert len(json_['xvalues']) == len(json_['yvalues']) > 0
def test_gsims_service_no_result_wrong_trt(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the gsims API service with a wrong tectonic region type'''
inputdic = testdata.readyaml(self.request_filename)
inputdic.update(trt='stable_continental_region')
# use a key which is not in the defined sets of OpenQuake's TRTs:
resp1 = client.get(querystring(inputdic, baseurl=self.url))
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
assert resp1.status_code == resp2.status_code == 400
assert areequal(resp1.json(), resp2.json())
assert isinstance(resp1.json(), dict) and \
resp1.json()['error']['code'] == 400
def test_gsims_service(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the gsims API service'''
inputdic = testdata.readyaml(self.request_filename)
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 200
assert areequal(resp1.json(), resp2.json())
expected_gsims = [
k[0] for k in aval_gsims(asjsonlist=True)
if k[2] == inputdic['trt']
]
assert sorted(resp1.json()) == sorted(expected_gsims)
# now try to supply two filters on gsim:
expected_gsims = [_ for _ in expected_gsims if _[0] in ('A', )]
inputdic['gsim'] = expected_gsims
resp1 = client.get(self.url, data=inputdic)
inputdic['gsim'] = 'A*'
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
assert resp1.status_code == resp2.status_code == 200
assert areequal(resp1.json(), resp2.json())
assert sorted(resp1.json()) == sorted(resp1.json()) == \
sorted(expected_gsims)
# test text format:
resp2 = client.post(self.url,
data=dict(inputdic, format='text'),
content_type='text/csv')
assert resp2.status_code == 200
assert areequal(resp1.json(),
[_.decode('utf8') for _ in resp2.content.split()])
def tst_trellis_mag(
self,
# pytest fixtures:
client,
testdata,
areequal,
# parametrized argument:
st_dev):
'''test trellis magnitude and magnitude stdev'''
inputdic = dict(testdata.readyaml(self.request_filename),
plot_type='m',
stdev=st_dev)
resp1 = client.get(querystring(inputdic, baseurl=self.url))
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
result = resp1.json()
assert resp1.status_code == 200
assert areequal(result, resp2.json())
form = TrellisForm(data=inputdic)
assert form.is_valid()
input_ = form.cleaned_data
assert sorted(result.keys()) == [
'PGA', 'PGV', 'SA(0.2)', 'imts', 'xlabel', 'xvalues'
]
xvalues = result['xvalues']
assert len(xvalues) == len(input_['magnitude'])
figures = self.get_figures(result)
if st_dev:
# assert we wrtoe the stdevs:
assert all(_['stdvalues'] for _ in figures)
assert all(_['stdlabel'] for _ in figures)
else:
# assert we did NOT write stdevs:
assert not any(_['stdvalues'] for _ in figures)
assert not any(_['stdlabel'] for _ in figures)
assert len(figures) == len(input_['distance']) * len(input_['imt'])
for fig in figures:
yvalues = fig['yvalues']
assert all(len(yval) == len(xvalues) for yval in yvalues.values())
assert sorted(yvalues.keys()) == sorted(input_['gsim'])
# test the text response:
resp2 = client.post(self.url,
data=dict(inputdic, format='text'),
content_type='text/csv')
assert resp2.status_code == 200
assert re.search(self.csv_expected_text, resp2.content)
ref_resp = resp2.content
# test different text formats
for text_sep, symbol in TextSepField._base_choices.items():
resp3 = client.post(self.url,
data=dict(inputdic,
format='text',
text_sep=text_sep),
content_type='text/csv')
assert resp3.status_code == 200
real_content = sorted(_ for _ in resp3.content.split(b'\r\n'))
expected_content = \
sorted(_ for _ in
ref_resp.replace(b',',
symbol.encode('utf8')).split(b'\r\n'))
if text_sep != 'space':
# FIXME: we do not test the space because quotation marks
# are involved and thus the text comparison is harder.
# We should read it with csv...
assert real_content == expected_content
resp3 = client.post(self.url,
data=dict(inputdic,
format='text',
text_sep='semicolon',
text_dec='comma'),
content_type='text/csv')
assert resp3.status_code == 200
real_content = sorted(_ for _ in resp3.content.split(b'\r\n'))
expected_content = \
sorted(_ for _ in
ref_resp.replace(b',', b';').replace(b'.', b',').
split(b'\r\n'))
# asserting all rows are equal fails. This might be due to rounding
# errors, thus assert only first line is equal. Not really sound,
# but better than nothing
assert real_content[0] == expected_content[0]
resp3 = client.post(self.url,
data=dict(inputdic,
format='text',
text_dec='comma'),
content_type='text/csv')
assert resp3.status_code == 400
expected_json = {
'error': {
'code':
400,
'message':
'Invalid input in text_sep, text_dec',
'errors': [{
'domain':
'text_sep',
'message': ("'text_sep' must differ from"
" 'text_dec' in 'text' format"),
'reason':
'conflicting values'
}, {
'domain':
'text_dec',
'message': ("'text_sep' must differ from"
" 'text_dec' in 'text' format"),
'reason':
'conflicting values'
}]
}
}
assert areequal(resp3.json(), expected_json)
def test_gmdbplot_errors(
self,
# pytest fixtures:
testdata,
areequal,
client):
'''tests the gmdbplot API service with errors'''
inputdic = testdata.readyaml(self.request_filename)
inputdic['gmdb'] = 'notexistingtable'
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 400
assert areequal(resp1.json(), resp2.json())
json_ = resp1.json()
expected_json = {
'error': {
'code':
400,
'message':
'Invalid input in gmdb',
'errors': [{
'domain':
'gmdb',
'message': ('Select a valid choice. notexistingtable '
'is not one of the available choices.'),
'reason':
'invalid_choice'
}]
}
}
assert areequal(json_, expected_json)
inputdic = testdata.readyaml(self.request_filename)
inputdic['dist'] = 'notexistingdist'
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 400
assert areequal(resp1.json(), resp2.json())
json_ = resp1.json()
expected_json = {
'error': {
'code':
400,
'message':
'Invalid input in distance_type',
'errors': [{
'domain':
'distance_type',
'message': ('Select a valid choice. notexistingdist '
'is not one of the available choices.'),
'reason':
'invalid_choice'
}]
}
}
assert areequal(json_, expected_json)
inputdic = testdata.readyaml(self.request_filename)
inputdic['sel'] = '(magnitude > 5a' # expression error
# this should be caught by the middleware. For the moment
# we assert it raises:
resp2 = client.post(self.url,
data=inputdic,
content_type='application/json')
resp1 = client.get(querystring(inputdic, baseurl=self.url))
assert resp1.status_code == resp2.status_code == 400
assert areequal(resp1.json(), resp2.json())
json_ = resp1.json()
expected = {
'error': {
'code':
400,
'message':
'Invalid input in selexpr',
'errors': [{
'domain':
'selexpr',
'message': ('unexpected EOF while parsing: '
'"(magnitude > 5a"'),
'reason':
'invalid'
}]
}
}
assert areequal(json_, expected)
