idmtools-platform-container 0.0.0.dev0__py3-none-any.whl → 0.0.2__py3-none-any.whl

tests/test_container_cli/test_history_count.py

@@ -0,0 +1,53 @@
+import os
+import sys
+import unittest
+from unittest.mock import patch
+import pytest
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+import idmtools_platform_container.cli.container as container_cli
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from test_base import TestContainerPlatformCliBase
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformHistoryCountCli(TestContainerPlatformCliBase):
+    @patch('rich.console.Console.print')
+    def test_history_count(self, mock_console):
+        # first clear the history
+        result = self.runner.invoke(container_cli.container, ['clear-history'])
+        self.assertEqual(result.exit_code, 0)
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False)
+        # run another experiment job
+        experiment1 = Experiment.from_task(task, name="run_command")
+        experiment1.run(wait_until_done=False)
+        # test history
+        result = self.runner.invoke(container_cli.container, ['history-count'])
+        self.assertEqual(result.exit_code, 0)
+        self.assertTrue(mock_console.call_args_list[0].args[0] == 2)  # Make sure there are 2 jobs in history
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', self.platform.container_id], '--remove')
+        self.assertEqual(result.exit_code, 0)
+
+    def test_history_count_help(self):
+        result = self.runner.invoke(container_cli.container, ['history-count', "--help"])
+        expected_help = ('Usage: container history-count [OPTIONS] [CONTAINER_ID]\n'
+                         '\n'
+                         '  Get the count of count histories.\n'
+                         '\n'
+                         '  Arguments:\n'
+                         '\n'
+                         '    CONTAINER_ID: Container ID (optional)\n'
+                         '\n'
+                         'Options:\n'
+                         '  --help  Show this message and exit.\n')
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_container_cli/test_inspect.py

@@ -0,0 +1,53 @@
+import os
+import sys
+from time import sleep
+from unittest.mock import patch
+import pytest
+import idmtools_platform_container.cli.container as container_cli
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from test_base import TestContainerPlatformCliBase
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformInspectCli(TestContainerPlatformCliBase):
+
+    @patch('rich.console.Console.print')
+    def test_inspect(self, mock_console):
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False)
+        sleep(1)
+        result = self.runner.invoke(container_cli.container, ['inspect', self.platform.container_id])
+        self.assertIn('Container ID', mock_console.call_args_list[1][0][0])
+        self.assertIn(f'{self.platform.container_id}', mock_console.call_args_list[1][0][0])
+        self.assertIn('Container Name', mock_console.call_args_list[2][0][0])
+        self.assertIn('Status', mock_console.call_args_list[3][0][0])
+        self.assertIn('Created', mock_console.call_args_list[4][0][0])
+        self.assertIn('StartedAt', mock_console.call_args_list[5][0][0])
+        self.assertIn('Image', mock_console.call_args_list[6][0][0])
+        self.assertIn(f'{self.platform.docker_image}', mock_console.call_args_list[7][0][0].text.plain)
+        self.assertIn('Image Tags', mock_console.call_args_list[8][0][0])
+        self.assertIn('State', mock_console.call_args_list[10][0][0])
+        self.assertIn('Mounts', mock_console.call_args_list[12][0][0])
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', self.platform.container_id], '--remove')
+        self.assertEqual(result.exit_code, 0)
+
+    def test_inspect_help(self):
+        result = self.runner.invoke(container_cli.container, ['inspect', "--help"])
+        expected_help = ('Usage: container inspect [OPTIONS] CONTAINER_ID\n'
+                         '\n'
+                         '  Inspect a container.\n'
+                         '\n'
+                         '  Arguments:\n'
+                         '\n'
+                         '    CONTAINER_ID: Container ID\n'
+                         '\n'
+                         'Options:\n'
+                         '  --help  Show this message and exit.\n')
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)

tests/test_container_cli/test_install.py

