oml-plot-tools 0.9.1__py3-none-any.whl

oml_plot_tools/tests/common.py

@@ -0,0 +1,126 @@
+# -*- coding:utf-8 -*-
+
+# This file is a part of IoT-LAB oml-plot-tools
+# Copyright (C) 2015 INRIA (Contact: admin@iot-lab.info)
+# Contributor(s) : see AUTHORS file
+#
+# This software is governed by the CeCILL license under French law
+# and abiding by the rules of distribution of free software.  You can  use,
+# modify and/ or redistribute the software under the terms of the CeCILL
+# license as circulated by CEA, CNRS and INRIA at the following URL
+# http://www.cecill.info.
+#
+# As a counterpart to the access to the source code and  rights to copy,
+# modify and redistribute granted by the license, users are provided only
+# with a limited warranty  and the software's author,  the holder of the
+# economic rights,  and the successive licensors  have only  limited
+# liability.
+#
+# The fact that you are presently reading this means that you have had
+# knowledge of the CeCILL license and that you accept its terms.
+
+
+"""Common tests functions."""
+
+import math
+import os
+import runpy
+import sys
+from io import StringIO
+from unittest import mock
+
+import matplotlib.pyplot as plt
+from PIL import Image
+
+TEST_DIR = os.path.dirname(__file__)
+IS_PYTHON_3_10 = (3, 10) == tuple(map(int, sys.version.split()[0].split(".")))[:2]
+
+
+def fixture_path(*args):
+    """Test file path."""
+    return os.path.join(TEST_DIR, *args)
+
+
+def help_main_and_doc(module, help_opt="--help"):
+    """Check that help message is module docstring.
+
+    Force COLUMNS to 80 as argparse wraps its usage line on the terminal
+    width, while the docstrings are written for the default 80 columns.
+    """
+    if not hasattr(module, "main"):
+        return None, None  # pragma: no cover
+
+    help_args = [module.__name__, help_opt]
+    out_msg = StringIO()
+
+    with mock.patch.dict(os.environ, {"COLUMNS": "80"}):
+        with mock.patch("sys.argv", help_args):
+            with mock.patch("sys.stderr", out_msg):
+                with mock.patch("sys.stdout", out_msg):
+                    try:
+                        runpy.run_module(
+                            module.__name__, run_name="__main__", alter_sys=True
+                        )
+                    except SystemExit:
+                        pass
+
+    help_msg = out_msg.getvalue().strip()
+    help_doc = module.__doc__.strip()
+    print(help_msg)
+    print(help_doc)
+
+    return help_msg, help_doc
+
+
+def utest_help_as_doc(testcase_instance, module, *args, **kwargs):
+    """Run help_as_doc as unittest test."""
+    help_msg, help_doc = help_main_and_doc(module, *args, **kwargs)
+    testcase_instance.assertEqual(help_msg, help_doc)
+
+
+def compare_images(ref_img, tmp_img):
+    """Compare two images using PIL.
+
+    :returns: root-mean-square of the two images
+    """
+    ref_h = Image.open(ref_img).histogram()
+    tmp_h = Image.open(tmp_img).histogram()
+    rms = math.sqrt(sum((a - b) ** 2 for a, b in zip(ref_h, tmp_h)) / len(ref_h))
+    return rms
+
+
+def utest_plot_and_compare(testcase, ref_img, threshold=0.0):
+    """Plot image and compare files.
+
+    Keep file if they differ.
+    'savefig' is not determinist between hosts so allow some differences with
+    threshold.
+    """
+    tmp_img = os.path.join("/tmp", os.path.basename(ref_img))
+
+    plt.tight_layout()
+    plt.savefig(tmp_img)
+
+    rms = compare_images(ref_img, tmp_img)
+
+    msg = f"{ref_img} != {tmp_img}: Root-mean-square == {rms:f} > {threshold:f}"
+    testcase.assertTrue(rms <= threshold, msg=msg)
+
+    os.remove(tmp_img)
+
+
+def assert_called_with_nparray(mock_function, np_array, *args, **kwargs):
+    """Assert mock function has been called with given np_array and arguments.
+
+    Using default mock assert_called_with failed.
+    Also using numpy comparison functions did not return expected value so use
+    'repr'
+    """
+    call_args, call_kwargs = mock_function.call_args
+
+    call_array = call_args[0]
+    call_args = call_args[1:]
+
+    assert repr(call_array) == repr(np_array)
+    assert repr(call_args) == repr(args)
+    assert call_kwargs == kwargs

