itproject-code/test/test_adjusters.py

"""test_adjusters.py -- test pipeline Adjusters (eg TargetTimeAdjuster)"""
import unittest
import unittest.mock as mock
import pipeline.adjusters as adjusters

class TestAdjuster(unittest.TestCase):
    """Test the generic Adjuster class"""

    def test_init(self):
        """Test the Adjuster can be initialised"""
        adjuster = adjusters.Adjuster()
        self.assertEqual(adjuster.features, [])

    def test_adjust(self):
        """Test the generic adjust"""
        adjuster = adjusters.Adjuster()
        self.assertEqual(adjuster.adjust(), [])
        self.assertEqual(adjuster.features, [])

class TestTargetTimeAdjuster(unittest.TestCase):
    """Test the TargetTimeAdjuster

    TTA drops Features until the target time is reached (or within a margin)"""

    def test_init(self):
        """Test the TTA can be initialised"""
        tta = adjusters.TargetTimeAdjuster()
        self.assertEqual(tta.features, [])

    def test_features_total_time(self):
        """Test the TTA can calculate the total time of Features

        Test:
         - input duration floats: 1.0, 2.0, 3.0, 4.0 == 10.0
        """
        tta = adjusters.TargetTimeAdjuster()
        features = []
        for i in range(1, 5):
            features.append(mock.Mock(duration=i*1.0))

        self.assertEqual(tta._features_total_time(features), 10.0)
        self.assertEqual(tta._features_total_time([]), 0.0)
        self.assertIs(type(tta._features_total_time([])), float)

    def test_determine_margin(self):
        """Test the TTA can determine the target time margins

        Args: time, margin, strategy (strategy in: ABSOLUTE, PERCENT)

        Test:
         - margin of zero
         - margin of 5.0
         - margin of 10.0
         - margin of 100.0
         - both ABSOLUTE and PERCENT strategies

        TODO: figure out what should be done with negative margins & margins > 100.0
        """

        tta = adjusters.TargetTimeAdjuster()
        with self.subTest("ABSOLUTE"):
            strategy = adjusters.TargetTimeAdjuster._STRATEGY.ABSOLUTE
            test_cases = []
            # populate test cases with tuples of (time, margin, expected)
            # zero margin
            test_cases.append((60.0, 0.0, (60.0, 60.0)))
            # margin of 5.0
            test_cases.append((60.0, 5.0, (55.0, 65.0)))
            # margin of 10.0
            test_cases.append((60.0, 10.0, (50.0, 70.0)))
            # margin of 100.0
            test_cases.append((60.0, 100.0, (0.0, 160.0)))

            # test
            for time, margin, expected in test_cases:
                self.assertEqual(tta._determine_margin(time, margin, strategy), expected)