@@ -0,0 +1,48 @@
+import os
+import sys
+from time import sleep
+from unittest.mock import patch
+import pytest
+import idmtools_platform_container.cli.container as container_cli
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from test_base import TestContainerPlatformCliBase
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformInstallCli(TestContainerPlatformCliBase):
+
+    @patch('rich.console.Console.print')
+    def test_install(self, mock_console):
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False)
+        sleep(1)
+        result = self.runner.invoke(container_cli.container, ['install', 'astor', '-c', self.platform.container_id])
+        # verify that the package was installed with container packages cli
+        result = self.runner.invoke(container_cli.container, ['packages', self.platform.container_id])
+        self.assertIn('astor', mock_console.call_args_list[1][0][0])
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', self.platform.container_id], '--remove')
+        self.assertEqual(result.exit_code, 0)
+
+    def test_install_help(self):
+        result = self.runner.invoke(container_cli.container, ['install', "--help"])
+        expected_help = ('Usage: container install [OPTIONS] PACKAGE\n'
+                         '\n'
+                         '  pip install a package on a container.\n'
+                         '\n'
+                         '  Arguments:\n'
+                         '\n'
+                         '    PACKAGE: package to be installed\n'
+                         '\n'
+                         'Options:\n'
+                         '  -c, --container-id TEXT     Container ID\n'
+                         '  -i, --index-url TEXT        index-url for pip install\n'
+                         '  -e, --extra-index-url TEXT  extra-index-url for pip install\n'
+                         '  --help                      Show this message and exit.\n')
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)

tests/test_container_cli/test_is_running.py

@@ -0,0 +1,69 @@
+import os
+import sys
+import unittest
+from time import sleep
+from unittest.mock import patch
+import pytest
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+import idmtools_platform_container.cli.container as container_cli
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(script_dir)
+from test_base import TestContainerPlatformCliBase
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformIsRunningCli(TestContainerPlatformCliBase):
+
+    def test_is_running(self):
+        command = "python3 Assets/sleep.py"
+        task = CommandTask(command=command)
+        task.common_assets.add_asset(os.path.join(script_dir, "..", "inputs", "sleep.py"))
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False)
+        sleep(10)
+        # test is-running with experiment id
+        with patch('rich.console.Console.print') as mock_console_exp:
+            result = self.runner.invoke(container_cli.container, ['is-running', experiment.id])
+            self.assertEqual(result.exit_code, 0)
+            self.assertEqual(f'EXPERIMENT {experiment.id} is running on container {self.platform.container_id}.',
+                             mock_console_exp.call_args_list[0][0][0])
+        # test is-running with simulation id
+        with patch('rich.console.Console.print') as mock_console_sim:
+            result = self.runner.invoke(container_cli.container, ['is-running', experiment.simulations[0].id])
+            self.assertEqual(result.exit_code, 0)
+            self.assertEqual(
+                f'SIMULATION {experiment.simulations[0].id} is running on container {self.platform.container_id}.',
+                mock_console_sim.call_args_list[0][0][0])
+        # test is-running with invalid id
+        with patch('rich.console.Console.print') as mock_console_invalid:
+            result = self.runner.invoke(container_cli.container, ['is-running', "abc"])
+            self.assertEqual(result.exit_code, 0)
+            self.assertEqual(f'Job abc is not found.', mock_console_invalid.call_args_list[0][0][0])
+
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', self.platform.container_id], '--remove')
+        self.assertEqual(result.exit_code, 0)
+
+    def test_is_running_help(self):
+        result = self.runner.invoke(container_cli.container, ['is-running', "--help"])
+        expected_help = (
+            'Usage: container is-running [OPTIONS] ITEM_ID\n'
+            '\n'
+            '  Check if an Experiment/Simulation is running.\n'
+            '\n'
+            '  Arguments:\n'
+            '\n'
+            '    ITEM_ID: Experiment/Simulation ID\n'
+            '\n'
+            'Options:\n'
+            '  --help  Show this message and exit.\n'
+        )
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_container_cli/test_jobs.py