oml_plot_tools/tests/common_test.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+
+# This file is a part of IoT-LAB oml-plot-tools
+# Copyright (C) 2015 INRIA (Contact: admin@iot-lab.info)
+# Contributor(s) : see AUTHORS file
+#
+# This software is governed by the CeCILL license under French law
+# and abiding by the rules of distribution of free software.  You can  use,
+# modify and/ or redistribute the software under the terms of the CeCILL
+# license as circulated by CEA, CNRS and INRIA at the following URL
+# http://www.cecill.info.
+#
+# As a counterpart to the access to the source code and  rights to copy,
+# modify and redistribute granted by the license, users are provided only
+# with a limited warranty  and the software's author,  the holder of the
+# economic rights,  and the successive licensors  have only  limited
+# liability.
+#
+# The fact that you are presently reading this means that you have had
+# knowledge of the CeCILL license and that you accept its terms.
+
+"""Tests for common.py."""
+
+import unittest
+from io import StringIO
+
+import numpy
+
+from oml_plot_tools import common, consum
+
+MEASURE_FMT = "{t} {type} {num} {t_s} {t_us} {measures}\n"
+HEADER = "HEADER\n" * common.OML_HEADER_LEN
+CONSO_T = common.OML_TYPES["consumption"]
+
+
+class TestCommon(unittest.TestCase):
+    """Tests for common OML loading utilities."""
+
+    def test_oml_load(self):
+        """Test loading valid OML data with two measurement entries."""
+        meas = "1. 2. 3."
+        content = HEADER
+        content += MEASURE_FMT.format(
+            t=0.1234, type=CONSO_T, num=1, t_s=12345, t_us=678900, measures=meas
+        )
+        content += MEASURE_FMT.format(
+            t=1.1234, type=CONSO_T, num=2, t_s=12346, t_us=678900, measures=meas
+        )
+
+        ret = common.oml_load(
+            StringIO(content), "consumption", consum.MEASURES_D.values()
+        )
+
+        expected = [
+            (12345.6789, "consumption", 1, 12345, 678900, 1.0, 2.0, 3.0),
+            (12346.6789, "consumption", 2, 12346, 678900, 1.0, 2.0, 3.0),
+        ]
+        self.assertEqual(expected, ret.tolist())
+        self.assertTrue(isinstance(ret, numpy.ndarray))
+
+    def test_oml_load_only_one(self):
+        """Test loading valid OML data with a single measurement entry."""
+        meas = "1. 2. 3."
+        content = HEADER
+        content += MEASURE_FMT.format(
+            t=0.1234, type=CONSO_T, num=1, t_s=12345, t_us=678900, measures=meas
+        )
+
+        ret = common.oml_load(
+            StringIO(content), "consumption", consum.MEASURES_D.values()
+        )
+
+        expected = [(12345.6789, "consumption", 1, 12345, 678900, 1.0, 2.0, 3.0)]
+        self.assertEqual(expected, ret.tolist())
+        self.assertTrue(isinstance(ret, numpy.ndarray))
+
+    def test_oml_invalid(self):
+        """Test that loading invalid or malformed OML data raises ValueError."""
+        # invalid data
+        content = HEADER + "invalid_content"
+        self.assertRaises(
+            ValueError,
+            common.oml_load,
+            StringIO(content),
+            "consumption",
+            consum.MEASURES_D.values(),
+        )
+
+        # Unknown file path
+        self.assertRaises(
+            ValueError,
+            common.oml_load,
+            "/invalid/file/path",
+            "consumption",
+            consum.MEASURES_D.values(),
+        )
+
+        # skip header fail
+        self.assertRaises(
+            ValueError,
+            common.oml_load,
+            StringIO("1 2 3"),
+            "consumption",
+            consum.MEASURES_D.values(),
+        )
+
+        # invalid oml 'type' file
+        meas = "1. 2. 3."
+        content = HEADER
+        content += MEASURE_FMT.format(
+            t=0.1234, type=(CONSO_T + 1), num=1, t_s=12345, t_us=678900, measures=meas
+        )
+        self.assertRaises(
+            ValueError,
+            common.oml_load,
+            StringIO(content),
+            "consumption",
+            consum.MEASURES_D.values(),
+        )
+
+    def test_array_empty(self):
+        """Test the array_empty utility function."""
+        self.assertTrue(common.array_empty(None))
+        self.assertTrue(common.array_empty([]))
+        self.assertFalse(common.array_empty([1, 2, 3]))
+
+    def test_measures_dict(self):
+        """Test the measures_dict utility function."""
+        d = common.measures_dict(("power", float, "Power (W)"))
+        self.assertIn("power", d)
+        self.assertEqual(d["power"].name, "power")
+        self.assertEqual(d["power"].type, float)
+        self.assertEqual(d["power"].label, "Power (W)")

