path: root/test/test_common.py

# -*- coding: utf-8 -*-
#
# SPDX-License-Identifier: MIT
"""Tests for the common routines."""

# pylint: disable=protected-access,missing-docstring

import datetime

from absl.testing import parameterized
from glucometerutils import common


class TestGlucoseConversion(parameterized.TestCase):
    def test_convert_to_mmol(self):
        self.assertEqual(
            5.56,
            common.convert_glucose_unit(100, common.Unit.MG_DL, common.Unit.MMOL_L),
        )

    def test_convert_to_mgdl(self):
        self.assertEqual(
            180, common.convert_glucose_unit(10, common.Unit.MMOL_L, common.Unit.MG_DL)
        )

    @parameterized.parameters(list(common.Unit))
    def test_convert_identity(self, unit):
        self.assertEqual(100, common.convert_glucose_unit(100, unit, unit))

    @parameterized.parameters([unit.value for unit in common.Unit])
    def test_convert_identity_str(self, unit_str):
        self.assertEqual(100, common.convert_glucose_unit(100, unit_str, unit_str))

    @parameterized.parameters(
        (common.Unit.MMOL_L, "foo"),
        ("foo", common.Unit.MG_DL),
        (None, common.Unit.MG_DL),
        (common.Meal.NONE, common.Unit.MG_DL),
    )
    def test_invalid_values(self, from_unit, to_unit):
        with self.assertRaises(Exception):
            common.convert_glucose_unit(100, from_unit, to_unit)


class TestGlucoseReading(parameterized.TestCase):

    TEST_DATETIME = datetime.datetime(2018, 1, 1, 0, 30, 45)

    def test_minimal(self):
        reading = common.GlucoseReading(self.TEST_DATETIME, 100)
        self.assertEqual(
            reading.as_csv(common.Unit.MG_DL),
            '"2018-01-01 00:30:45","100.00","","blood sample",""',
        )

    @parameterized.named_parameters(
        ("_mgdl", common.Unit.MG_DL, 100), ("_mmoll", common.Unit.MMOL_L, 5.56)
    )
    def test_value(self, unit, expected_value):
        reading = common.GlucoseReading(self.TEST_DATETIME, 100)
        self.assertAlmostEqual(reading.get_value_as(unit), expected_value, places=2)

    @parameterized.named_parameters(
        (
            "_meal_none",
            {"meal": common.Meal.NONE},
            '"2018-01-01 00:30:45","100.00","","blood sample",""',
        ),
        (
            "_meal_before",
            {"meal": common.Meal.BEFORE},
            '"2018-01-01 00:30:45","100.00","Before Meal","blood sample",""',
        ),
        (
            "_meal_after",
            {"meal": common.Meal.AFTER},
            '"2018-01-01 00:30:45","100.00","After Meal","blood sample",""',
        ),
        (
            "_measurement_blood",
            {"measure_method": common.MeasurementMethod.BLOOD_SAMPLE},
            '"2018-01-01 00:30:45","100.00","","blood sample",""',
        ),
        (
            "_measurement_cgm",
            {"measure_method": common.MeasurementMethod.CGM},
            '"2018-01-01 00:30:45","100.00","","CGM",""',
        ),
        (
            "_comment",
            {"comment": "too much"},
            '"2018-01-01 00:30:45","100.00","","blood sample","too much"',
        ),
        (
            "_comment_quoted",
            {"comment": '"too" much'},
            '"2018-01-01 00:30:45","100.00","","blood sample",""too" much"',
        ),
    )
    def test_csv(self, kwargs_dict, expected_csv):
        reading = common.GlucoseReading(self.TEST_DATETIME, 100, **kwargs_dict)
        self.assertEqual(reading.as_csv(common.Unit.MG_DL), expected_csv)


class TestMeterInfo(parameterized.TestCase):
    @parameterized.named_parameters(
        ("_no_serial_number", {}, "Serial Number: N/A\n"),
        ("_serial_number", {"serial_number": 1234}, "Serial Number: 1234\n"),
        ("_no_version_information", {}, "Version Information:\n    N/A\n"),
        (
            "_version_information_1",
            {"version_info": ["test"]},
            "Version Information:\n    test\n",
        ),
        (
            "_version_information_2",
            {"version_info": ["test", "test2"]},
            "Version Information:\n    test\n    test2\n",
        ),
        ("_default_native_unit", {}, "Native Unit: mg/dL\n"),
    )
    def test_meter_info(self, kwargs_dict, expected_fragment):
        info = common.MeterInfo(self.id(), **kwargs_dict)
        self.assertIn(expected_fragment, str(info))