@@ -0,0 +1,138 @@
+import os
+import sys
+import unittest
+import re
+from unittest.mock import patch
+import pytest
+
+from idmtools.entities import Suite
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+import idmtools_platform_container.cli.container as container_cli
+from idmtools_platform_container.container_platform import ContainerPlatform
+from idmtools_platform_file.tools.job_history import JobHistory
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(script_dir)
+from test_base import TestContainerPlatformCliBase
+from helper import get_actual_rich_table_values
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformJobCli(TestContainerPlatformCliBase):
+
+    @patch('rich.console.Console.print')
+    def test_jobs(self, mock_console):
+        command = "python3 Assets/sleep.py 100"
+        task = CommandTask(command=command)
+        task.common_assets.add_asset(os.path.join(script_dir, "..", "inputs", "sleep.py"))
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False)
+        job = JobHistory.get_job(experiment.id)
+
+        # second experiment
+        experiment2 = Experiment.from_task(task, name="run_command")
+        experiment2.run(wait_until_done=False)
+        job2 = JobHistory.get_job(experiment2.id)
+
+        # test jobs
+        result = self.runner.invoke(container_cli.container, ['jobs'])
+        self.assertEqual(result.exit_code, 0)
+        actual_table = get_actual_rich_table_values(mock_console)
+        expected_job = ['EXPERIMENT', experiment.id, job['CONTAINER']]
+        expected_job2 = ['EXPERIMENT', experiment2.id, job2['CONTAINER']]
+        elapsed_ok = False
+        job_ok = False
+        expected_head = ['Entity Type', 'Entity ID', 'Job ID', 'Container', 'Status', 'Elapsed']
+        self.assertEqual(actual_table[0], expected_head)
+        for row in actual_table[1:]:
+            if row[1] == experiment.id:  # if experiment id is found
+                # make sure all items in expected_job are in row
+                self.assertTrue(all(item in row for item in expected_job))
+            if row[1] == experiment2.id:  # if experiment2 id is found
+                self.assertTrue(all(item in row for item in expected_job2))
+
+            # verify last item (Elapsed) in row is in format of 'HH:MM'
+            match = re.match(r'^\d{2}:\d{2}$', row[-1])
+            elapsed_ok = True if match else False
+
+            # verify job is found
+            match_job = re.match(r'^\d+$', row[2])
+            job_ok = True if match_job else False
+        self.assertEqual(job_ok, True)
+        self.assertEqual(elapsed_ok, True)
+        # # clean up container
+        # result = self.runner.invoke(container_cli.container, ['stop-container', self.platform.container_id], '--remove')
+        # self.assertEqual(result.exit_code, 0)
+
+    @patch('rich.console.Console.print')
+    def test_jobs_with_container_id(self, mock_console):
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False)
+        job = JobHistory.get_job(experiment.id)
+        # test jobs with container id
+        result = self.runner.invoke(container_cli.container, ['jobs'], self.platform.container_id)
+        self.assertEqual(result.exit_code, 0)
+        actual_table = get_actual_rich_table_values(mock_console)
+        expected_job = ['EXPERIMENT', experiment.id, job['CONTAINER']]
+        found = False
+        for row in actual_table[1:]:
+            if all(item in row for item in expected_job):  # if all items in expected_job are in row
+                found = True  # set found to True
+        self.assertEqual(found, True)
+        # clean up by stop the job
+        result = self.runner.invoke(container_cli.container, ['cancel', experiment.id])
+        self.assertEqual(result.exit_code, 0)
+
+    @patch('rich.console.Console.print')
+    def test_jobs_with_container_suite(self, mock_console):
+        # first clear the history
+        result = self.runner.invoke(container_cli.container, ['clear-history'])
+        self.assertEqual(result.exit_code, 0)
+        command = "sleep 100"
+        platform = ContainerPlatform(job_directory=self.job_directory, new_container=True)
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        suite = Suite(name="suite_name")
+        suite.add_experiment(experiment)
+        suite.run(wait_until_done=False, platform=platform)
+        job = JobHistory.get_job(experiment.id)
+        # test history
+        result = self.runner.invoke(container_cli.container, ['jobs'], platform.container_id)
+        self.assertEqual(result.exit_code, 0)
+        actual_table = get_actual_rich_table_values(mock_console)
+        expected_job = ['EXPERIMENT', experiment.id, job['CONTAINER']]
+        found = False
+        for row in actual_table[1:]:
+            if all(item in row for item in expected_job):  # if all items in expected_job are in row
+                found = True  # set found to True
+        self.assertEqual(found, True)
+        # clean up by stop the job
+        result = self.runner.invoke(container_cli.container, ['cancel', experiment.id])
+        self.assertEqual(result.exit_code, 0)
+
+    def test_jobs_help(self):
+        result = self.runner.invoke(container_cli.container, ['jobs', "--help"])
+        expected_help = (
+            'Usage: container jobs [OPTIONS] [CONTAINER_ID]\n'
+            '\n'
+            '  List running Experiment/Simulation jobs.\n'
+            '\n'
+            '  Arguments:\n'
+            '\n'
+            '    CONTAINER_ID: Container ID (optional)\n'
+            '\n'
+            'Options:\n'
+            '  -l, --limit INTEGER  Max number of simulations to show\n'
+            '  -n, --next INTEGER   Next number of jobs to show\n'
+            '  --help               Show this message and exit.\n'
+        )
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_container_cli/test_list_containers.py