oml_plot_tools/tests/consum_test.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+
+# This file is a part of IoT-LAB oml-plot-tools
+# Copyright (C) 2015 INRIA (Contact: admin@iot-lab.info)
+# Contributor(s) : see AUTHORS file
+#
+# This software is governed by the CeCILL license under French law
+# and abiding by the rules of distribution of free software.  You can  use,
+# modify and/ or redistribute the software under the terms of the CeCILL
+# license as circulated by CEA, CNRS and INRIA at the following URL
+# http://www.cecill.info.
+#
+# As a counterpart to the access to the source code and  rights to copy,
+# modify and redistribute granted by the license, users are provided only
+# with a limited warranty  and the software's author,  the holder of the
+# economic rights,  and the successive licensors  have only  limited
+# liability.
+#
+# The fact that you are presently reading this means that you have had
+# knowledge of the CeCILL license and that you accept its terms.
+
+"""Tests for consum.py."""
+
+import unittest
+from unittest import mock
+
+from .. import common, consum
+from .common import (
+    IS_PYTHON_3_10,
+    assert_called_with_nparray,
+    fixture_path,
+    utest_help_as_doc,
+    utest_plot_and_compare,
+)
+
+
+class TestConsumptionOmlPlot(unittest.TestCase):
+    """Tests for consumption OML plot functions."""
+
+    def setUp(self):
+        """Set up consumption OML data for plot tests."""
+        conso_file = fixture_path("examples", "consumption.oml")
+        self.data = consum.oml_load(conso_file)
+        self.title = "Node"
+
+    def test_plot_all(self):
+        """Test plotting all consumption measures."""
+        ref_img = fixture_path("examples", "consumption_all.png")
+        consum.oml_plot(self.data, self.title, consum.MEASURES_D.values())
+        utest_plot_and_compare(self, ref_img, 150)
+
+    def test_plot_current(self):
+        """Test plotting current consumption measure only."""
+        ref_img = fixture_path("examples", "consumption_current.png")
+        consum.oml_plot(self.data, self.title, [consum.MEASURES_D["current"]])
+        utest_plot_and_compare(self, ref_img, 100)
+
+    def test_plot_clock(self):
+        """Test plotting OML clock data for consumption."""
+        ref_img = fixture_path("examples", "consumption_clock.png")
+        consum.common.oml_plot_clock(self.data)
+        utest_plot_and_compare(self, ref_img, 50)
+
+
+class TestConsumptionPlot(unittest.TestCase):
+    """Tests for consumption main CLI entry point."""
+
+    def setUp(self):
+        """Set up mocks and test arguments for consumption main tests."""
+        meas_file = fixture_path("examples", "consumption.oml")
+        self.data = consum.oml_load(meas_file)[0:1]
+
+        self.title = "TITLE_TESTS"
+        self.args = [
+            "plot_oml_consum",
+            "-i",
+            meas_file,
+            "--begin",
+            "0",
+            "--end",
+            "1",
+            "-l",
+            self.title,
+        ]
+
+        self.oml_plot = mock.patch("oml_plot_tools.consum.oml_plot").start()
+        self.oml_plot_clock = mock.patch(
+            "oml_plot_tools.consum.common.oml_plot_clock"
+        ).start()
+
+    def tearDown(self):
+        """Stop all active patches after each test."""
+        mock.patch.stopall()
+
+    def consum_main(self, *args):
+        """Call consumption main with given additional args."""
+        with mock.patch("sys.argv", list(self.args) + list(args)):
+            consum.main()
+
+    def test_plot_selection(self):
+        """Test individual measure selection options -p, -v, -c."""
+        self.consum_main("-p")
+        assert_called_with_nparray(
+            self.oml_plot,
+            self.data,
+            self.title,
+            [common.MeasureTuple("power", float, "Power (W)")],
+        )
+
+        self.consum_main("-v")
+        assert_called_with_nparray(
+            self.oml_plot,
+            self.data,
+            self.title,
+            [common.MeasureTuple("voltage", float, "Voltage (V)")],
+        )
+
+        self.consum_main("-c")
+        assert_called_with_nparray(
+            self.oml_plot,
+            self.data,
+            self.title,
+            [common.MeasureTuple("current", float, "Current (A)")],
+        )
+
+        self.oml_plot.reset_mock()
+        self.consum_main("-c", "-v", "-p", "-p")
+        self.assertEqual(self.oml_plot.call_count, 3)
+
+    def test_plot_all(self):
+        """Test -a option calls oml_plot with all measures."""
+        self.consum_main("-a")
+        assert_called_with_nparray(
+            self.oml_plot, self.data, self.title, consum.MEASURES_D.values()
+        )
+
+    def test_plot_default_all(self):
+        """Test that no measure option defaults to plotting all measures."""
+        self.consum_main()
+        assert_called_with_nparray(
+            self.oml_plot, self.data, self.title, consum.MEASURES_D.values()
+        )
+
+    def test_plot_time(self):
+        """Test -t option calls oml_plot_clock with consumption data."""
+        self.consum_main("-t")
+        assert_called_with_nparray(self.oml_plot_clock, self.data)
+
+
+class TestConsumptionPlotDirect(unittest.TestCase):
+    """Tests for direct calls to consumption OML loading and plotting."""
+
+    def setUp(self):
+        """Set up test OML data for direct loading and plotting tests."""
+        meas_file = fixture_path("examples", "consumption.oml")
+        self.data = consum.oml_load(meas_file)
+        self.title = "Node"
+
+    def test_consumption_plot_all(self):
+        """Test direct call to consumption_plot with all measures."""
+        with mock.patch("oml_plot_tools.consum.oml_plot") as mock_plot:
+            with mock.patch("oml_plot_tools.consum.common.plot_show"):
+                consum.consumption_plot(self.data, self.title, ["all"])
+                self.assertTrue(mock_plot.called)
+
+    def test_consumption_plot_power(self):
+        """Test direct call to consumption_plot with power measure."""
+        with mock.patch("oml_plot_tools.consum.oml_plot") as mock_plot:
+            with mock.patch("oml_plot_tools.consum.common.plot_show"):
+                consum.consumption_plot(self.data, self.title, ["power"])
+                self.assertTrue(mock_plot.called)
+
+    def test_consumption_plot_voltage(self):
+        """Test direct call to consumption_plot with voltage measure."""
+        with mock.patch("oml_plot_tools.consum.oml_plot") as mock_plot:
+            with mock.patch("oml_plot_tools.consum.common.plot_show"):
+                consum.consumption_plot(self.data, self.title, ["voltage"])
+                self.assertTrue(mock_plot.called)
+
+    def test_consumption_plot_current(self):
+        """Test direct call to consumption_plot with current measure."""
+        with mock.patch("oml_plot_tools.consum.oml_plot") as mock_plot:
+            with mock.patch("oml_plot_tools.consum.common.plot_show"):
+                consum.consumption_plot(self.data, self.title, ["current"])
+                self.assertTrue(mock_plot.called)
+
+    def test_consumption_plot_time(self):
+        """Test direct call to consumption_plot with time measure."""
+        with mock.patch("oml_plot_tools.consum.common.oml_plot_clock") as mock_clock:
+            with mock.patch("oml_plot_tools.consum.common.plot_show"):
+                consum.consumption_plot(self.data, self.title, ["time"])
+                self.assertTrue(mock_clock.called)
+
+
+class TestDoc(unittest.TestCase):
+    """Tests that module help matches its docstring."""
+
+    @unittest.skipIf(IS_PYTHON_3_10, "Python 3.10 not supported")
+    def test_doc(self):
+        """Test that the module help output matches its docstring."""
+        utest_help_as_doc(self, consum)