afscgap.test.test_entry

  1"""
  2Tests for library entry point vai the query function.
  3
  4(c) 2023 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 csv
 11import unittest
 12import unittest.mock
 13
 14import afscgap.test.test_tools
 15
 16# pylint: disable=C0115, C0116
 17
 18
 19class EntryPointNoInferenceTests(unittest.TestCase):
 20
 21    def setUp(self):
 22        self._result_1 = afscgap.test.test_tools.make_result_json(
 23            'result_1.json'
 24        )
 25        self._result_2 = afscgap.test.test_tools.make_result_json(
 26            'result_2.json'
 27        )
 28        self._mock_requestor = unittest.mock.MagicMock(
 29            side_effect=[self._result_1, self._result_2]
 30        )
 31
 32    def test_query_primitive(self):
 33        query = afscgap.Query(requestor=self._mock_requestor)
 34        query.filter_year(eq=2021)
 35        query.filter_srvy(eq='BSS')
 36        results = list(query.execute())
 37        self.assertEquals(len(results), 20)
 38
 39    def test_query_dict(self):
 40        query = afscgap.Query(requestor=self._mock_requestor)
 41        query.filter_year(eq=2021)
 42        query.filter_latitude(eq={'$gte': 56.99, '$lte': 57.04})
 43        query.filter_longitude(eq={'$gte': -143.96, '$lte': -144.01})
 44        results = list(query.execute())
 45        self.assertEquals(len(results), 20)
 46
 47    def test_query_keywords(self):
 48        query = afscgap.Query(requestor=self._mock_requestor)
 49        query.filter_year(eq=2021)
 50        query.filter_latitude(min_val=56.99, max_val=57.04)
 51        query.filter_longitude(min_val=-143.96, max_val=-144.01)
 52        results = list(query.execute())
 53        self.assertEquals(len(results), 20)
 54
 55    def test_query_dict_filter_incomplete(self):
 56        query = afscgap.Query(requestor=self._mock_requestor)
 57        query.filter_year(eq=2021)
 58        query.filter_latitude(eq={'$gte': 56.99, '$lte': 57.04})
 59        query.filter_longitude(eq={'$gte': -143.96, '$lte': -144.01})
 60        query.set_filter_incomplete(True)
 61        results = list(query.execute())
 62        self.assertEquals(len(results), 19)
 63
 64    def test_query_dict_invalid_filter_incomplete(self):
 65        query = afscgap.Query(requestor=self._mock_requestor)
 66        query.filter_year(eq=2021)
 67        query.filter_latitude(eq={'$gte': 56.99, '$lte': 57.04})
 68        query.filter_longitude(eq={'$gte': -143.96, '$lte': -144.01})
 69        query.set_filter_incomplete(True)
 70        result = query.execute()
 71        list(result)
 72        self.assertEquals(result.get_invalid().qsize(), 2)
 73
 74    def test_query_dict_invalid_keep_incomplete(self):
 75        query = afscgap.Query(requestor=self._mock_requestor)
 76        query.filter_year(eq=2021)
 77        query.filter_latitude(eq={'$gte': 56.99, '$lte': 57.04})
 78        query.filter_longitude(eq={'$gte': -143.96, '$lte': -144.01})
 79        query.set_filter_incomplete(False)
 80        result = query.execute()
 81        list(result)
 82        self.assertEquals(result.get_invalid().qsize(), 1)
 83
 84    def test_create_param_eq(self):
 85        query = afscgap.Query(requestor=self._mock_requestor)
 86        self.assertEqual(query._create_param(2021), 2021)
 87
 88    def test_create_param_lt(self):
 89        query = afscgap.Query(requestor=self._mock_requestor)
 90        self.assertEqual(query._create_param(min_val=2021), [2021, None])
 91
 92    def test_create_param_gt(self):
 93        query = afscgap.Query(requestor=self._mock_requestor)
 94        self.assertEqual(query._create_param(max_val=2021), [None, 2021])
 95
 96    def test_create_param_between(self):
 97        query = afscgap.Query(requestor=self._mock_requestor)
 98        self.assertEqual(
 99            query._create_param(min_val=2020, max_val=2021),
100            [2020, 2021]
101        )
102
103
104class EntryPointInferenceTests(unittest.TestCase):
105
106    def setUp(self):
107        self._api_result = afscgap.test.test_tools.make_result_json(
108            'limited.json'
109        )
110        self._hauls_result = afscgap.test.test_tools.make_result_text(
111            'hauls.csv'
112        )
113        self._mock_requestor = unittest.mock.MagicMock(
114            side_effect=[self._hauls_result, self._api_result]
115        )
116
117    def test_query_keep_presence_only(self):
118        mock_requestor = unittest.mock.MagicMock(
119            side_effect=[self._api_result]
120        )
121
122        query = afscgap.Query(requestor=mock_requestor)
123        query.filter_year(eq=2021)
124        query.set_presence_only(True)
125        result = query.execute()
126
127        results = list(result)
128        self.assertEquals(len(results), 2)
129
130    def test_query_primitive(self):
131        warn_function = unittest.mock.MagicMock()
132
133        query = afscgap.Query(requestor=self._mock_requestor)
134        query.filter_year(eq=2021)
135        query.set_presence_only(False)
136        query.set_warn_function(warn_function)
137        result = query.execute()
138
139        results = list(result)
140        self.assertEquals(len(results), 4)
141
142    def test_query_primitive_warning(self):
143        warn_function = unittest.mock.MagicMock()
144
145        query = afscgap.Query(requestor=self._mock_requestor)
146        query.filter_year(eq=2021)
147        query.set_presence_only(False)
148        query.set_warn_function(warn_function)
149        result = query.execute()
150
151        warn_function.assert_called()
152
153    def test_query_primitive_suppress(self):
154        warn_function = unittest.mock.MagicMock()
155        
156        query = afscgap.Query(requestor=self._mock_requestor)
157        query.filter_year(eq=2021)
158        query.set_presence_only(False)
159        query.set_warn_function(warn_function)
160        query.set_suppress_large_warning(True)
161        result = query.execute()
162
163        warn_function.assert_not_called()
164
165    def test_prefetch(self):
166        hauls_path = afscgap.test.test_tools.get_test_file_path('hauls.csv')
167        with open(hauls_path) as f:
168            rows = csv.DictReader(f)
169            hauls = [afscgap.inference.parse_haul(row) for row in rows]
170
171        warn_function = unittest.mock.MagicMock()
172
173        query = afscgap.Query(requestor=self._mock_requestor)
174        query.filter_year(eq=2021)
175        query.set_presence_only(False)
176        query.set_warn_function(warn_function)
177        query.set_suppress_large_warning(True)
178        query.set_hauls_prefetch(hauls)
179        result = query.execute()
180
181        self._mock_requestor.assert_not_called()