@@ -0,0 +1,99 @@
+import os
+import re
+import sys
+import unittest
+from unittest.mock import patch
+import pytest
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+import idmtools_platform_container.cli.container as container_cli
+from idmtools_platform_container.container_platform import ContainerPlatform
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from test_base import TestContainerPlatformCliBase
+from helper import get_actual_rich_table_values, cleaned_str
+
+upper_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(upper_dir)
+from utils import delete_containers_by_image_prefix
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformListContainersCli(TestContainerPlatformCliBase):
+    def setUp(self):
+        super(TestContainerPlatformListContainersCli, self).setUpClass()
+        delete_containers_by_image_prefix(self.platform.docker_image)
+
+    @patch('rich.console.Console.print')
+    def test_list_containers(self, mock_console):
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False, platform=self.platform)
+        result = self.runner.invoke(container_cli.container, ['list-containers'])
+        self.assertEqual(result.exit_code, 0)
+        # verify there are at least 1 container show up in result
+        expected_result = bool(re.match(r'There are 1 container\(s\)\.', mock_console.call_args_list[0].args[0]))
+        self.assertTrue(expected_result)
+        table = get_actual_rich_table_values(mock_console)
+        expected_head = ["Container ID", "Image", "Status", "Created", "Started", "Name"]
+        self.assertEqual(table[0], expected_head)
+        self.assertEqual(self.platform.container_id, table[1][0])
+        self.assertEqual(self.platform.docker_image, table[1][1])
+        self.assertIn("running", cleaned_str(table[1][2]))
+        match_created_time = re.match(r'^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$', table[1][3])
+        match_started_time = re.match(r'^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$', table[1][4])
+        self.assertTrue(match_created_time)
+        self.assertTrue(match_started_time)
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', self.platform.container_id])
+        self.assertEqual(result.exit_code, 0)
+
+    @patch('rich.console.Console.print')
+    def test_list_containers_all(self, mock_console):
+        # create first job then stop it
+        platform1 = ContainerPlatform(job_directory=self.job_directory)
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False, platform=platform1)
+        # stop container
+        result = self.runner.invoke(container_cli.container, ['stop-container', platform1.container_id])
+        self.assertEqual(result.exit_code, 0)
+        # create another job
+        platform2 = ContainerPlatform(job_directory=self.job_directory, new_container=True)
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment2 = Experiment.from_task(task, name="run_command")
+        experiment2.run(wait_until_done=False, platform=platform2)
+        with patch('rich.console.Console.print') as mock_console:
+            result = self.runner.invoke(container_cli.container, ['list-containers', '--all'])
+            self.assertEqual(result.exit_code, 0)
+            # verify there are at least 2 container show up in result
+            expected_result = bool(
+                re.match(r'There are [1-9]\d* container\(s\)\.', mock_console.call_args_list[0].args[0]))
+            self.assertTrue(expected_result)
+
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', platform1.container_id])
+        self.assertEqual(result.exit_code, 0)
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', platform2.container_id])
+        self.assertEqual(result.exit_code, 0)
+
+    def test_list_containers_help(self):
+        result = self.runner.invoke(container_cli.container, ['list-containers', "--help"])
+        expected_help = ('Usage: container list-containers [OPTIONS]\n'
+                         '\n'
+                         '  List all available containers.\n'
+                         '\n'
+                         'Options:\n'
+                         '  --all / --no-all  Include stopped containers or not\n'
+                         '  --help            Show this message and exit.\n')
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_container_cli/test_packages.py

