def test_sncl_get_valid_loc_minus(self, mock_request):
# request.method == 'GET'
mock_request.method = 'GET'
s = schema.StreamEpochSchema(context={'request': mock_request})
# define multiple channels
reference_result = {
'network': '*',
'station': '*',
'location': '--',
'channel': '*'
}
test_dataset = {'loc': '--'}
test_dataset = self._load(s, test_dataset)
result = self._dump(s, test_dataset)
self.assertEqual(result, reference_result)
test_dataset = {'location': '--'}
test_dataset = self._load(s, test_dataset)
result = self._dump(s, test_dataset)
self.assertEqual(result, reference_result)
test_dataset = {'location': '--', 'loc': '*'}
test_dataset = self._load(s, test_dataset)
result = self._dump(s, test_dataset)
self.assertEqual(result, reference_result)
def test_sncl_get_invalid_cha(self, mock_request):
# request.method == 'GET'
mock_request.method = 'GET'
s = schema.StreamEpochSchema(context={'request': mock_request})
test_dataset = {'net': 'CH', 'sta': 'DAVOX', 'cha': 'BH,'}
with self.assertRaises(ma.ValidationError):
test_dataset = self._load(s, test_dataset)
def test_sncl_get_end_lt_start(self, mock_request):
# request.method == 'GET'
mock_request.method = 'GET'
s = schema.StreamEpochSchema(context={'request': mock_request})
# define endtime <= starttime
test_dataset = {'net': 'CH', 'sta': 'DAVOX', 'end': '2017-01-01',
'start': '2017-02-01'}
with self.assertRaises(ma.ValidationError):
test_dataset = self._load(s, test_dataset)
def test_sncl_get_start_future(self, mock_request):
# request.method == 'GET'
mock_request.method = 'GET'
s = schema.StreamEpochSchema(context={'request': mock_request})
# define starttime in future
future = datetime.datetime.now() + datetime.timedelta(1)
future = future.isoformat()
test_dataset = {'net': 'CH', 'sta': 'DAVOX', 'start': future}
with self.assertRaises(ma.ValidationError):
test_dataset = self._load(s, test_dataset)
def test_sncl_post_missing_time(self, mock_request):
# request.method == 'POST
mock_request.method = 'POST'
s = schema.StreamEpochSchema(context={'request': mock_request})
# define a invalid SNCL
test_dataset = {
'net': 'CH',
'sta': 'DAVOX',
'loc': '*',
'cha': '*',
'start': '2017-01-01'}
with self.assertRaises(ma.ValidationError):
self._load(s, test_dataset)
def test_sncl_post_start_lt_end(self, mock_request):
# request.method == 'POST'
mock_request.method = 'POST'
s = schema.StreamEpochSchema(context={'request': mock_request})
# invalid time definition
test_dataset = {
'net': 'CH',
'sta': 'DAVOX',
'loc': '*',
'cha': '*',
'start': '2017-01-02',
'end': '2017-01-01'}
with self.assertRaises(ma.ValidationError):
self._load(s, test_dataset)
def test_sncl_get_end_future(self, mock_request):
# request.method == 'GET'
mock_request.method = 'GET'
s = schema.StreamEpochSchema(context={'request': mock_request})
# define endtime in future
now = datetime.datetime.utcnow()
tomorrow = now + datetime.timedelta(1)
tomorrow_str = tomorrow.isoformat()
test_dataset = {'net': 'CH', 'sta': 'DAVOX',
'end': tomorrow_str}
result = self._load(s, test_dataset)
self.assertAlmostEqual(result.endtime, now,
delta=datetime.timedelta(seconds=1))
def test_sncl_get(self, mock_request):
# request.method == 'GET'
mock_request.method = 'GET'
s = schema.StreamEpochSchema(context={'request': mock_request})
# no time definitions
reference_result = {
'network': 'CH?*',
'station': 'DAVOX?*',
'location': '*?ABC',
'channel': 'AZ?*'}
test_dataset = {'network': 'CH?*', 'sta': 'DAVOX?*', 'loc': '*?ABC',
'cha': 'AZ?*'}
test_dataset = self._load(s, test_dataset)
result = self._dump(s, test_dataset)
self.assertEqual(result, reference_result)
def test_sncl_get_end(self, mock_request):
# request.method == 'GET'
mock_request.method = 'GET'
s = schema.StreamEpochSchema(context={'request': mock_request})
# only endtime definition
reference_result = {
'network': 'CH',
'station': 'DAVOX',
'location': '*',
'channel': '*',
'endtime': '2017-01-01T00:00:00'}
test_dataset = {'net': 'CH', 'sta': 'DAVOX', 'end': '2017-01-01'}
test_dataset = self._load(s, test_dataset)
result = self._dump(s, test_dataset)
self.assertEqual(result, reference_result)
def test_sncl_post(self, mock_request):
# request.method == 'POST'
mock_request.method = 'POST'
s = schema.StreamEpochSchema(context={'request': mock_request})
# valid values - single SNCL line
reference_result = sncl.StreamEpoch(
stream=sncl.Stream(network='CH', station='DAVOX'),
starttime=datetime.datetime(2017, 1, 1),
endtime=datetime.datetime(2017, 1, 2))
test_dataset = {
'net': 'CH',
'sta': 'DAVOX',
'loc': '*',
'cha': '*',
'start': '2017-01-01',
'end': '2017-01-02'}
result = self._load(s, test_dataset)
self.assertEqual(result, reference_result)
def test_sncl_get_end_future_wfcatalog(self, mock_request):
# request.method == 'GET'
mock_request.method = 'GET'
s = schema.StreamEpochSchema(context={
'request': mock_request,
'service': 'eidaws-wfcatalog'
})
# define endtime in future
now = datetime.datetime.utcnow()
tomorrow = now + datetime.timedelta(1)
tomorrow_str = tomorrow.isoformat()
test_dataset = {
'net': 'CH',
'sta': 'DAVOX',
'start': now.isoformat(),
'end': tomorrow_str
}
result = self._load(s, test_dataset)
self.assertEqual(result.endtime, tomorrow)
def test_sncl_post_start_end_future(self, mock_request):
# request.method == 'POST'
mock_request.method = 'POST'
s = schema.StreamEpochSchema(context={'request': mock_request})
# both starttime and endtime in future
today = datetime.datetime.now()
tomorrow = today + datetime.timedelta(1)
tomorrow_str = tomorrow.isoformat()
dat = today + datetime.timedelta(2)
dat_str = dat.isoformat()
test_dataset = {
'net': 'CH',
'sta': 'DAVOX',
'loc': '*',
'cha': '*',
'start': tomorrow_str,
'end': dat_str
}
with self.assertRaises(ma.ValidationError):
self._load(s, test_dataset)
def test_sncl_post_start_end_future(self, mock_request):
# request.method == 'POST'
mock_request.method = 'POST'
s = schema.StreamEpochSchema(context={'request': mock_request})
# both starttime and endtime in future (not caught)
today = datetime.datetime.now()
tomorrow = today + datetime.timedelta(1)
tomorrow_str = tomorrow.isoformat()
dat = today + datetime.timedelta(2)
dat_str = dat.isoformat()
reference_result = sncl.StreamEpoch(
stream=sncl.Stream(network='CH', station='DAVOX'),
starttime=tomorrow,
endtime=dat)
test_dataset = {'net': 'CH',
'sta': 'DAVOX',
'loc': '*',
'cha': '*',
'start': tomorrow_str,
'end': dat_str}
result = self._load(s, test_dataset)
self.assertEqual(result, reference_result)
