afscgap.test.test_flat_model

  1"""
  2Tests for objects reprensenting flat files.
  3
  4(c) 2025 Regents of University of California / The Eric and Wendy Schmidt Center
  5for Data Science and the Environment at UC Berkeley.
  6
  7This file is part of afscgap released under the BSD 3-Clause License. See
  8LICENSE.md.
  9"""
 10import unittest
 11import unittest.mock
 12
 13import afscgap.flat_model
 14
 15EXPECTED_FIELDS = {
 16    'year',
 17    'srvy',
 18    'survey',
 19    'survey_name',
 20    'survey_definition_id',
 21    'cruise',
 22    'cruisejoin',
 23    'hauljoin',
 24    'haul',
 25    'stratum',
 26    'station',
 27    'vessel_id',
 28    'vessel_name',
 29    'date_time',
 30    'latitude_dd_start',
 31    'longitude_dd_start',
 32    'latitude_dd_end',
 33    'longitude_dd_end',
 34    'bottom_temperature_c',
 35    'surface_temperature_c',
 36    'depth_m',
 37    'distance_fished_km',
 38    'duration_hr',
 39    'net_width_m',
 40    'net_height_m',
 41    'area_swept_km2',
 42    'performance',
 43    'species_code',
 44    'cpue_kgkm2',
 45    'cpue_nokm2',
 46    'count',
 47    'weight_kg',
 48    'taxon_confidence',
 49    'scientific_name',
 50    'common_name',
 51    'id_rank',
 52    'worms',
 53    'itis',
 54    'complete'
 55}
 56
 57
 58class ExecuteMetaParamsTests(unittest.TestCase):
 59
 60    def setUp(self):
 61        self._params = afscgap.flat_model.ExecuteMetaParams(
 62            'test_base_url',
 63            'requestor',
 64            123,
 65            True,
 66            False,
 67            True,
 68            'warn_func'
 69        )
 70
 71    def test_get_base_url(self):
 72        self.assertEqual(self._params.get_base_url(), 'test_base_url')
 73
 74    def test_get_requestor(self):
 75        self.assertEqual(self._params.get_requestor(), 'requestor')
 76
 77    def test_get_limit(self):
 78        self.assertEqual(self._params.get_limit(), 123)
 79
 80    def test_get_filter_incomplete(self):
 81        self.assertEqual(self._params.get_filter_incomplete(), True)
 82
 83    def test_get_presence_only(self):
 84        self.assertEqual(self._params.get_presence_only(), False)
 85
 86    def test_get_suppress_large_warning(self):
 87        self.assertEqual(self._params.get_suppress_large_warning(), True)
 88
 89    def test_get_warn_func(self):
 90        self.assertEqual(self._params.get_warn_func(), 'warn_func')
 91
 92
 93class HaulKeyTests(unittest.TestCase):
 94
 95    def setUp(self):
 96        self._key = afscgap.flat_model.HaulKey(2025, 'Gulf of Alaska', 123)
 97        self._key_same = afscgap.flat_model.HaulKey(2025, 'Gulf of Alaska', 123)
 98        self._key_other_year = afscgap.flat_model.HaulKey(2026, 'Gulf of Alaska', 123)
 99        self._key_other_survey = afscgap.flat_model.HaulKey(2025, 'Other', 123)
