Rename test/ to tests/

.github/workflows/cd.yml

@@ -88,7 +88,7 @@ jobs:
             run: pip install -e .[tests]
 
         -   name: Run pytest
-            run: pytest -sv --cov=plumpy test
+            run: pytest -s --cov=plumpy tests
 
         -   name: Create xml coverage
             run: coverage xml

.github/workflows/ci.yml

@@ -45,7 +45,7 @@ jobs:
             run: pip install .[tests]
 
         -   name: Run pytest
-            run: pytest -s --cov=plumpy test
+            run: pytest -s --cov=plumpy tests/
 
         -   name: Create xml coverage
             run: coverage xml

pyproject.toml

@@ -74,7 +74,7 @@ name = 'plumpy'
 exclude = [
     'docs/',
     'examples/',
-    'test/',
+    'tests/',
 ]
 
 [tool.flynt]

test/base/test_statemachine.py → tests/base/test_statemachine.py

@@ -25,7 +25,7 @@ def __init__(self, player, track):
         super().__init__(player)
         self.track = track
         self._last_time = None
-        self._played = 0.0
+        self._played = 0.
 
     def __str__(self):
         if self.in_state:
@@ -40,7 +40,7 @@ def exit(self):
         super().exit()
         self._update_time()
 
-    def play(self, track=None):
+    def play(self, track=None):  # pylint: disable=no-self-use, unused-argument
         return False
 
     def _update_time(self):
@@ -55,7 +55,8 @@ class Paused(state_machine.State):
     TRANSITIONS = {STOP: STOPPED}
 
     def __init__(self, player, playing_state):
-        assert isinstance(playing_state, Playing), 'Must provide the playing state to pause'
+        assert isinstance(playing_state, Playing), \
+            'Must provide the playing state to pause'
         super().__init__(player)
         self.playing_state = playing_state
 
@@ -64,7 +65,7 @@ def __str__(self):
 
     def play(self, track=None):
         if track is not None:
-            self.state_machine.transition_to(Playing, track)
+            self.state_machine.transition_to(Playing, track=track)
         else:
             self.state_machine.transition_to(self.playing_state)
 
@@ -80,7 +81,7 @@ def __str__(self):
         return '[]'
 
     def play(self, track):
-        self.state_machine.transition_to(Playing, track)
+        self.state_machine.transition_to(Playing, track=track)
 
 
 class CdPlayer(state_machine.StateMachine):
@@ -107,7 +108,7 @@ def play(self, track=None):
 
     @state_machine.event(from_states=Playing, to_states=Paused)
     def pause(self):
-        self.transition_to(Paused, self._state)
+        self.transition_to(Paused, playing_state=self._state)
         return True
 
     @state_machine.event(from_states=(Playing, Paused), to_states=Stopped)
@@ -116,13 +117,14 @@ def stop(self):
 
 
 class TestStateMachine(unittest.TestCase):
+
     def test_basic(self):
         cd_player = CdPlayer()
         self.assertEqual(cd_player.state, STOPPED)
 
         cd_player.play('Eminem - The Real Slim Shady')
         self.assertEqual(cd_player.state, PLAYING)
-        time.sleep(1.0)
+        time.sleep(1.)
 
         cd_player.pause()
         self.assertEqual(cd_player.state, PAUSED)

test/rmq/test_process_comms.py → tests/rmq/test_process_comms.py

@@ -1,14 +1,15 @@
 # -*- coding: utf-8 -*-
 import asyncio
+import copy
 
 import kiwipy
+from kiwipy import rmq
 import pytest
 import shortuuid
-from kiwipy import rmq
 
 import plumpy
-import plumpy.communications
 from plumpy import process_comms
+import plumpy.communications
 
 from .. import utils
 
@@ -43,11 +44,12 @@ def sync_controller(thread_communicator: rmq.RmqThreadCommunicator):
 
 
 class TestRemoteProcessController:
+
     @pytest.mark.asyncio
     async def test_pause(self, thread_communicator, async_controller):
         proc = utils.WaitForSignalProcess(communicator=thread_communicator)
         # Run the process in the background
