bertieb
/
itproject-code
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
128 Commits
1 Branch
127 KiB
 
Branch: main
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'main'
${ noResults }
itproject-code/test/test_utils.py

393 lines
16 KiB
Raw Permalink Blame History 

  1. """Test cases for utils"""

  2. import unittest

  3. 

  4. import pipeline.utils as utils

  5. 

  6. class MockSource():

  7.     """Mock Source object for testing Feature"""

  8.     def __init__(self, source):

  9.         self.source = source

  10. 

  11.     def __str__(self):

  12.         return self.source

  13. 

  14.     def to_json(self):

  15.         return {"source": self.source}

  16. 

  17.     def __eq__(self, other):

  18.         return self.source == other.source

  19. 

  20. class MockInterval():

  21.     """Mock Interval object for testing Feature"""

  22.     def __init__(self, start, end):

  23.         self.start = start

  24.         self.end = end

  25. 

  26.     def to_json(self):

  27.         return {"start": self.start, "end": self.end}

  28. 

  29. class TestSource(unittest.TestCase):

  30.     """Source is a container for source, path, and provider of a media file

  31. 

  32.     source -- the source of the media file (eg, a URL or a local path)

  33.     path -- the path to the media file

  34.     provider -- the provider of the media file (eg, "FileInputJSON")

  35. 

  36.     Accessing the object should return the path to the media file.

  37. 

  38.     Methods:

  39. 

  40.     duration() -- return the duration of the media file (uses ffprobe, result is cached)

  41.     """

  42.     # Happy path tests

  43.     def setUp(self):

  44.         self.source = "audio_clips/testclip-5min.aac"

  45.         self.path = "audio_clips/testclip-5min.aac"

  46.         self.provider = "FileInputJSON"

  47.         self._duration = 306.121214 # duration of testclip-5min.aac

  48. 

  49.     def test_init(self):

  50.         source = utils.Source(self.source, self.path, self.provider)

  51.         self.assertEqual(source.source, self.source)

  52.         self.assertEqual(source.path, self.path)

  53.         self.assertEqual(source.provider, self.provider)

  54. 

  55.     def test_str(self):

  56.         """Accessing the object should return the path to the media file"""

  57.         source = utils.Source(self.source, self.path, self.provider)

  58.         self.assertEqual(str(source), self.path)

  59. 

  60.     def test_repr(self):

  61.         source = utils.Source(self.source, self.path, self.provider)

  62.         self.assertEqual(repr(source), f"Source({self.source}, {self.path}, {self.provider})")

  63. 

  64.     def test_duration(self):

  65.         """Use a mock duration of 306.121214 for the test clip"""

  66.         source = utils.Source(self.source, self.path, self.provider)

  67.         self.assertEqual(source.duration(), self._duration)

  68. 

  69.     def test_to_json(self):

  70.         source = utils.Source(self.source, self.path, self.provider)

  71.         self.assertEqual(source.to_json(), {"source": self.source, "path": self.path, "provider": self.provider})

  72. 

  73.     # Sad path tests

  74.     def test_init_no_source(self):

  75.         with self.assertRaises(ValueError):

  76.             utils.Source("", self.path, self.provider)

  77. 

  78.     def test_init_no_path(self):

  79.         with self.assertRaises(ValueError):

  80.             utils.Source(self.source, "", self.provider)

  81. 

  82.     def test_init_no_provider(self):

  83.         with self.assertRaises(ValueError):

  84.             utils.Source(self.source, self.path, "")

  85. 

  86.     def test_duration_no_file(self):

  87.         """Test that duration raises FileNotFoundError if the file does not exist"""

  88.         source = utils.Source(self.source, "fakepath-noexist!😇", self.provider)

  89.         # if that file actually exists I'll eat my hat

  90.         with self.assertRaises(FileNotFoundError):

  91.             source.duration()

  92. 

  93. 

  94. class TestSourceMedia(unittest.TestCase):

  95.     """SourceMedia is a container for Source objects"""

  96.     class FakeSource():

  97.         """Fake source object for testing SourceMedia

  98. 

  99.          Since SourceMedia doesn't actually access any of the attributes of Source objects,

  100.          we can use a very empty class for testing.

  101.          """

  102. 

  103.     def setUp(self):

  104.         self.source1 = self.FakeSource()

  105.         self.source2 = self.FakeSource()

  106.         self.source3 = self.FakeSource()

  107.         self.sources = [self.source1, self.source2, self.source3]

  108. 

  109.     def test_init(self):

  110.         source_media = utils.SourceMedia(sources=self.sources)

  111.         self.assertEqual(source_media.sources, self.sources)

  112. 

  113.     def test_iter(self):

  114.         source_media = utils.SourceMedia(sources=self.sources)

  115.         self.assertEqual(list(source_media), self.sources)

  116. 

  117. 

  118. class TestInterval(unittest.TestCase):

  119.     """Interval is a container for start, end and duration attributes"""

  120.     def setUp(self):

  121.         self.start = 0

  122.         self.end = 10

  123.         self.duration = 10

  124. 

  125.     # Happy path tests

  126. 

  127.     def test_init_start_end(self):

  128.         """Create an Interval using start and end attributes"""

  129.         interval = utils.Interval(start=self.start, end=self.end)

  130.         self.assertEqual(interval.start, self.start)

  131.         self.assertEqual(interval.end, self.end)

  132.         self.assertEqual(interval.duration, self.duration)

  133. 

  134.     def test_init_start_duration(self):

  135.         """Create an Interval using start and duration attributes"""

  136.         interval = utils.Interval(start=self.start, duration=self.duration)

  137.         self.assertEqual(interval.start, self.start)

  138.         self.assertEqual(interval.end, self.end)

  139.         self.assertEqual(interval.duration, self.duration)

  140. 

  141.     def test_init_end_duration(self):

  142.         """Create an Interval using end and duration attributes"""

  143.         interval = utils.Interval(end=self.end, duration=self.duration)

  144.         self.assertEqual(interval.start, self.start)

  145.         self.assertEqual(interval.end, self.end)

  146.         self.assertEqual(interval.duration, self.duration)

  147. 

  148.     def test_from_start_classmethod(self):

  149.         """Create an Interval using the from_start classmethod (ie start attribute only- uses default duration)"""

  150.         interval = utils.Interval.from_start(start=self.start)

  151.         self.assertEqual(interval.start, self.start)

  152.         self.assertEqual(interval.end, interval.start + utils.Interval.DEFAULT_DURATION)

  153.         self.assertEqual(interval.duration, utils.Interval.DEFAULT_DURATION)

  154. 

  155.     def test_from_end_classmethod(self):

  156.         """Create an Interval using the from_end classmethod (ie end attribute only- uses default duration)"""

  157.         interval = utils.Interval.from_end(end=self.end)

  158.         self.assertEqual(interval.start, interval.end - utils.Interval.DEFAULT_DURATION)

  159.         self.assertEqual(interval.end, self.end)

  160.         self.assertEqual(interval.duration, utils.Interval.DEFAULT_DURATION)

  161. 

  162.     def test_repr(self):

  163.         interval = utils.Interval(start=self.start, end=self.end)

  164.         self.assertEqual(repr(interval), f"Interval({self.start}, {self.end}, {self.duration})")

  165. 

  166.     def test_lt(self):

  167.         """Test the __lt__ method used for sorting Interval objects based on start time

  168. 

  169.         If the start times are equal, the interval with the smaller end time is considered smaller

  170.         """

  171.         interval1 = utils.Interval(start=0, end=10)

  172.         interval2 = utils.Interval(start=0, end=15)

  173.         interval3 = utils.Interval(start=5, end=10)

  174.         interval4 = utils.Interval(start=5, end=15)

  175.         self.assertTrue(interval1 < interval2) # same start, interval1 has smaller end

  176.         self.assertTrue(interval1 < interval3) # interval1 start is smaller

  177.         self.assertTrue(interval3 > interval2) # interval3 start is larger

  178.         self.assertTrue(interval3 < interval4) # same start, interval3 has smaller end

  179. 

  180.     def test_eq(self):

  181.         """Test the __eq__ method for comparing Interval objects"""

  182.         interval1 = utils.Interval(start=0, end=10)

  183.         interval2 = utils.Interval(start=0, end=10)

  184.         interval3 = utils.Interval(start=0, end=15)

  185.         self.assertEqual(interval1, interval2)

  186.         self.assertNotEqual(interval1, interval3)

  187. 

  188.     def test_to_json(self):

  189.         """Test to_json method"""

  190.         interval = utils.Interval(start=self.start, end=self.end)

  191.         self.assertEqual(interval.to_json(), {"start": self.start, "end": self.end, "duration": self.duration})

  192. 

  193.     def test_move_start(self):

  194.         """Test the move_start method - changes start time to time specified, keeps end time constant"""

  195.         interval = utils.Interval(start=self.start, end=self.end)

  196.         interval.move_start(5)

  197.         self.assertEqual(interval.start, 5)

  198.         self.assertEqual(interval.end, 10)

  199.         self.assertEqual(interval.duration, 5)

  200. 

  201.     def test_move_start_relative(self):

  202.         """Test the move_start method with relative=True - changes start time by a relative amount"""

  203.         interval = utils.Interval(start=self.start, end=self.end)

  204.         interval.move_start(2, relative=True)

  205.         self.assertEqual(interval.start, 2)

  206.         self.assertEqual(interval.end, 10)

  207.         self.assertEqual(interval.duration, 8)

  208. 

  209.     def test_move_end(self):

  210.         """Test the move_end method - changes end time to time specified, keeps start time constant"""

  211.         with self.subTest("non-relative"):

  212.             interval = utils.Interval(start=self.start, end=self.end)

  213.             interval.move_end(15)

  214.             self.assertEqual(interval.start, 0)

  215.             self.assertEqual(interval.end, 15)

  216.             self.assertEqual(interval.duration, 15)

  217.         with self.subTest("relative"):

  218.             interval = utils.Interval(start=self.start, end=self.end)

  219.             interval.move_end(5, relative=True)

  220.             self.assertEqual(interval.start, 0)

  221.             self.assertEqual(interval.end, 15)

  222.             self.assertEqual(interval.duration, 15)

  223. 

  224.     def test_update_duration(self):

  225.         """Test the update_duration method - changes duration to time specified, keeps start time constant"""

  226.         interval = utils.Interval(start=self.start, end=self.end)

  227.         interval.update_duration(15)

  228.         self.assertEqual(interval.start, 0)

  229.         self.assertEqual(interval.end, 15)

  230.         self.assertEqual(interval.duration, 15)

  231.         # test with relative=True

  232.         interval.update_duration(5, relative=True)

  233.         self.assertEqual(interval.start, 0)

  234. 

  235.     def test_overlaps(self):

  236.         """Test the overlaps method - returns True if the interval overlaps with another interval"""

  237.         interval1 = utils.Interval(start=0, end=10)

  238.         interval2 = utils.Interval(start=5, end=15) # overlaps with interval1

  239.         interval3 = utils.Interval(start=15, end=20) # does not overlap with interval1

  240.         interval4 = utils.Interval(start=10, end=15) # touch overlap with interval1

  241.         # test with overlapping interval

  242.         self.assertTrue(interval1.overlaps(interval2))

  243.         self.assertTrue(interval2.overlaps(interval1))

  244.         # test with non-overlapping interval

  245.         self.assertFalse(interval1.overlaps(interval3))

  246.         self.assertFalse(interval3.overlaps(interval1))

  247.         # test with touching interval

  248.         self.assertTrue(interval1.overlaps(interval4))

  249.         self.assertTrue(interval4.overlaps(interval1))

  250. 

  251.     # Unhappy path tests

  252. 

  253.     def test_init_no_start_end(self):

  254.         with self.assertRaises(ValueError):

  255.             utils.Interval()

  256. 

  257.     def test_init_start_end_duration(self):

  258.         with self.assertRaises(ValueError):

  259.             utils.Interval(start=self.start, end=self.end, duration=self.duration)

  260. 

  261.     def test_init_start_after_end(self):

  262.         with self.assertRaises(ValueError):

  263.             utils.Interval(start=10, end=0)

  264. 

  265.     def test_init_negative_duration(self):

  266.         with self.assertRaises(ValueError):

  267.             utils.Interval(start=0, duration=-10)

  268.         with self.assertRaises(ValueError):

  269.             utils.Interval(end=0, duration=-10)

  270. 

  271. class TestFeature(unittest.TestCase):

  272.     """Test the Feature class"""

  273. 

  274.     # happy path tests

  275. 

  276.     def test_init(self):

  277.         """Test creation of a Feature object.

  278. 

  279.         Needs: interval, source, feature_extractor and score"""

  280.         source = MockSource("source")

  281.         interval = MockInterval(0, 10)

  282.         feature_extractor = "feature_extractor"

  283.         score = 0.5

  284.         feature = utils.Feature(interval, source, feature_extractor, score)

  285.         # NOTE: LSP complains about assign MockSource to source, but it's fine

  286.         self.assertEqual(feature.interval, interval)

  287.         self.assertEqual(feature.source, source)

  288.         self.assertEqual(feature.feature_extractor, feature_extractor)

  289.         self.assertEqual(feature.score, score)

  290. 

  291.     def test_repr(self):

  292.         source = MockSource("source")

  293.         interval = MockInterval(0, 10)

  294.         feature_extractor = "test"

  295.         score = 0.5

  296.         feature = utils.Feature(interval, source, feature_extractor, score)

  297.         self.assertEqual(repr(feature), f"Feature({interval}, {source}, {feature_extractor}, {score})")

  298. 

  299.     def test_to_json(self):

  300.         """test Feature.to_json method"""

  301.         source = MockSource("source")

  302.         interval = MockInterval(0, 10)

  303.         feature_extractor = "test"

  304.         score = 0.5

  305.         feature = utils.Feature(interval, source, feature_extractor, score)

  306.         self.assertEqual(feature.to_json(), {"interval": interval.to_json(), "source": source.to_json(),

  307.                                              "feature_extractor": feature_extractor, "score": score})

  308. 

  309.     def test_classmethod_from_start(self):

  310.         """Test the @classmethod for creating Feature with Interval.from_start"""

  311.         source = MockSource("source")

  312.         feature_extractor = "test"

  313.         score = 0.5

  314.         feature = utils.Feature.from_start(start=0, source=source, feature_extractor=feature_extractor, score=score)

  315.         self.assertEqual(feature.interval.start, 0)

  316.         self.assertEqual(feature.interval.end, 5)

  317.         self.assertEqual(feature.interval.duration, 5)

  318.         self.assertEqual(feature.source, source)

  319.         self.assertEqual(feature.feature_extractor, feature_extractor)

  320.         self.assertEqual(feature.score, score)

  321. 

  322.     def test_classmethod_from_end(self):

  323.         """Test the @classmethod for creating Feature with Interval.from_end"""

  324.         source = MockSource("source")

  325.         feature_extractor = "test"

  326.         score = 0.5

  327.         feature = utils.Feature.from_end(end=10, source=source, feature_extractor=feature_extractor, score=score)

  328.         self.assertEqual(feature.interval.start, 5)

  329.         self.assertEqual(feature.interval.end, 10)

  330.         self.assertEqual(feature.interval.duration, 5)

  331.         self.assertEqual(feature.source, source)

  332.         self.assertEqual(feature.feature_extractor, feature_extractor)

  333.         self.assertEqual(feature.score, score)

  334. 

  335.     def test_lt(self):

  336.         """test __lt__ method for sorting Feature objects"""

  337.         # TODO: ensure goood coverage of corresponding __lt__ method of Interval

  338.         feature1 = utils.Feature(utils.Interval(0, 10), MockSource("source"), "test_1", 0.5)

  339.         feature2 = utils.Feature(utils.Interval(0, 15), MockSource("source"), "test_1", 0.5)

  340.         feature3 = utils.Feature(utils.Interval(5, 10), MockSource("source"), "test_1", 0.5)

  341.         feature4 = utils.Feature(utils.Interval(5, 15), MockSource("source"), "test_1", 0.5)

  342.         feature5 = utils.Feature(utils.Interval(0, 10), MockSource("source"), "test_1", 0.6) # score

  343.         feature6 = utils.Feature(utils.Interval(0, 10), MockSource("source"), "test_2", 0.5) # feature_extractor

  344. 

  345.         # test sorting based on Interval

  346.         self.assertTrue(feature1 < feature2)

  347.         self.assertTrue(feature1 < feature3)

  348.         self.assertTrue(feature3 < feature4)

  349. 

  350.         # test sorting based on feature_extractor

  351.         self.assertTrue(feature1 < feature6)

  352. 

  353.         # test sorting based on score

  354.         self.assertTrue(feature1 < feature5)

  355. 

  356.     def test_eq(self):

  357.         """test __eq__ method for comparing Feature objects"""

  358.         feature1 = utils.Feature(utils.Interval(0, 10), MockSource("source"), "test_1", 0.5)

  359.         feature2 = utils.Feature(utils.Interval(0, 10), MockSource("source"), "test_1", 0.5)

  360.         feature3 = utils.Feature(utils.Interval(0, 10), MockSource("source"), "test_1", 0.6)

  361.         self.assertEqual(feature1, feature2)

  362.         self.assertNotEqual(feature1, feature3)

  363. 

  364.     def test_feature_no_score(self):

  365.         """Test creating a Feature without a score"""

  366.         source = MockSource("source")

  367.         interval = MockInterval(0, 10)

  368.         feature_extractor = "test"

  369.         feature = utils.Feature(interval, source, feature_extractor)

  370.         self.assertEqual(feature.score, 0.0)

  371. 

  372.     # unhappy path tests

  373. 

  374.     def test_init_unhappy(self):

  375.         """Test init with pats missing"""

  376.         with self.assertRaises(ValueError):

  377.             utils.Feature(None, None, None, None)

  378. 

  379.         # missing interval

  380.         with self.assertRaises(ValueError):

  381.             utils.Feature(None, MockSource("source"), "feature_extractor", 0.5)

  382. 

  383.         # missing source

  384.         with self.assertRaises(ValueError):

  385.             utils.Feature(MockInterval(0, 10), None, "feature_extractor", 0.5)

  386. 

  387.         # missing feature_extractor

  388.         feature = utils.Feature(MockInterval(0, 10), MockSource("source"), None, 0.5)

  389.         self.assertEqual(feature.feature_extractor, "unknown")

  390. 

  391. if __name__ == "__main__":

  392.     unittest.main()