100        self._key_other_haul = afscgap.flat_model.HaulKey(2025, 'Gulf of Alaska', 124)
101
102    def test_get_year(self):
103        self.assertEqual(self._key.get_year(), 2025)
104
105    def test_get_survey(self):
106        self.assertEqual(self._key.get_survey(), 'Gulf of Alaska')
107
108    def test_get_haul(self):
109        self.assertEqual(self._key.get_haul(), 123)
110
111    def test_get_key_same(self):
112        self.assertEqual(self._key.get_key(), self._key_same.get_key())
113    
114    def test_get_key_different(self):
115        self.assertNotEqual(self._key.get_key(), self._key_other_year.get_key())
116        self.assertNotEqual(self._key.get_key(), self._key_other_survey.get_key())
117        self.assertNotEqual(self._key.get_key(), self._key_other_haul.get_key())
118
119    def test_get_path(self):
120        self.assertEqual(self._key.get_path(), '/joined/2025_Gulf of Alaska_123.avro')
121
122    def test_hash_eq(self):
123        self.assertEqual(hash(self._key), hash(self._key_same))
124
125    def test_hash_neq(self):
126        self.assertNotEqual(hash(self._key), hash(self._key_other_year))
127        self.assertNotEqual(hash(self._key), hash(self._key_other_survey))
128        self.assertNotEqual(hash(self._key), hash(self._key_other_haul))
129
130    def test_repr_eq(self):
131        self.assertEqual(repr(self._key), repr(self._key_same))
132
133    def test_repr_neq(self):
134        self.assertNotEqual(repr(self._key), repr(self._key_other_year))
135        self.assertNotEqual(repr(self._key), repr(self._key_other_survey))
136        self.assertNotEqual(repr(self._key), repr(self._key_other_haul))
137
138    def test_eq(self):
139        self.assertEqual(self._key, self._key_same)
140
141    def test_neq(self):
142        self.assertNotEqual(self._key, self._key_other_year)
143        self.assertNotEqual(self._key, self._key_other_survey)
144        self.assertNotEqual(self._key, self._key_other_haul)
145
146
147class FlatRecordTests(unittest.TestCase):
148
149    def test_get_year(self):
150        self._test_getter('year', 2025, lambda x: x.get_year())
151
152    def test_get_srvy(self):
153        self._test_getter('srvy', 'GOA', lambda x: x.get_srvy())
154
155    def test_get_survey(self):
156        self._test_getter('survey', 'Gulf of Alaska', lambda x: x.get_survey())
157
158    def test_get_survey_id(self):
159        self._test_getter('survey_definition_id', 123, lambda x: x.get_survey_id())
160
161    def test_get_cruise(self):
162        self._test_getter('cruise', 123, lambda x: x.get_cruise())
163
164    def test_get_haul(self):
165        self._test_getter('haul', 123, lambda x: x.get_haul())
166
167    def test_get_stratum(self):
168        self._test_getter('stratum', 123, lambda x: x.get_stratum())
169
170    def test_get_station(self):
171        self._test_getter('station', 'test station', lambda x: x.get_station())
172
173    def test_get_vessel_name(self):
174        self._test_getter('vessel_name', 'test vessel', lambda x: x.get_vessel_name())
175
176    def test_get_vessel_id(self):
177        self._test_getter('vessel_id', 123, lambda x: x.get_vessel_id())
178
179    def test_get_date_time(self):
180        self._test_getter('date_time', '2025-12-31', lambda x: x.get_date_time())
181
182    def test_get_latitude_start(self):
183        self._test_getter('latitude_dd_start', 1.23, lambda x: x.get_latitude_start())
184
185    def test_get_longitude_start(self):
186        self._test_getter('longitude_dd_start', 1.23, lambda x: x.get_longitude_start())
187
188    def test_get_latitude(self):
189        inner = {'latitude_dd_start': 1, 'latitude_dd_end': 3}
190        record = afscgap.flat_model.FlatRecord(inner)
191        self.assertAlmostEqual(record.get_latitude(), 2)
192
193    def test_get_longitude(self):
194        inner = {'longitude_dd_start': 1, 'longitude_dd_end': 3}
195        record = afscgap.flat_model.FlatRecord(inner)
196        self.assertAlmostEqual(record.get_longitude(), 2)
197
198    def test_get_latitude_end(self):
199        self._test_getter('latitude_dd_end', 1.23, lambda x: x.get_latitude_end())
200
201    def test_get_longitude_end(self):
202        self._test_getter('longitude_dd_end', 1.23, lambda x: x.get_longitude_end())
203
204    def test_get_species_code(self):
205        self._test_getter('species_code', 123, lambda x: x.get_species_code())
206
207    def test_get_species_code_empty(self):
208        self._test_getter('species_code', None, lambda x: x.get_species_code())
209
210    def test_get_common_name(self):
211        self._test_getter('common_name', 'test', lambda x: x.get_common_name())
212
213    def test_get_common_name_empty(self):
214        self._test_getter('common_name', None, lambda x: x.get_common_name())
215
216    def test_get_scientific_name(self):
217        self._test_getter('scientific_name', 'test', lambda x: x.get_scientific_name())
218
219    def test_get_scientific_name_empty(self):
220        self._test_getter('scientific_name', None, lambda x: x.get_scientific_name())
221
222    def test_get_taxon_confidence(self):
223        self._test_getter('taxon_confidence', 'test', lambda x: x.get_taxon_confidence())
224
225    def test_get_taxon_confidence_empty(self):
226        self._test_getter('taxon_confidence', None, lambda x: x.get_taxon_confidence())
227
228    def test_get_cpue_weight_maybe_empty(self):
229        self._test_getter('cpue_kgkm2', None, lambda x: x.get_cpue_weight_maybe())
230
231    def test_get_cpue_weight_maybe_convert(self):
232        self._test_getter_convert(
233            'cpue_kgkm2',
234            1.23,
235            lambda x: x.get_cpue_weight_maybe('kg/ha'),
236            'kg/km2',
237            'kg/ha'
238        )
239
240    def test_get_cpue_count_maybe_empty(self):
241        self._test_getter('cpue_nokm2', None, lambda x: x.get_cpue_count_maybe())
242
243    def test_get_cpue_count_maybe_convert(self):
244        self._test_getter_convert(
245            'cpue_nokm2',
246            1.23,
247            lambda x: x.get_cpue_count_maybe('count/ha'),
248            'no/km2',
249            'count/ha'
250        )
251
252    def test_get_weight_maybe_empty(self):
253        self._test_getter('weight_kg', None, lambda x: x.get_weight_maybe())
254
255    def test_get_weight_maybe_convert(self):
256        self._test_getter_convert(
257            'weight_kg',
258            1.23,
259            lambda x: x.get_weight_maybe('g'),
260            'kg',
261            'g'
262        )
263
264    def test_get_count_maybe(self):
265        self._test_getter('count', 1.23, lambda x: x.get_count_maybe())
266
267    def test_get_count_maybe_empty(self):
268        self._test_getter('count', None, lambda x: x.get_count_maybe())
269
270    def test_get_bottom_temperature_maybe(self):
271        self._test_getter(
272            'bottom_temperature_c',
273            1.23,
274            lambda x: x.get_bottom_temperature_maybe()
275        )
276
277    def test_get_bottom_temperature_maybe_empty(self):
278        self._test_getter(
279            'bottom_temperature_c',
280            None,
281            lambda x: x.get_bottom_temperature_maybe()
282        )
283
284    def test_get_bottom_temperature_maybe_convert(self):
285        self._test_getter_convert(
286            'bottom_temperature_c',
287            1.23,
288            lambda x: x.get_bottom_temperature_maybe('f'),
289            'c',
290            'f'
291        )
292
293    def test_get_surface_temperature_maybe(self):
294        self._test_getter(
295            'surface_temperature_c',
296            1.23,
297            lambda x: x.get_surface_temperature_maybe()
298        )
299
300    def test_get_surface_temperature_maybe_empty(self):
301        self._test_getter(
302            'surface_temperature_c',
303            None,
304            lambda x: x.get_surface_temperature_maybe()
305        )
306
307    def test_get_surface_temperature_maybe_convert(self):
308        self._test_getter_convert(
309            'surface_temperature_c',
310            1.23,
311            lambda x: x.get_surface_temperature_maybe('f'),
312            'c',
313            'f'
314        )
315
316    def test_get_depth(self):
317        return self._test_getter_convert(
318            'depth_m',
319            1.23,
320            lambda x: x.get_depth('m'),
321            'm',
322            'm'
323        )
324
325    def test_get_depth_convert(self):
326        return self._test_getter_convert(
327            'depth_m',
328            1.23,
329            lambda x: x.get_depth('km'),
330            'm',
331            'km'
332        )
333
334    def test_get_distance_fished(self):
335        return self._test_getter_convert(
336            'distance_fished_km',
337            1.23,
338            lambda x: x.get_distance_fished('km'),
339            'km',
340            'km'
341        )
342
343    def test_get_distance_fished_convert(self):
344        return self._test_getter_convert(
345            'distance_fished_km',
346            1.23,
347            lambda x: x.get_distance_fished('m'),
348            'km',
349            'm'
350        )
351
352    def test_get_net_width(self):
353        self._test_getter('net_width_m', 123, lambda x: x.get_net_width())
354
355    def test_get_net_width_convert(self):
356        self._test_getter_convert(
357            'net_width_m',
358            123,
359            lambda x: x.get_net_width('km'),
360            'm',
361            'km'
362        )
363
364    def test_get_net_height(self):
365        self._test_getter('net_height_m', 123, lambda x: x.get_net_height())
366
367    def test_get_net_height_convert(self):
368        self._test_getter_convert(
369            'net_height_m',
370            123,
371            lambda x: x.get_net_height('km'),
372            'm',
373            'km'
374        )
375
376    def test_get_net_width_maybe(self):
377        self._test_getter('net_width_m', 123, lambda x: x.get_net_width_maybe())
378
379    def test_get_net_width_maybe_empty(self):
380        self._test_getter('net_width_m', None, lambda x: x.get_net_width_maybe())
381
382    def test_get_net_width_maybe_empty_convert(self):
383        self._test_getter_convert(
384            'net_width_m',
385            123,
386            lambda x: x.get_net_width_maybe('km'),
387            'm',
388            'km'
389        )
390
391    def test_get_net_height_maybe(self):
392        self._test_getter('net_height_m', 123, lambda x: x.get_net_height_maybe())
393
394    def test_get_net_height_maybe_empty(self):
395        self._test_getter('net_height_m', None, lambda x: x.get_net_height_maybe())
396
397    def test_get_net_height_maybe_convert(self):
398        self._test_getter_convert(
399            'net_height_m',
400            123,
401            lambda x: x.get_net_height_maybe('km'),
402            'm',
403            'km'
404        )
405
406    def test_get_area_swept(self):
407        self._test_getter('area_swept_km2', 123, lambda x: x.get_area_swept('km2'))
408
409    def test_get_area_swept_convert(self):
410        self._test_getter_convert(
411            'area_swept_km2',
412            123,
413            lambda x: x.get_area_swept('ha'),
414            'km2',
415            'ha'
416        )
417
418    def test_get_duration(self):
419        self._test_getter('duration_hr', 1.23, lambda x: x.get_duration('hr'))
420
421    def test_get_duration_convert(self):
422        self._test_getter_convert(
423            'duration_hr',
424            1.23,
425            lambda x: x.get_duration('min'),
426            'hr',
427            'min'
428        )
429
430    def test_get_cpue_weight(self):
431        self._test_getter('cpue_kgkm2', 1.23, lambda x: x.get_cpue_weight('kg/km2'))
432
433    def test_get_cpue_weight_convert(self):
434        self._test_getter_convert(
435            'cpue_kgkm2',
436            1.23,
437            lambda x: x.get_cpue_weight('kg/ha'),
438            'kg/km2',
439            'kg/ha'
440        )
441
442    def test_get_cpue_count(self):
443        self._test_getter('cpue_nokm2', 1.23, lambda x: x.get_cpue_count('no/km2'))
444
445    def test_get_cpue_count_convert(self):
446        self._test_getter_convert(
447            'cpue_nokm2',
448            1.23,
449            lambda x: x.get_cpue_count('count/ha'),
450            'no/km2',
451            'count/ha'
452        )
453
454    def test_get_weight(self):
455        self._test_getter('weight_kg', 1.23, lambda x: x.get_weight('kg'))
456
457    def test_get_weight_convert(self):
458        self._test_getter_convert(
459            'weight_kg',
460            1.23,
461            lambda x: x.get_weight('g'),
462            'kg',
463            'g'
464        )
465
466    def test_get_count(self):
467        self._test_getter('count', 1123, lambda x: x.get_count())
468
469    def test_get_bottom_temperature(self):
470        self._test_getter('bottom_temperature_c', 1.23, lambda x: x.get_bottom_temperature('c'))
471
472    def test_get_bottom_temperature_convert(self):
473        self._test_getter_convert(
474            'bottom_temperature_c',
475            1.23,
476            lambda x: x.get_bottom_temperature('f'),
477            'c',
478            'f'
479        )
480
481    def test_get_surface_temperature(self):
482        self._test_getter('surface_temperature_c', 1.23, lambda x: x.get_surface_temperature('c'))
483
484    def test_get_surface_temperature_convert(self):
485        self._test_getter_convert(
486            'surface_temperature_c',
487            1.23,
488            lambda x: x.get_surface_temperature('f'),
489            'c',
490            'f'
491        )
492
493    def test_is_complete_true(self):
494        inner = {}
495
496        for field in afscgap.flat_model.RECORD_REQUIRED_FIELDS:
497            inner[field] = True
498
499        inner['complete'] = True
500
501        record = afscgap.flat_model.FlatRecord(inner)
502        self.assertTrue(record.is_complete())
503
504    def test_is_complete_false_computed(self):
505        inner = {}
506
507        for field in afscgap.flat_model.RECORD_REQUIRED_FIELDS:
508            inner[field] = True
509
510        inner['complete'] = True
511        inner['count'] = None
512
513        record = afscgap.flat_model.FlatRecord(inner)
514        self.assertFalse(record.is_complete())
515
516    def test_is_complete_false_explicit(self):
517        inner = {}
518
519        for field in afscgap.flat_model.RECORD_REQUIRED_FIELDS:
520            inner[field] = True
521
522        inner['complete'] = False
523
524        record = afscgap.flat_model.FlatRecord(inner)
525        self.assertFalse(record.is_complete())
526
527    def _test_getter(self, field, value, accessor):
528        self.assertTrue(field in EXPECTED_FIELDS)
529
530        inner = {field: value}
531        record = afscgap.flat_model.FlatRecord(inner)
532        returned = accessor(record)
533
534        if returned == value:
535            self.assertEqual(returned, value)
536        else:
537            self.assertAlmostEqual(returned, value)
538
539    def _test_getter_convert(self, field, value, accessor, source, destination):
540        self.assertTrue(field in EXPECTED_FIELDS)
541        inner = {field: value}
542        record = afscgap.flat_model.FlatRecord(inner)
543        expected = afscgap.convert.convert(value, source, destination)
544        self.assertAlmostEqual(accessor(record), expected)