Updated measurement/series related tests.

Author: chisou

c8y_api/model/measurements.py

@@ -716,19 +716,11 @@ def get_series(
 
         See also: https://cumulocity.com/api/core/#operation/getMeasurementSeriesResource
         """
-        # The 'series' parameter has to be added through a hack; it
-        # may be a list and because 'series' is by default converted to
-        # the 'valueFragmentSeries' parameter
-
-        # if series:
-        #     series = series if isinstance(series, str) else ','.join(series)
-
         base_query = self._prepare_query(
             resource=f'{self.resource}/series',
             expression=expression,
             source=source,
-            # this is a non-mapped parameter
-            aggregationType=aggregation,
+            aggregationType=aggregation,  # this is a non-mapped parameter
             series=series,
             before=before,
             after=after,
@@ -738,14 +730,81 @@ def get_series(
             **kwargs)
         return Series(self.c8y.get(base_query))
 
+    def collect_series(
+            self,
+            expression: str = None,
+            source: str = None,
+            aggregation: str = None,
+            series: str | Sequence[str] = None,
+            before: str | datetime = None,
+            after: str | datetime = None,
+            min_age: timedelta = None,
+            max_age: timedelta = None,
+            reverse: bool = None,
+            value: str = None,
+            timestamps: bool|str = None,
+            **kwargs
+    ):
+        """Query the database for series values.
+
+        This function is functionally the same as using the `get_series` function
+        with an immediate `collect` on the result.
+
+        Args:
+            expression (str):  Arbitrary filter expression which will be
+                passed to Cumulocity without change; all other filters
+                are ignored if this is provided
+            source (str):  Database ID of a source device
+            aggregation (str):  Aggregation type
+            series (str|Sequence[str]):  Series' to query and collect; If
+                multiple series are collected each element in the result will
+                be a tuple. If omitted, all available series are collected.
+            before (datetime|str):  Datetime object or ISO date/time string.
+                Only measurements assigned to a time before this date are
+                included.
+            after (datetime|str):  Datetime object or ISO date/time string.
+                Only measurements assigned to a time after this date are
+                included.
+            min_age (timedelta):  Timedelta object. Only measurements of
+                at least this age are included.
+            max_age (timedelta):  Timedelta object. Only measurements with
+                at most this age are included.
+            reverse (bool):  Invert the order of results, starting with the
+                most recent one.
+            value (str):  Which value (min/max) to collect. If omitted, both
+                values will be collected, grouped as 2-tuples.
+            timestamps (bool|str):  Whether each element in the result list will
+                be prepended with the corresponding timestamp. If True, the
+                timestamp string will be included; Use 'datetime' or 'epoch' to
+                parse the timestamp string.
+
+        Returns:
+            A simple list or list of tuples (potentially nested) depending on the
+            parameter combination.
+
+        See also: https://cumulocity.com/api/core/#operation/getMeasurementSeriesResource
+        """
+        result = self.get_series(
+            expression=expression,
+            source=source,
+            aggregation=aggregation,
+            series=series,
+            before=before,
+            after=after,
+            min_age=min_age,
+            max_age=max_age,
+            reverse=reverse,
+            **kwargs)
+        return result.collect(
+            series=series,
+            value=value,
+            timestamps=timestamps)
+
     def delete_by(
             self,
             expression: str = None,
             type: str = None,
             source: str | int = None,
-            # value_fragment_type: str = None,
-            # value_fragment_series: str = None,
-            # series: str = None,
             date_from: str | datetime = None,
             date_to: str | datetime = None,
             before: str | datetime = None,
@@ -785,9 +844,6 @@ def delete_by(
             expression=expression,
             type=type,
             source=source,
-            # value_fragment_type=value_fragment_type,
-            # value_fragment_series=value_fragment_series,
-            # series=series,
             date_from=date_from,
             date_to=date_to,
             before=before,

integration_tests/test_measurements.py

@@ -216,8 +216,6 @@ def unaggregated_series_result(live_c8y: CumulocityApi, sample_series_device: De
 def aggregated_series_result(live_c8y: CumulocityApi, sample_series_device: Device) -> Series:
     """Provide an aggregated series result."""
     start_time = datetime.fromisoformat('2020-01-01 00:00:00+00:00')
-    print(f"Type: {type(sample_series_device.c8y_SupportedSeries)}")
-    print(f"Values: {sample_series_device.c8y_SupportedSeries}")
     return live_c8y.measurements.get_series(source=sample_series_device.id,
                                             series=sample_series_device.c8y_SupportedSeries,
                                             aggregation=Measurements.AggregationType.HOURLY,
@@ -263,3 +261,37 @@ def test_collect_multiple_series(series_fixture, request):
     for i in range(0, len(series_names)):
         t = type(values[0][i])
         assert all(isinstance(v[i], t) for v in values if v[i])
+
+
+def test_get_and_collect_series(live_c8y, sample_series_device):
+    """Verify that get & collect works as expected."""
+    series = live_c8y.measurements.get_series(
+        source=sample_series_device.id,
+        series=sample_series_device.c8y_SupportedSeries,
+        aggregation=Measurements.AggregationType.HOURLY,
+        after='1970-01-01',
+        before='now'
+    )
+
+    # multiple series
+    collected = series.collect(sample_series_device.c8y_SupportedSeries)
+    directly_collected = live_c8y.measurements.collect_series(
+        source=sample_series_device.id,
+        series=sample_series_device.c8y_SupportedSeries,
+        aggregation=Measurements.AggregationType.HOURLY,
+        after='1970-01-01',
+        before='now'
+    )
+    assert collected == directly_collected
+
+    # single series
+    for series_name in sample_series_device.c8y_SupportedSeries:
+        collected = series.collect(series_name)
+        directly_collected = live_c8y.measurements.collect_series(
+            source=sample_series_device.id,
+            series=series_name,
+            aggregation=Measurements.AggregationType.HOURLY,
+            after='1970-01-01',
+            before='now'
+        )
+        assert collected == directly_collected

tests/model/test_base.py

@@ -344,6 +344,8 @@ def test_complex_object_updating(fun):
 
 
 def test_inheritance():
+    """Verify that the base classes inheritance and typing is as expected."""
+    # pylint: disable=unidiomatic-typecheck
     mo = ManagedObject.from_json({
         'id': 'ID',
         'name': 'NAME',

tests/model/test_measurements.py

@@ -127,32 +127,6 @@ def test_select_invalid_combinations(fun, args, errors):
         isolate_call_url(fun, **params)
     assert all(e in str(error) for e in errors)
 
-
-def generate_series_data() -> tuple:
-    """Generate all kinds of combinations of series fragments."""
-
-    def gen_level2(n):
-        level2_single = ({n: {'1': {'value': 1}}}, [f'{n}.1'])
-        level2_multi = ({n: {'1': {'value': 1}, '2': {'value': 2}}}, [f'{n}.1', f'{n}.2'])
-        level2_invalid = ({n: {'1': {'data': 1}}}, [])
-        level2_mix1 = ({n: {'1': {'data': 1}, '2': {'value': 2}}}, [f'{n}.2'])
-        level2_mix2 = ({n: {'1': {'value': 1}, '2': {'data': 2}}}, [f'{n}.1'])
-
-        return [level2_single, level2_multi, level2_invalid, level2_mix1, level2_mix2]
-
-    a = gen_level2('A')
-    b = gen_level2('B')
-    # collecting combinations of A and B cases
-    # (first element is the json, 2nd the expectation for each combination)
-    ab = [({**r[0][0], **r[1][0]}, r[0][1] + r[1][1]) for r in itertools.product(a, b)]
-
-    cases = a + ab
-    # id is the beautified expectation, prefixed with a number
-    ids = [f'{i}: ' + ','.join(map(lambda x: x.replace('.', ''), x[1])) for i, x in enumerate(cases)]
-
-    return cases, ids
-
-
 @pytest.mark.parametrize('params, expected, not_expected', [
     ({'expression': 'X&Y'}, ['X&Y'], ['expression']),
     ({'source': 'SOURCE'}, ['source=SOURCE'], []),
@@ -172,13 +146,59 @@ def test_get_series_parameters(params, expected, not_expected):
         assert e not in resource
 
 
-@pytest.mark.skip("TODO: test purpose unclear")
+def generate_series_data() -> tuple:
+    """Generate all kinds of combinations of series fragments.
+
+    Returns a tuple of testcases and corresponding testcase ID. Each testcase
+    element is again a tuple of a JSON structure (the test data) and a list
+    of expected series' names (for assertion).
+
+    We will define 2 sets (A and B) of such test cases (with different fragment
+    names), each featuring possible JSON combinations of single and multiple
+    series as well as invalid structures (not following the syntax for series).
+
+    Finally, we will create test cases from all possible combinations of the two
+    basic sets.
+
+    The tests' ID are generated from the expectation set.
+    """
+
+    def generate(fragment):
+        level2_single = ({fragment: {'series1': {'value': 1}}},
+                         [f'{fragment}.series1'])
+        level2_multi = ({fragment: {'series1': {'value': 1}, 'series2': {'value': 2}}},
+                        [f'{fragment}.series1', f'{fragment}.series2'])
+        level2_invalid = ({fragment: {'series1': {'data': 1}}},
+                          [])
+        level2_mix1 = ({fragment: {'series1': {'data': 1}, 'series2': {'value': 2}}},
+                       [f'{fragment}.series2'])
+        level2_mix2 = ({fragment: {'series1': {'value': 1}, 'series2': {'data': 2}}},
+                       [f'{fragment}.series1'])
+        return [level2_single, level2_multi, level2_invalid, level2_mix1, level2_mix2]
+
+    # generating A and B sets
+    a = generate('fragmentA')
+    b = generate('fragmentB')
+
+    # collecting combinations of A and B cases
+    ab = [({**r[0][0], **r[1][0]}, r[0][1] + r[1][1]) for r in itertools.product(a, b)]
+
+    cases = a + ab
+    # id is the beautified expectation, prefixed with a number
+    ids = [f'{i}: ' + ','.join(map(lambda x: x.replace('.', '/'), x[1])) for i, x in enumerate(cases)]
+
+    return cases, ids
+
+
 @pytest.mark.parametrize('testcase', generate_series_data()[0], ids=generate_series_data()[1])
 def test_get_series(testcase):
-    """Verify that the get_series function works as expected."""
+    """Verify that the get_series function works as expected.
+
+    The `get_series` function on a measurement determines and returns the
+    names of series defined within a single measurement.
+    """
     data = {**testcase[0], 'source': {'id': '1'}}
     m = Measurement.from_json(data)
-    # expected = [*xs for xs in testcase[1]]
     assert testcase[1] == m.get_series()