# -*- coding: utf-8 -*-
"""Tests for `lemi_metadata` module."""
import openpyxl
import pickle
import unittest
from obspy import UTCDateTime
from pathlib import Path
from lemi2seed.lemi_data import LemiData
from lemi2seed.lemi_metadata import LemiMetadata
from lemi2seed.logging import setup_logger
from lemi2seed.metadata_category import Elec, Mag, Aux
OUTPUT_MSEED = Path(__file__).resolve().parent.joinpath('MSEED')
OUTPUT_LOG = Path(__file__).resolve().parent.joinpath('LOG')
OUTPUT_XML = Path(__file__).resolve().parent.joinpath('STATIONXML')
TEST_DIR = Path(__file__).resolve().parent.joinpath('test_data')
SCR_DIR = "lemi2seed.lemi_metadata"
# Set up logging
logger = setup_logger(SCR_DIR)
class TestLemiMetadata(unittest.TestCase):
"""Test suite for LemiMetadata class."""
def setUp(self):
"""Set up test fixtures"""
lemi_data = LemiData(TEST_DIR.joinpath("EM", "TEST5"), OUTPUT_MSEED, OUTPUT_LOG)
lemi_data.prep_data()
self.data = lemi_data
self.path2md = TEST_DIR.joinpath("METADATA")
self.path2md_fail_1 = TEST_DIR.joinpath("METADATA_NO_FIELD_SHEET")
self.path2md_fail_2 = TEST_DIR.joinpath("METADATA_CORRUPTED")
self.file = self.path2md.joinpath('LEMI_Install_Sheet.xlsx')
self.md = LemiMetadata(self.path2md, OUTPUT_XML, self.data)
file_ = self.path2md.joinpath('metadata_fields.pkl')
with open(file_, 'rb') as fin:
self.md_fields_no_reformat = pickle.load(fin)
file_ = self.path2md.joinpath('metadata_fields_reformatted.pkl')
with open(file_, 'rb') as fin:
self.md_fields = pickle.load(fin)
def test_scan_path2md_field_sheet_provided(self):
"""Test basic functionality of scan_path2md."""
md = LemiMetadata(self.path2md, OUTPUT_XML, self.data)
self.assertEqual(*md.filenames, self.file)
def test_scan_path2md_no_field_sheet_provided(self):
"""Test basic functionality of scan_path2md."""
with self.assertLogs(logger, level='ERROR') as cmd:
LemiMetadata(self.path2md_fail_1, OUTPUT_XML, self.data)
msg = ("No field sheet found under the following path - {}. All "
"metadata will have to be provided using the GUI!"
.format(self.path2md_fail_1))
self.assertEqual(cmd.output, [":".join(['ERROR', SCR_DIR, msg])])
def test_get_md_field_pass(self):
"""Test basic functionality of get_md_field."""
workbook = openpyxl.load_workbook(self.file, data_only=True)
sheet = workbook.active
self.assertEqual(LemiMetadata.get_md_field(sheet, 'B3'), 'EM')
workbook.close()
def test_get_md_field_fail(self):
"""Test basic functionality of get_md_field."""
workbook = openpyxl.load_workbook(self.file, data_only=True)
sheet = workbook.active
with self.assertLogs(logger, level='ERROR'):
self.assertIsNone(LemiMetadata.get_md_field(sheet, 12))
workbook.close()
def test_identify_field_sheet_pass(self):
"""Test basic functionality of identify_field_sheet."""
workbook = openpyxl.load_workbook(self.file, data_only=True)
sheet = workbook.active
sheet_type = self.md.identify_field_sheet(sheet, 'LEMI_Install_Sheet.xlsx')
self.assertEqual(sheet_type, 'install_sheet')
workbook.close()
def test_identify_field_sheet_fail(self):
"""Test basic functionality of identify_field_sheet."""
md = LemiMetadata(self.path2md_fail_2, OUTPUT_XML, self.data)
file_ = self.path2md_fail_2.joinpath('LEMI_Install_Sheet_2.xlsx')
workbook = openpyxl.load_workbook(file_, data_only=True)
sheet = workbook.active
with self.assertLogs(logger, level='WARNING') as cmd:
md.identify_field_sheet(sheet, file_)
msg = ("The following file {} does not have the proper header. The "
"provided spread sheet templates were not used or their "
"layout was modified. Skipping file!".format(file_))
self.assertEqual(cmd.output, [":".join(['WARNING', SCR_DIR, msg])])
workbook.close()
def test_reformat_run(self):
"""Test basic functionality of reformat_run."""
run_fields = self.md_fields_no_reformat['Run']
file_ = self.path2md.joinpath('run_fields_reformatted.pkl')
with open(file_, 'rb') as fin:
reformatted = pickle.load(fin)
self.assertDictEqual(self.md.reformat_run(run_fields), reformatted)
def test_reformat_elec(self):
"""Test basic functionality of reformat_elec."""
elec_fields = self.md_fields_no_reformat['Elec']
file_ = self.path2md.joinpath('electric_fields_reformatted.pkl')
with open(file_, 'rb') as fin:
reformatted = pickle.load(fin)
self.assertDictEqual(self.md.reformat_elec(elec_fields), reformatted)
def test_reformat_mag(self):
"""Test basic functionality of reformat_mag."""
mag_fields = self.md_fields_no_reformat['Mag']
file_ = self.path2md.joinpath('magnetic_fields_reformatted.pkl')
with open(file_, 'rb') as fin:
reformatted = pickle.load(fin)
self.assertDictEqual(self.md.reformat_mag(mag_fields), reformatted)
def test_reformat_md_dict(self):
"""Test basic functionality of reformat_md_dict."""
self.assertDictEqual(self.md.reformat_md_dict(self.md_fields_no_reformat),
self.md_fields)
def test_from_field_sheets_failed_to_open(self):
"""Test basic functionality of from_field_sheets"""
self.md.filenames = [self.path2md_fail_2.joinpath('LEMI_Install_Sheet_1.xlsx')]
with self.assertLogs(logger, level='ERROR') as cmd:
self.md.from_field_sheets
msg = ("Failed to open field sheet: {} - Skipping file - Exception: "
"File is not a zip file".format(self.md.filenames[0]))
self.assertEqual(cmd.output, [":".join(['ERROR', SCR_DIR, msg])])
def test_from_field_sheets_duplicate_sheet_type(self):
"""Test basic functionality of from_field_sheets"""
self.md.filenames = [self.file] * 2
with self.assertLogs(logger, level='WARNING') as cmd:
self.md.from_field_sheets
msg = ("Already parsed the install sheet - You may have more than one "
"install sheet - Skipping {}!".format(self.file))
self.assertEqual(cmd.output, [":".join(['WARNING', SCR_DIR, msg])])
def test_from_field_sheets_expected_workflow(self):
"""Test basic functionality of from_field_sheets"""
self.assertDictEqual(self.md.from_field_sheets, self.md_fields)
def test_populate_net_md_props(self):
"""Test basic functionality of populate_net_md_props."""
self.md.populate_net_md_props(self.md_fields['Net'])
self.assertSetEqual(self.md.net.md_missing,
{'geo_name', 'start', 'project', 'name'})
self.assertSetEqual(self.md.net.md_invalid, {'start'})
for key, val in self.md_fields['Net'].items():
if key not in self.md.net.md_invalid:
self.assertEqual(getattr(self.md.net, key), val)
self.assertIsNone(self.md.net.start)
def test_populate_sta_md_props(self):
"""Test basic functionality of populate_sta_md_props."""
self.md.populate_sta_md_props(self.md_fields['Sta'])
self.assertSetEqual(self.md.sta.md_missing,
{'end', 'elev', 'lon', 'start', 'geo_name'})
self.assertSetEqual(self.md.sta.md_invalid, {'elev', 'lon', 'start'})
for key, val in self.md_fields['Sta'].items():
if key not in self.md.sta.md_invalid:
self.assertEqual(getattr(self.md.sta, key), val)
self.assertEqual(self.md.sta.run_list, 'a, b, c, d')
self.assertIsNone(self.md.sta.elev)
self.assertIsNone(self.md.sta.start)
def test_init_run_md_props(self):
"""Test basic functionality of init_run_md_props."""
time_period_starts = [UTCDateTime(2020, 9, 30, 21, 5),
UTCDateTime(2020, 9, 30, 21, 12),
UTCDateTime(2020, 9, 30, 21, 14),
UTCDateTime(2020, 10, 1, 0, 0)]
time_period_ends = [UTCDateTime(2020, 9, 30, 21, 11, 1),
UTCDateTime(2020, 9, 30, 21, 13, 45),
UTCDateTime(2020, 9, 30, 21, 27, 59),
UTCDateTime(2020, 10, 1, 0, 5, 59)]
self.md.init_run_md_props()
for ind, run in enumerate(self.md.run):
self.assertEqual(run.start, time_period_starts[ind])
self.assertEqual(run.end, time_period_ends[ind])
self.assertEqual(run.resource_id, 'mt.run.id:' + self.md.run_list[ind])
def test_populate_run_md_props(self):
"""Test basic functionality of populate_run_md_props."""
self.md.populate_run_md_props(self.md_fields['Run'])
self.assertEqual(self.md.run[0].comps_rec, 'E1, E2, E3, E4, Hx, Hy, Hz')
self.assertEqual(self.md.run[0].datalogger_sn, 110)
self.assertSetEqual(self.md.run[0].md_missing, set())
self.assertSetEqual(self.md.run[0].md_invalid, set())
for run in self.md.run[1:]:
self.assertIsNone(run.comps_rec)
self.assertIsNone(run.datalogger_sn)
self.assertSetEqual(run.md_missing, {'datalogger_sn', 'comps_rec'})
self.assertSetEqual(run.md_invalid, {'datalogger_sn', 'comps_rec'})
def test_init_cha_md_props_elec(self):
"""Test basic functionality of init_cha_md_props."""
cha = self.md.init_cha_md_props('elec', 'a')
self.assertIsInstance(cha, Elec)
self.assertEqual(cha.elev, round(self.md.data_stats['elev'], 3))
self.assertEqual(cha.lat, round(self.md.data_stats['lat'], 3))
self.assertEqual(cha.lon, round(self.md.data_stats['lon'], 3))
self.assertEqual(cha.run_id, 'a')
def test_init_cha_md_props_mag(self):
"""Test basic functionality of init_cha_md_props."""
cha = self.md.init_cha_md_props('mag', 'a')
self.assertIsInstance(cha, Mag)
self.assertEqual(cha.elev, round(self.md.data_stats['elev'], 3))
self.assertEqual(cha.lat, round(self.md.data_stats['lat'], 3))
self.assertEqual(cha.lon, round(self.md.data_stats['lon'], 3))
self.assertEqual(cha.run_id, 'a')
def test_init_cha_md_props_aux(self):
"""Test basic functionality of init_cha_md_props."""
cha = self.md.init_cha_md_props('aux', 'a')
self.assertIsInstance(cha, Aux)
self.assertEqual(cha.elev, round(self.md.data_stats['elev'], 3))
self.assertEqual(cha.lat, round(self.md.data_stats['lat'], 3))
self.assertEqual(cha.lon, round(self.md.data_stats['lon'], 3))
self.assertEqual(cha.run_id, 'a')
def test_populate_elec_md_props_one_run_set(self):
"""Test basic functionality of populate_elec_md_props."""
self.md.populate_run_md_props(self.md_fields['Run'])
self.md.populate_elec_md_props(self.md_fields['Elec'])
file_ = self.path2md.joinpath('electric_metadata_properties_1.pkl')
with open(file_, 'rb') as fin:
expected = pickle.load(fin)
self.assertListEqual(self.md.elec, expected)
def test_populate_elec_md_props_two_runs_set(self):
"""Test basic functionality of populate_elec_md_props."""
self.md.populate_run_md_props(self.md_fields['Run'])
self.md.run[1].comps_rec = 'E1, E2, Hx, Hy, Hz'
specs = 'Borin STELTH 4 - Silver-Silver Chloride'
self.md_fields['Elec']['Run_b_Elec_Pair_1']['cha_num'] = 'E1'
self.md_fields['Elec']['Run_b_Elec_Pair_2']['cha_num'] = 'E2'
self.md_fields['Elec']['Run_b_Elec_Pair_3']['cha_num'] = 'E3'
self.md_fields['Elec']['Run_b_Elec_Pair_4']['cha_num'] = 'E4'
self.md_fields['Elec']['Run_b_Elec_Pair_1']['inst_specs'] = specs
self.md_fields['Elec']['Run_b_Elec_Pair_2']['inst_specs'] = specs
self.md.populate_elec_md_props(self.md_fields['Elec'])
file_ = self.path2md.joinpath('electric_metadata_properties_2.pkl')
with open(file_, 'rb') as fin:
expected = pickle.load(fin)
self.assertListEqual(self.md.elec, expected)
def test_populate_mag_md_props_one_run_set(self):
"""Test basic functionality of populate_mag_md_props."""
self.md.populate_run_md_props(self.md_fields['Run'])
self.md.populate_mag_md_props(self.md_fields['Mag'])
file_ = self.path2md.joinpath('magnetic_metadata_properties_1.pkl')
with open(file_, 'rb') as fin:
expected = pickle.load(fin)
self.assertListEqual(self.md.mag, expected)
def test_populate_mag_md_props_two_runs_set(self):
"""Test basic functionality of populate_mag_md_props."""
self.md.populate_run_md_props(self.md_fields['Run'])
self.md.run[1].comps_rec = 'E1, E2, Hx, Hy, Hz'
specs = 'LEMI-039'
self.md_fields['Mag']['Run_b_Mag']['inst_specs'] = specs
self.md.populate_mag_md_props(self.md_fields['Mag'])
file_ = self.path2md.joinpath('magnetic_metadata_properties_2.pkl')
with open(file_, 'rb') as fin:
expected = pickle.load(fin)
self.assertListEqual(self.md.mag, expected)
def test_populate_aux_md_props_one_run_set(self):
"""Test basic functionality of populate_aux_md_props."""
self.md.populate_run_md_props(self.md_fields['Run'])
self.md.populate_aux_md_props()
file_ = self.path2md.joinpath('auxiliary_metadata_properties.pkl')
with open(file_, 'rb') as fin:
expected = pickle.load(fin)
self.assertListEqual(self.md.aux, expected)
def test_filter_cha_cha_not_populated_for_given_run(self):
"""Test basic functionality of filter_cha."""
self.assertListEqual(self.md.filter_cha('aux', 'a'), [])
def test_filter_cha_cha_populated_for_given_run(self):
"""Test basic functionality of filter_cha."""
cha_names = ['LEH', 'LKH', 'LKF', 'GNS', 'GST', 'LCE']
self.md.populate_md_props(self.md_fields)
cha_filtered = self.md.filter_cha('aux', 'a')
self.assertEqual(len(cha_filtered), 6)
for ind, cha in enumerate(cha_filtered):
self.assertEqual(cha.cha_name, cha_names[ind])
def test_get_cha_inds_cha_not_populated_for_given_run(self):
"""Test basic functionality of get_cha_inds."""
self.assertListEqual(self.md.get_cha_inds('aux', 'a'), [])
def test_get_cha_inds_cha_populated_for_given_run(self):
"""Test basic functionality of get_cha_inds."""
self.md.populate_md_props(self.md_fields)
cha_inds = self.md.get_cha_inds('aux', 'a')
self.assertListEqual(cha_inds, [0, 1, 2, 3, 4, 5])
def test_get_comps_rec_no_elec(self):
"""Test basic functionality of get_comps_rec."""
type_ = 'E'
cha_type = 'electric field'
run_id = 'b'
self.md.populate_run_md_props(self.md_fields['Run'])
with self.assertLogs(logger, level='WARNING') as cmd:
self.md.get_comps_rec(type_, run_id)
msg = (f"No {cha_type} data recorded for run '{run_id}'. If you "
f"did record {cha_type} data for that run, please update "
"your list of recorded components at the station level "
"accordingly!")
self.assertEqual(cmd.output, [":".join(['WARNING', SCR_DIR, msg])])
def test_get_comps_rec_no_elec_but_mag(self):
"""Test basic functionality of get_comps_rec."""
type_ = 'E'
cha_type = 'electric field'
run_id = 'b'
self.md.populate_run_md_props(self.md_fields['Run'])
self.md.run[1].comps_rec = 'Hx, Hy, Hz'
with self.assertLogs(logger, level='WARNING') as cmd:
self.md.get_comps_rec(type_, run_id)
msg = (f"No {cha_type} data recorded for run '{run_id}'. If you "
f"did record {cha_type} data for that run, please update "
"your list of recorded components at the station level "
"accordingly!")
self.assertEqual(cmd.output, [":".join(['WARNING', SCR_DIR, msg])])
def test_get_comps_rec_elec(self):
"""Test basic functionality of get_comps_rec."""
type_ = 'E'
run_id = 'a'
self.md.populate_run_md_props(self.md_fields['Run'])
comps = self.md.get_comps_rec(type_, run_id)
self.assertEqual(comps, ['E1', 'E2', 'E3', 'E4'])
def test_get_comps_rec_missing_mag(self):
"""Test basic functionality of get_comps_rec."""
type_ = 'H'
cha_type = 'magnetic field'
run_id = 'b'
self.md.populate_run_md_props(self.md_fields['Run'])
self.md.run[1].comps_rec = 'Hx, Hy'
with self.assertLogs(logger, level='WARNING') as cmd:
self.md.get_comps_rec(type_, run_id)
msg = ("LEMI-039 fluxgate is a 3-component magnetometer. If you did "
f"record {cha_type} data for run {run_id}, data from all "
"magnetic components (Hx, Hy and Hz) were recorded. Please "
"update your list of recorded components at the station level.")
self.assertEqual(cmd.output, [":".join(['WARNING', SCR_DIR, msg])])
def test_get_comps_rec_mag(self):
"""Test basic functionality of get_comps_rec."""
type_ = 'H'
run_id = 'a'
self.md.populate_run_md_props(self.md_fields['Run'])
comps = self.md.get_comps_rec(type_, run_id)
self.assertEqual(comps, ['Hx', 'Hy', 'Hz'])
def test_match_num_e_pairs(self):
"""Test basic functionality of match_num_e_pairs."""
comps = ['E1', 'E2', 'E3', 'E4']
run_id = 'a'
self.md.populate_md_props(self.md_fields)
with self.assertLogs(logger, level='ERROR') as cmd:
self.md.match_num_e_pairs(comps, run_id, 2)
msg = (f"Invalid number of electrode pairs (run '{run_id}')! The "
"number of electrode pairs does not match the number of "
"electric channels in your list of recorded components at the "
"station/run level.")
self.assertEqual(cmd.output, [":".join(['ERROR', SCR_DIR, msg])])
for ind, elec in enumerate(self.md.elec):
self.assertSetEqual(elec.md_invalid, {'run_a_num_e_pairs'})
self.md.match_num_e_pairs(comps, run_id, 4)
for elec in self.md.elec:
self.assertSetEqual(elec.md_invalid, set())
def test_match_comps_rec(self):
"""Test basic functionality of match_comps_rec."""
comps = ['E1', 'E2']
run_id = 'a'
self.md.populate_md_props(self.md_fields)
with self.assertLogs(logger, level='ERROR') as cmd:
self.md.match_comps_rec(self.md.elec, comps, run_id)
msg = (f"Invalid electric channel numbers (run '{run_id}')! The "
"channel numbers don't match the electric channels in your "
"list of recorded components at the station/run level.")
self.assertEqual(cmd.output, [":".join(['ERROR', SCR_DIR, msg])])
for e_cha in self.md.elec:
self.assertSetEqual(e_cha.md_invalid, {'cha_num'})
def test_update_cha_num(self):
"""Test basic functionality of update_cha_num."""
cha = self.md.init_cha_md_props('elec', 'a')
self.assertIsNone(cha.cha_num)
updated_cha = LemiMetadata.update_cha_num(cha, 'E1')
self.assertEqual(updated_cha.cha_num, 'E1')
def test_update_comp_cha_name(self):
"""Test basic functionality of update_comp_cha_name."""
cha = self.md.init_cha_md_props('mag', 'a')
self.assertIsNone(cha.cha_name)
self.assertIsNone(cha.comp)
updated_cha = LemiMetadata.update_comp_cha_name(cha, 'Hx')
self.assertEqual(updated_cha.cha_name, 'LFN')
self.assertEqual(updated_cha.comp, 'Hx')
def test_get_e_infos(self):
"""Test basic functionality of get_e_infos."""
comps = ['Ex', 'Ey', 'Ex', 'Ey', 'Ex', 'Ey']
self.md.populate_run_md_props(self.md_fields['Run'])
self.md.run[1].comps_rec = 'E1, E2, Hx, Hy, Hz'
cha = self.md.init_cha_md_props('elec', 'a')
self.md.elec.extend([self.md.update_cha_num(cha, f'E{i+1}')
for i in range(4)])
cha = self.md.init_cha_md_props('elec', 'b')
self.md.elec.extend([self.md.update_cha_num(cha, f'E{i+1}')
for i in range(2)])
for ind, elec in enumerate(self.md.elec):
elec.comp = comps[ind]
e_infos = self.md.get_e_infos()
self.assertDictEqual(e_infos,
{'a': {'E1': 'Ex', 'E2': 'Ey', 'E3': 'Ex', 'E4': 'Ey'},
'b': {'E1': 'Ex', 'E2': 'Ey'}, 'c': {}, 'd': {}})
def test_update_location(self):
"""Test basic functionality of update_location."""
comps = ['Ex', 'Ey', 'Ex', 'Ey']
location_codes = ['00', '00', '01', '01']
self.md.populate_run_md_props(self.md_fields['Run'])
cha = self.md.init_cha_md_props('elec', 'a')
self.md.elec.extend([self.md.update_cha_num(cha, f'E{i+1}') for i in range(4)])
for ind, elec in enumerate(self.md.elec):
elec.comp = comps[ind]
self.assertEqual(elec.loc_code, '')
self.md.update_loc()
for ind, elec in enumerate(self.md.elec):
self.assertEqual(elec.loc_code, location_codes[ind])
def test_flag_md_missing_no_skip(self):
"""Test basic functionality of flag_md_missing."""
LemiMetadata.flag_md_missing(self.md.net)
self.assertSetEqual(self.md.net.md_missing,
{'geo_name', 'start', 'archive_net', 'project',
'end', 'name'})
def test_flag_md_missing_skip(self):
"""Test basic functionality of flag_md_missing."""
LemiMetadata.flag_md_missing(self.md.net, ['geo_name'])
self.assertSetEqual(self.md.net.md_missing,
{'start', 'archive_net', 'project', 'end', 'name'})
def test_dc2dict(self):
"""Test basic functionality of dc2dict."""
cha = self.md.init_cha_md_props('elec', 'a')
self.assertDictEqual(self.md.dc2dict(cha),
{'elev': 2201.725,
'lat': 34.048,
'lon': -107.128,
'inst_manufacturer': None,
'inst_model': None,
'inst_specs': None,
'inst_type': None,
'meas_azimuth': None,
'meas_tilt': None,
'sample_rate': 1.0,
'cha_num': None,
'contact_resistance_end': None,
'contact_resistance_start': None,
'dc_end': None,
'dc_start': None,
'dipole_len': None,
'neg_elec_dir': None,
'neg_elec_sn': None,
'pos_elec_dir': None,
'pos_elec_sn': None})
def test_for_gui_md_not_populated(self):
"""Test basic functionality of for_gui."""
file_ = self.path2md.joinpath('gui_metadata_not_populated.pkl')
with open(file_, 'rb') as fin:
expected = pickle.load(fin)
self.assertDictEqual(self.md.for_gui, expected)
def test_for_gui_md_populated(self):
"""Test basic functionality of for_gui."""
self.md.populate_md_props(self.md_fields)
file_ = self.path2md.joinpath('gui_metadata_populated.pkl')
with open(file_, 'rb') as fin:
expected = pickle.load(fin)
self.assertDictEqual(self.md.for_gui, expected)
def test_save_md(self):
"""Test basic functionality of save_md."""
file_ = self.path2md.joinpath('lemi_metadata.pkl')
self.md.save_md(file_)
self.assertTrue(file_.is_file())
def test_load_md(self):
"""Test basic functionality of load_md."""
file_ = self.path2md.joinpath('lemi_metadata.pkl')
self.md.save_md(file_)
md = LemiMetadata.load_md(file_)
self.assertEqual(md.net, self.md.net)
self.assertEqual(md.sta, self.md.sta)
self.assertListEqual(md.run, self.md.run)
self.assertListEqual(md.elec, self.md.elec)
self.assertListEqual(md.mag, self.md.mag)
self.assertListEqual(md.aux, self.md.aux)
def test_update_azimuth_tilt(self):
"""Test basic functionality of update_azimuth_tilt."""
self.md.populate_md_props(self.md_fields)
self.md.update_azimuth_tilt()
for cha in self.md.filter_cha('mag', 'a'):
if cha.comp == 'Hx':
self.assertEqual(cha.meas_tilt, 0.0)
self.assertEqual(cha.meas_azimuth, 20)
if cha.comp == 'Hy':
self.assertEqual(cha.meas_tilt, 0.0)
self.assertEqual(cha.meas_azimuth, 110.0)
if cha.comp == 'Hz':
self.assertEqual(cha.meas_tilt, -1.0)
self.assertEqual(cha.meas_azimuth, 0.0)
def tearDown(self):
"""Tear down test fixtures"""
file_ = self.path2md.joinpath('lemi_metadata.pkl')
if file_.is_file():
file_.unlink()