@@ -0,0 +1,41 @@
+import os
+import sys
+from unittest.mock import patch
+import pytest
+import idmtools_platform_container.cli.container as container_cli
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from test_base import TestContainerPlatformCliBase
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformPackagesCli(TestContainerPlatformCliBase):
+
+    @patch('rich.console.Console.print')
+    def test_packages(self, mock_console):
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False)
+        result = self.runner.invoke(container_cli.container, ['packages', self.platform.container_id])
+        self.assertEqual(result.exit_code, 0)
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', self.platform.container_id], '--remove')
+        self.assertEqual(result.exit_code, 0)
+
+    def test_packages_help(self):
+        result = self.runner.invoke(container_cli.container, ['packages', "--help"])
+        expected_help = ('Usage: container packages [OPTIONS] CONTAINER_ID\n'
+                        '\n'
+                        '  List packages installed on a container.\n'
+                        '\n'
+                        '  Arguments:\n'
+                        '\n'
+                        '    CONTAINER_ID: Container ID\n'
+                        '\n'
+                        'Options:\n'
+                        '  --help  Show this message and exit.\n')
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)

tests/test_container_cli/test_path.py

@@ -0,0 +1,96 @@
+import os
+import sys
+from unittest.mock import patch
+import pytest
+
+import idmtools_platform_container.cli.container as container_cli
+from idmtools.core import ItemType
+from idmtools.entities import Suite
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+from idmtools_platform_container.utils.general import normalize_path
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from test_base import TestContainerPlatformCliBase
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformPathCli(TestContainerPlatformCliBase):
+
+    def test_path_help(self):
+        result = self.runner.invoke(container_cli.container, ['path', "--help"])
+        expected_help = ('Usage: container path [OPTIONS] ITEM_ID\n'
+                         '\n'
+                         '  Locate Suite/Experiment/Simulation file directory.\n'
+                         '\n'
+                         '  Arguments:\n'
+                         '\n'
+                         '    ITEM_ID: Suite/Experiment/Simulation ID\n'
+                         '\n'
+                         'Options:\n'
+                         '  --help  Show this message and exit.\n')
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)
+
+    @patch('rich.console.Console.print')
+    def test_path_new_no_suite(self, mock_console):
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False)
+        result = self.runner.invoke(container_cli.container, ['path', experiment.id])
+        self.assertEqual(result.exit_code, 0)
+        # check path
+        exp_dir = self.platform.get_directory_by_id(experiment.id, ItemType.EXPERIMENT)
+        self.assertIn(normalize_path(normalize_path(exp_dir)),
+                      normalize_path(mock_console.call_args.args[0].split(' ')[1]))
+        # Test simulation path
+        with patch("rich.console.Console.print") as mock_console:
+            result = self.runner.invoke(container_cli.container, ['path', experiment.simulations[0].id])
+            self.assertEqual(result.exit_code, 0)
+            sim_dir = self.platform.get_directory_by_id(experiment.simulations[0].id, ItemType.SIMULATION)
+            self.assertIn(normalize_path(normalize_path(sim_dir)),
+                          normalize_path(mock_console.call_args.args[0].split(' ')[1]))
+        # Test suite path
+        with patch("rich.console.Console.print") as mock_console:
+            result = self.runner.invoke(container_cli.container, ['path', experiment.parent_id])
+            self.assertEqual(result.exit_code, 1)
+
+    @patch('rich.console.Console.print')
+    def test_path_new_suite(self, mock_console):
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        suite = Suite(name="suite_name")
+        suite.add_experiment(experiment)
+        # Run via Suite (mirrors your original with-suite behavior)
+        experiment.run(platform=self.platform, wait_until_done=False)
+        result = self.runner.invoke(container_cli.container, ['path', experiment.id])
+        self.assertEqual(result.exit_code, 0)
+        # check path
+        exp_dir = self.platform.get_directory_by_id(experiment.id, ItemType.EXPERIMENT)
+        self.assertIn(normalize_path(normalize_path(exp_dir)),
+                      normalize_path(mock_console.call_args.args[0].split(' ')[1]))
+        # Test simulation path
+        with patch("rich.console.Console.print") as mock_console:
+            result = self.runner.invoke(container_cli.container, ['path', experiment.simulations[0].id])
+            self.assertEqual(result.exit_code, 0)
+            sim_dir = self.platform.get_directory_by_id(experiment.simulations[0].id, ItemType.SIMULATION)
+            self.assertIn(normalize_path(normalize_path(sim_dir)),
+                          normalize_path(mock_console.call_args.args[0].split(' ')[1]))
+        # Test suite path
+        with patch("rich.console.Console.print") as mock_console:
+            result = self.runner.invoke(container_cli.container, ['path', experiment.parent_id])
+            self.assertEqual(result.exit_code, 0)
+            suite_dir = self.platform.get_directory_by_id(suite.id, ItemType.SUITE)
+            self.assertIn(normalize_path(normalize_path(suite_dir)),
+                          normalize_path(mock_console.call_args.args[0].split(' ')[1]))
+
+        # Test invalid path
+        with patch("idmtools_platform_file.tools.job_history.logger") as mock_logger:
+            result = self.runner.invoke(container_cli.container, ['path', "abc"])
+            mock_logger.debug.assert_called_with("Invalid item id: abc")
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', self.platform.container_id], '--remove')
+        self.assertEqual(result.exit_code, 0)

