def create_dummy_display_controller(*, number_of_images: int = 0, number_of_image_transformers: int = 0, **kwargs) \
-> DisplayController:
"""
Creates a dummy display controller.
:param number_of_images: number of images in the display controller's image store
:param number_of_image_transformers: number of image transformers to create
:param kwargs: key-word arguments to pass to `DisplayController`
:return: the dummy display controller
"""
if number_of_images != 0 and "image_store" in kwargs:
raise ValueError(
"Cannot specify number of images to create in an image store and pass in image store"
)
if "image_store" not in kwargs:
kwargs["image_store"] = InMemoryImageStore(
create_image() for _ in range(number_of_images))
if number_of_image_transformers != 0:
if "image_transformers" in kwargs:
raise ValueError(
"Cannot specify a number of image transformers to be created in addition to passing in "
"image transformers")
kwargs["image_transformers"] = [
SimpleImageTransformer()
for _ in range(number_of_image_transformers)
]
return BaseDisplayController(driver=DummyBaseDisplayDriver(), **kwargs)
def test_display_next_image_when_image_added(self):
image_store = InMemoryImageStore([WHITE_IMAGE])
display_controller = self.create_display_controller(image_store)
display_controller.display_next_image()
display_controller.image_store.add(BLACK_IMAGE)
display_controller.display_next_image()
self.assertEqual(BLACK_IMAGE, display_controller.current_image)
def test_display_next_image_when_image_removed_and_some_left(self):
image_store = InMemoryImageStore([WHITE_IMAGE, BLACK_IMAGE])
display_controller = self.create_display_controller(image_store)
first_image = display_controller.display_next_image()
display_controller.image_store.remove(first_image.identifier)
self.assertIsNotNone(display_controller.current_image)
self.assertNotEqual(first_image, display_controller.current_image)
def test_display_next_image_when_image_removed_and_no_left(self):
image_store = InMemoryImageStore([WHITE_IMAGE])
display_controller = self.create_display_controller(image_store)
self.assertEqual(WHITE_IMAGE, display_controller.display_next_image())
self.assertEqual(WHITE_IMAGE, display_controller.current_image)
display_controller.image_store.remove(WHITE_IMAGE.identifier)
self.assertIsNone(display_controller.current_image)
def test_display_next_image_when_single_image(self):
image_store = InMemoryImageStore([WHITE_IMAGE])
display_controller = self.create_display_controller(image_store)
self.assertEqual(WHITE_IMAGE, display_controller.display_next_image())
self.assertEqual(WHITE_IMAGE, display_controller.current_image)
self.assertEqual(WHITE_IMAGE, display_controller.display_next_image())
self.assertEqual(WHITE_IMAGE, display_controller.current_image)
def create_display_controller(self, image_store: Optional[ImageStore] = None, *args, **kwargs) \
-> AutoCyclingDisplayController:
display_controller = AutoCyclingDisplayController(
DummyBaseDisplayDriver(),
image_store if image_store is not None else InMemoryImageStore(),
cycle_image_after_seconds=0.001)
self._display_controllers.append(display_controller)
return display_controller
def test_display_next_image_when_multiple_image(self):
image_store = InMemoryImageStore([WHITE_IMAGE, BLACK_IMAGE])
display_controller = self.create_display_controller(image_store)
first_image = display_controller.display_next_image()
second_image = display_controller.display_next_image()
self.assertCountEqual((WHITE_IMAGE, BLACK_IMAGE),
(first_image, second_image))
self.assertNotEqual(first_image, second_image)
def test_stop(self):
display_controller = self.create_display_controller(
InMemoryImageStore([WHITE_IMAGE, BLACK_IMAGE]))
changes = 0
def listener(image: Image):
nonlocal changes
changes += 1
display_controller.driver.event_listeners.add_listener(
listener, ListenableDisplayDriver.Event.DISPLAY)
display_controller.start()
display_controller.stop()
end_changes = changes
sleep(display_controller.cycle_image_after_seconds * 25)
self.assertEqual(end_changes, changes)
def test_start(self):
display_controller = self.create_display_controller(
InMemoryImageStore([WHITE_IMAGE, BLACK_IMAGE]))
images = list()
call_semaphore = Semaphore(0)
def listener(image: Image):
nonlocal call_semaphore
nonlocal images
call_semaphore.release()
images.append(image)
display_controller.driver.event_listeners.add_listener(
listener, ListenableDisplayDriver.Event.DISPLAY)
display_controller.start()
for _ in range(10):
self.assertTrue(call_semaphore.acquire(timeout=10))
self.assertIn(WHITE_IMAGE, images)
self.assertIn(BLACK_IMAGE, images)
def create_image_store(self, *args, **kwargs) -> ListenableImageStore:
return ListenableImageStore(InMemoryImageStore(*args, **kwargs))
def create_image_store(self, *args, **kwargs) -> InMemoryImageStore:
return InMemoryImageStore(*args, **kwargs)
def create_display_controller(self, image_store: Optional[ImageStore] = None, *args, **kwargs) \
-> CyclableDisplayController:
return CyclableDisplayController(
DummyBaseDisplayDriver(),
image_store if image_store is not None else InMemoryImageStore())