-        asyncio.ensure_future(proc.step_until_terminated())  # noqa: RUF006
+        asyncio.ensure_future(proc.step_until_terminated())
         # Send a pause message
         result = await async_controller.pause_process(proc.pid)
 
@@ -59,7 +61,7 @@ async def test_pause(self, thread_communicator, async_controller):
     async def test_play(self, thread_communicator, async_controller):
         proc = utils.WaitForSignalProcess(communicator=thread_communicator)
         # Run the process in the background
-        asyncio.ensure_future(proc.step_until_terminated())  # noqa: RUF006
+        asyncio.ensure_future(proc.step_until_terminated())
         assert proc.pause()
 
         # Send a play message
@@ -77,7 +79,7 @@ async def test_play(self, thread_communicator, async_controller):
     async def test_kill(self, thread_communicator, async_controller):
         proc = utils.WaitForSignalProcess(communicator=thread_communicator)
         # Run the process in the event loop
-        asyncio.ensure_future(proc.step_until_terminated())  # noqa: RUF006
+        asyncio.ensure_future(proc.step_until_terminated())
 
         # Send a kill message and wait for it to be done
         result = await async_controller.kill_process(proc.pid)
@@ -90,7 +92,7 @@ async def test_kill(self, thread_communicator, async_controller):
     async def test_status(self, thread_communicator, async_controller):
         proc = utils.WaitForSignalProcess(communicator=thread_communicator)
         # Run the process in the background
-        asyncio.ensure_future(proc.step_until_terminated())  # noqa: RUF006
+        asyncio.ensure_future(proc.step_until_terminated())
 
         # Send a status message
         status = await async_controller.get_status(proc.pid)
@@ -121,6 +123,7 @@ def on_broadcast_receive(**msg):
 
 
 class TestRemoteProcessThreadController:
+
     @pytest.mark.asyncio
     async def test_pause(self, thread_communicator, sync_controller):
         proc = utils.WaitForSignalProcess(communicator=thread_communicator)
@@ -195,15 +198,18 @@ async def test_kill_all(self, thread_communicator, sync_controller):
         for _ in range(10):
             procs.append(utils.WaitForSignalProcess(communicator=thread_communicator))
 
-        sync_controller.kill_all('bang bang, I shot you down')
+        msg = copy.copy(process_comms.KILL_MSG)
+        msg[process_comms.MESSAGE_KEY] = 'bang bang, I shot you down'
+
+        sync_controller.kill_all(msg)
         await utils.wait_util(lambda: all([proc.killed() for proc in procs]))
         assert all([proc.state == plumpy.ProcessState.KILLED for proc in procs])
 
     @pytest.mark.asyncio
     async def test_status(self, thread_communicator, sync_controller):
         proc = utils.WaitForSignalProcess(communicator=thread_communicator)
         # Run the process in the background
-        asyncio.ensure_future(proc.step_until_terminated())  # noqa: RUF006
+        asyncio.ensure_future(proc.step_until_terminated())
 
         # Send a status message
         status_future = sync_controller.get_status(proc.pid)

test/test_process_comms.py → tests/test_process_comms.py

@@ -1,17 +1,23 @@
 # -*- coding: utf-8 -*-
+import asyncio
+from test import utils
+import unittest
+
+from kiwipy import rmq
 import pytest
 
 import plumpy
-from plumpy import process_comms
-from test import utils
+from plumpy import communications, process_comms
 
 
 class Process(plumpy.Process):
+
     def run(self):
         pass
 
 
 class CustomObjectLoader(plumpy.DefaultObjectLoader):
+
     def load_object(self, identifier):
         if identifier == 'jimmy':
             return Process
@@ -35,14 +41,15 @@ async def test_continue():
     pid = process.pid
     persister.save_checkpoint(process)
     del process
+    process = None
 
     result = await launcher._continue(None, **plumpy.create_continue_body(pid)[process_comms.TASK_ARGS])
     assert result == utils.DummyProcess.EXPECTED_OUTPUTS
 
 
 @pytest.mark.asyncio
 async def test_loader_is_used():
-    """Make sure that the provided class loader is used by the process launcher"""
+    """ Make sure that the provided class loader is used by the process launcher """
     loader = CustomObjectLoader()
     proc = Process()
     persister = plumpy.InMemoryPersister(loader=loader)