tests/test_container_cli/test_ps.py

@@ -0,0 +1,47 @@
+import os
+import sys
+from unittest.mock import patch
+import pytest
+import idmtools_platform_container.cli.container as container_cli
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from test_base import TestContainerPlatformCliBase
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformProcessCli(TestContainerPlatformCliBase):
+
+    @patch('rich.console.Console.print')
+    def test_ps(self, mock_console):
+        command = "sleep 100"
+        task = CommandTask(command=command)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False)
+        result = self.runner.invoke(container_cli.container, ['ps', self.platform.container_id])
+        self.assertEqual(result.exit_code, 0)
+        # check ps
+        self.assertIn(f'EXPERIMENT:{experiment.id}', mock_console.call_args_list[0].args[0])
+        self.assertIn(f'batch.sh', mock_console.call_args_list[0].args[0])
+        # self.assertIn(
+        #     "xargs -d \\n -P 4 -I% bash -c cd $(pwd) && $(pwd)/run_simulation.sh %  1>> stdout.txt 2>> stderr.txt",
+        #     mock_console.call_args_list[0].args[0])
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', self.platform.container_id], '--remove')
+        self.assertEqual(result.exit_code, 0)
+
+    def test_ps_help(self):
+        result = self.runner.invoke(container_cli.container, ['ps', "--help"])
+        expected_help = ('Usage: container ps [OPTIONS] CONTAINER_ID\n'
+                         '\n'
+                         '  List running processes in a container.\n'
+                         '\n'
+                         '  Arguments:\n'
+                         '\n'
+                         '    CONTAINER_ID: Container ID\n'
+                         '\n'
+                         'Options:\n'
+                         '  --help  Show this message and exit.\n')
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)