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

tests/inputs/run.sh

@@ -0,0 +1 @@
+python3 -m pip list

tests/inputs/sleep.py

@@ -0,0 +1,9 @@
+import sys
+import time
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        sleep_time = int(sys.argv[1])
+    else:
+        sleep_time = 100
+    time.sleep(sleep_time)

tests/test_container_cli/helper.py

@@ -0,0 +1,57 @@
+import re
+
+from rich.table import Table
+
+
+def get_actual_rich_table_values(mock_console):
+    """
+    Get actual table values from the mock console
+    Args:
+        mock_console: rich.console.Console
+
+    Returns:
+        list for actual table values
+    """
+    actual_table = []
+    head = []
+    for call in mock_console.call_args_list:
+        args, _ = call
+
+        for arg in args:
+            if isinstance(arg, Table):
+                actual_rows = []
+                if len(head) == 0:
+                    head = [column.header for column in arg.columns]
+                    actual_table.append(head)
+                for c in arg.columns:
+                    actual_rows.append(c._cells[0])
+                actual_table.append(actual_rows)
+    return actual_table
+
+
+def found_job_id_by_experiment(actual_jobs_table, experiment_id=None):
+    """
+    Find job id by experiment id
+    Args:
+        actual_jobs_table: the actual jobs table from 'idmtools container jobs' cli command
+        experiment_id:
+
+    Returns:
+        job_id, container_id
+    """
+    for row in actual_jobs_table:
+        if row[1] == experiment_id:
+            return row[2], row[3]
+    return None
+
+
+def cleaned_str(input_string):
+    """
+    Remove all substrings enclosed in brackets, leading spaces, and newlines
+    Args:
+        input_string: str
+
+    Returns:
+        cleaned string
+    """
+    return re.sub(r'^\s+|\[.*?\]|\n', '', input_string)

tests/test_container_cli/test_base.py

@@ -0,0 +1,14 @@
+import unittest
+import os
+import pytest
+from click.testing import CliRunner
+from idmtools.core.platform_factory import Platform
+
+
+class TestContainerPlatformCliBase(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.runner = CliRunner()
+        cls.job_directory = os.path.join(os.path.dirname(os.path.abspath(__file__)), "DEST")
+        cls.platform = Platform("Container", job_directory=cls.job_directory)

tests/test_container_cli/test_cancel.py

@@ -0,0 +1,96 @@
+import os
+import sys
+from time import sleep
+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
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(script_dir)
+from test_base import TestContainerPlatformCliBase
+from helper import found_job_id_by_experiment, get_actual_rich_table_values
+
+
+@pytest.mark.serial
+class TestContainerPlatformCancelCli(TestContainerPlatformCliBase):
+    @patch('rich.console.Console.print')
+    def test_cancel_with_experiment_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)
+        sleep(1)
+        # test cancel with experiment id
+        result = self.runner.invoke(container_cli.container, ['cancel', experiment.id])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn('Successfully killed EXPERIMENT', mock_console.call_args_list[0].args[0])
+
+    @patch('rich.console.Console.print')
+    def test_cancel_with_simulation_id(self, mock_console1):
+        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(1)
+        # test cancel with simulation id
+        result = self.runner.invoke(container_cli.container, ['cancel', experiment.simulations[0].id])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn('Successfully killed SIMULATION', mock_console1.call_args_list[0].args[0])
+
+    @patch('rich.console.Console.print')
+    def test_cancel_with_experiment_job_id_and_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)
+        sleep(1)
+        result = self.runner.invoke(container_cli.container, ['jobs'])
+        self.assertEqual(result.exit_code, 0)
+        actual_table = get_actual_rich_table_values(mock_console)
+        job_id, container_id = found_job_id_by_experiment(actual_table[1:], experiment.id)
+        # test cancel with job_id and container_id
+        result = self.runner.invoke(container_cli.container, ['cancel', job_id, '-c', container_id])
+        self.assertTrue(f'Successfully killed EXPERIMENT {job_id}', mock_console.call_args[0][0])
+        self.assertEqual(result.exit_code, 0)
+
+    @patch('rich.console.Console.print')
+    def test_cancel_with_job_id_only(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, ['jobs'])
+        self.assertEqual(result.exit_code, 0)
+        actual_table = get_actual_rich_table_values(mock_console)
+        job_id, container_id = found_job_id_by_experiment(actual_table[1:], experiment.id)
+        # test cancel with job_id and container_id
+        result = self.runner.invoke(container_cli.container, ['cancel', job_id])
+        self.assertTrue(f'Successfully killed EXPERIMENT {job_id}', mock_console.call_args[0][0])
+        self.assertEqual(result.exit_code, 0)
+
+    def test_cancel_help(self):
+        result = self.runner.invoke(container_cli.container, ['cancel', "--help"])
+        expected_help = (
+            "Usage: container cancel [OPTIONS] ITEM_ID\n"
+            "\n"
+            "  Cancel an Experiment/Simulation job.\n"
+            "\n"
+            "  Arguments:\n"
+            "\n"
+            "    ITEM_ID: Experiment/Simulation ID or Job ID\n"
+            "\n"
+            "Options:\n"
+            "  -c, --container_id TEXT  Container Id\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_clear_results.py

@@ -0,0 +1,54 @@
+import os
+import sys
+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
+class TestContainerPlatformClearResultsCli(TestContainerPlatformCliBase):
+
+    def test_clear_results(self):
+        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, ['clear-results', experiment.id])
+        self.assertEqual(result.exit_code, 0)
+        # check if the EXPERIMENT_FILES are removed
+        for f in container_cli.EXPERIMENT_FILES:
+            self.assertFalse(os.path.exists(os.path.join(self.job_directory, experiment.id, f)))
+        # check if the SIMULATION_FILES are removed
+        for f in container_cli.SIMULATION_FILES:
+            self.assertFalse(os.path.exists(
+                os.path.join(self.job_directory,experiment.id, experiment.simulations[0].id, f)))
+        # clear-results Assets for simulation extra folder
+        result = self.runner.invoke(container_cli.container, ['clear-results', experiment.id, '-r',
+                                                              os.path.join(self.job_directory,
+                                                                           experiment.id, experiment.simulations[0].id,
+                                                                           "Assets")])
+        self.assertFalse(os.path.exists(
+            os.path.join(self.job_directory, experiment.id, experiment.simulations[0].id,
+                         "Assets")))
+        # 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_clear_results_help(self):
+        result = self.runner.invoke(container_cli.container, ['clear-results', "--help"])
+        expected_help = ('Usage: container clear-results [OPTIONS] ITEM_ID\n'
+                         '\n'
+                         '  Clear job results files and folders.\n'
+                         '\n'
+                         '  Arguments:\n'
+                         '\n'
+                         '    ITEM_ID: Experiment/Simulation ID\n'
+                         '\n'
+                         'Options:\n'
+                         '  -r, --remove TEXT  Extra files/folders to be removed from simulation\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_container.py

@@ -0,0 +1,72 @@
+import os
+import sys
+import pytest
+import idmtools_platform_container.cli.container as container_cli
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from test_base import TestContainerPlatformCliBase
+
+
+class TestContainerPlatformCliContainer(TestContainerPlatformCliBase):
+
+    def test_container_help(self):
+        result = self.runner.invoke(container_cli.container, ["--help"])
+        expected_help = ('Usage: container [OPTIONS] COMMAND [ARGS]...\n'
+                         '\n'
+                         '  Container Platform CLI commands.\n'
+                         '\n'
+                         '  Args:     all: Bool, show all commands\n'
+                         '\n'
+                         '  Returns:     None\n'
+                         '\n'
+                         'Options:\n'
+                         '  --all   Show all commands\n'
+                         '  --help  Show this message and exit.\n'
+                         '\n'
+                         'Commands:\n'
+                         '  cancel   Cancel an Experiment/Simulation job.\n'
+                         '  history  View the job history.\n'
+                         '  jobs     List running Experiment/Simulation jobs.\n'
+                         '  status   Check the status of an Experiment/Simulation.\n'
+                         )
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help)
+
+    def test_container_help_all(self):
+        result = self.runner.invoke(container_cli.container, ["--all", "--help"])
+        expected_help_all = ('Usage: container [OPTIONS] COMMAND [ARGS]...\n'
+                             '\n'
+                             '  Container Platform CLI commands.\n'
+                             '\n'
+                             '  Args:     all: Bool, show all commands\n'
+                             '\n'
+                             '  Returns:     None\n'
+                             '\n'
+                             'Options:\n'
+                             '  --all   Show all commands\n'
+                             '  --help  Show this message and exit.\n'
+                             '\n'
+                             'Commands:\n'
+                             '  cancel            Cancel an Experiment/Simulation job.\n'
+                             '  clear-history     Clear the job history.\n'
+                             '  clear-results     Clear job results files and folders.\n'
+                             '  get-detail        Retrieve Experiment history.\n'
+                             '  history           View the job history.\n'
+                             '  history-count     Get the count of count histories.\n'
+                             '  inspect           Inspect a container.\n'
+                             '  install           pip install a package on a container.\n'
+                             '  is-running        Check if an Experiment/Simulation is running.\n'
+                             '  jobs              List running Experiment/Simulation jobs.\n'
+                             '  list-containers   List all available containers.\n'
+                             '  packages          List packages installed on a container.\n'
+                             '  path              Locate Suite/Experiment/Simulation file directory.\n'
+                             '  ps                List running processes in a container.\n'
+                             '  remove-container  Remove stopped containers.\n'
+                             '  status            Check the status of an Experiment/Simulation.\n'
+                             '  stop-container    Stop running container(s).\n'
+                             '  sync-history      Sync the file system with job history.\n'
+                             '  verify-docker     Verify the Docker environment.\n'
+                             '  volume            Check the history volume.\n'
+                             )
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, expected_help_all)

tests/test_container_cli/test_file_container_cli.py

@@ -0,0 +1,121 @@
+import json
+import os
+import shutil
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+import pytest
+from click.testing import CliRunner
+import idmtools_platform_file.cli.file as file_cli
+from idmtools.core import EntityStatus, ItemType
+from idmtools.core.platform_factory import Platform
+from idmtools.entities.command_task import CommandTask
+from idmtools.entities.experiment import Experiment
+from idmtools_platform_container.container_operations.docker_operations import stop_container
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestFileContainerPlatformCli(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.runner = CliRunner()
+        cls.job_directory = os.path.join(os.path.dirname(os.path.abspath(__file__)), "DEST")
+        cls.platform = Platform("Container", job_directory=cls.job_directory)
+        command = "ls -lat"
+        task = CommandTask(command=command)
+        cls.experiment = Experiment.from_task(task, name="run_command")
+        cls.experiment.run(wait_until_done=True)
+
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        try:
+            stop_container(cls.platform.container_id, remove=True)
+        except Exception as e:
+            pass
+        shutil.rmtree(os.path.join(os.path.dirname(os.path.abspath(__file__)), "DEST"))
+
+    # Test cli: test status
+    # idmtools file DEST status-report --exp-id <exp_id>
+    @patch('idmtools_platform_file.tools.status_report.status_report.user_logger')
+    def test_status_report(self, mock_user_logger):
+        result = self.runner.invoke(file_cli.file,
+                                    [self.job_directory, 'status-report', '--exp-id', self.experiment.id])
+        self.assertEqual(result.exit_code, 0)
+        actual_messages = [call[0][0] for call in mock_user_logger.info.call_args_list]
+
+        # verify there are total 18 lines for this cli command
+        self.assertEqual(mock_user_logger.info.call_count, 17)
+
+        # verify first 2 lines as expected messages
+        expected_messages_first_2_lines = [
+            f"{'experiment: '.ljust(20)} {self.experiment.id}",
+            f"{'job directory: '.ljust(20)} {self.job_directory}",
+        ]
+        self.assertEqual(actual_messages[:2], expected_messages_first_2_lines)
+
+        # verify last 8 lines as expected messages
+        expected_messages_last_few_lines = [
+            f"{'status filter: '.ljust(20)} ('0', '-1', '100')",
+            f"{'sim filter: '.ljust(20)} None",
+            f"{'verbose: '.ljust(20)} True",
+            f"{'display: '.ljust(20)} True",
+            f"{'Simulation Count: '.ljust(20)} {self.experiment.simulation_count}",
+            f"{'Match Count: '.ljust(20)} 1 ({{'0': 1}})",
+            f"{'Not Running Count: '.ljust(20)} 0",
+            "\nExperiment Status: SUCCEEDED"
+        ]
+        self.assertEqual(actual_messages[-8:], expected_messages_last_few_lines)
+
+    # Test cli: get latest experiment info
+    # idmtools file job_directory get-latest
+    @patch('idmtools_platform_file.cli.file.user_logger')
+    def test_get_latest(self, mock_user_logger):
+        result = self.runner.invoke(file_cli.file, [self.job_directory, 'get-latest'])
+        self.assertEqual(result.exit_code, 0)
+        exp_dir = str(self.platform.get_directory_by_id(self.experiment.id, ItemType.EXPERIMENT))
+        expected_dict = dict(experiment_id=Path(exp_dir).name,
+                             experiment_directory=exp_dir,
+                             job_directory=self.job_directory)
+        actual_messages = [call[0][0] for call in mock_user_logger.info.call_args_list]
+        self.assertEqual(actual_messages[0], json.dumps(expected_dict, indent=3))
+
+    # Test cli: Get simulation/experiment's status
+    # idmtools file job_directory status --exp-id <exp_id>
+    @patch('idmtools_platform_file.tools.status_report.utils.user_logger')
+    def test_status(self, mock_user_logger):
+        result = self.runner.invoke(file_cli.file, [self.job_directory, 'status', '--exp-id', self.experiment.id])
+        self.assertEqual(result.exit_code, 0)
+        actual_messages = [call[0][0] for call in mock_user_logger.info.call_args_list]
+        exp_dir = str(self.platform.get_directory_by_id(self.experiment.id, ItemType.EXPERIMENT))
+        expected_messages = [
+            f"\nExperiment Directory: \n{exp_dir}",
+            "\nSimulation Count:    1\n",
+            "SUCCEEDED (1)",
+            "FAILED (0)",
+            "RUNNING (0)",
+            "PENDING (0)",
+            f"\nExperiment Status: SUCCEEDED\n"]
+        self.assertEqual(actual_messages, expected_messages)
+
+    # Test cli: get status of experiment/simulation
+    # idmtools file job_directory get-status --exp-id <exp_id>
+    @patch('idmtools_platform_file.cli.file.user_logger')
+    def test_get_status(self, mock_user_logger):
+        result = self.runner.invoke(file_cli.file, [self.job_directory, 'get-status', '--exp-id', self.experiment.id])
+        self.assertEqual(result.exit_code, 0)
+        mock_user_logger.info.assert_called_with("SUCCEEDED")
+
+    # Test cli: get path of experiment/simulation
+    # idmtools file job_directory get-path --exp-id <exp_id>
+    @patch('idmtools_platform_file.cli.file.user_logger')
+    def test_get_path(self, mock_user_logger):
+        result = self.runner.invoke(file_cli.file, [self.job_directory, 'get-path', '--exp-id', self.experiment.id])
+        self.assertEqual(result.exit_code, 0)
+        exp_dir = str(self.platform.get_directory_by_id(self.experiment.id, ItemType.EXPERIMENT))
+        mock_user_logger.info.assert_called_with(Path(exp_dir))
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_container_cli/test_get_detail.py

@@ -0,0 +1,60 @@
+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.core import ItemType
+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 TestContainerPlatformGetDetailCli(TestContainerPlatformCliBase):
+
+    @patch('rich.console.Console.print')
+    def test_get_details(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, ['get-detail', experiment.id])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn(f'"JOB_DIRECTORY": "{normalize_path(self.job_directory)}",',
+                      mock_console.call_args_list[0].args[0].text)
+        exp_dir = self.platform.get_directory_by_id(experiment.id, ItemType.EXPERIMENT)
+        self.assertIn(
+            f'"EXPERIMENT_DIR": "{normalize_path(exp_dir)}",',
+            mock_console.call_args_list[0].args[0].text)
+        self.assertIn(f'"EXPERIMENT_NAME": "run_command",',
+                      mock_console.call_args_list[0].args[0].text)
+        self.assertIn(f'"EXPERIMENT_ID": "{experiment.id}",',
+                      mock_console.call_args_list[0].args[0].text)
+        self.assertIn(f'"CONTAINER": "{self.platform.container_id}",',
+                      mock_console.call_args_list[0].args[0].text)
+        self.assertIn(f'"CREATED": ',
+                      mock_console.call_args_list[0].args[0].text)
+        # 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_get_detail_help(self):
+        result = self.runner.invoke(container_cli.container, ['get-detail', "--help"])
+        expected_help = ('Usage: container get-detail [OPTIONS] EXP_ID\n'
+                         '\n'
+                         '  Retrieve Experiment history.\n'
+                         '\n'
+                         '  Arguments:\n'
+                         '\n'
+                         '    EXP_ID: Experiment 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_history.py

@@ -0,0 +1,136 @@
+import os
+import re
+import sys
+import unittest
+from pathlib import Path
+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_container.utils.general import normalize_path
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from test_base import TestContainerPlatformCliBase
+from helper import cleaned_str
+
+
+@pytest.mark.serial
+@pytest.mark.cli
+class TestContainerPlatformHistoryCli(TestContainerPlatformCliBase):
+    @patch('rich.console.Console.print')
+    def test_history(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")
+        experiment.run(wait_until_done=False, platform=platform)
+        # test history
+        result = self.runner.invoke(container_cli.container, ['history'])
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual('There are 1 Experiment cache in history.', mock_console.call_args_list[0].args[0])
+        self.assertIn(normalize_path(f"{platform.job_directory}"),
+                      mock_console.call_args_list[2].args[0])
+        self.assertEqual('EXPERIMENT_NAME : run_command', cleaned_str(mock_console.call_args_list[3][0][0]))
+        self.assertEqual(f'EXPERIMENT_ID   : {experiment.id}', cleaned_str(mock_console.call_args_list[4][0][0]))
+        self.assertEqual(f'CONTAINER       : {platform.container_id}',
+                          cleaned_str(mock_console.call_args_list[5][0][0]))
+        match_created_time = re.match(r'^CREATED         : \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$',
+                                      cleaned_str(mock_console.call_args_list[6][0][0]))
+        self.assertTrue(match_created_time)
+        # Verify history path:
+        JOB_HISTORY_DIR = "idmtools_experiment_history"
+        history_path = Path.home().joinpath(".idmtools").joinpath(JOB_HISTORY_DIR)
+        self.assertTrue(history_path.is_dir())
+        self.assertTrue(any(history_path.iterdir()))  # verify history path has some files
+
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', platform.container_id, '--remove'])
+        self.assertEqual(result.exit_code, 0)
+
+    @patch('rich.console.Console.print')
+    def test_history_with_container(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)
+        platform = ContainerPlatform(job_directory=self.job_directory, new_container=True)
+        experiment = Experiment.from_task(task, name="run_command")
+        experiment.run(wait_until_done=False, platform=platform)
+        # test history
+        result = self.runner.invoke(container_cli.container, ['history', platform.container_id])
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual('There are 1 Experiment cache in history.', mock_console.call_args_list[0].args[0])
+        self.assertIn(normalize_path(f"{platform.job_directory}"),
+                      mock_console.call_args_list[2].args[0])
+        self.assertEqual('EXPERIMENT_NAME : run_command', cleaned_str(mock_console.call_args_list[3][0][0]))
+        self.assertEqual(f'EXPERIMENT_ID   : {experiment.id}', cleaned_str(mock_console.call_args_list[4][0][0]))
+        self.assertEqual(f'CONTAINER       : {platform.container_id}',
+                          cleaned_str(mock_console.call_args_list[5][0][0]))
+        match_created_time = re.match(r'^CREATED         : \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$',
+                                      cleaned_str(mock_console.call_args_list[6][0][0]))
+        self.assertTrue(match_created_time)
+
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', platform.container_id, '--remove'])
+        self.assertEqual(result.exit_code, 0)
+
+    @patch('rich.console.Console.print')
+    def test_history_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)
+        # test history
+        result = self.runner.invoke(container_cli.container, ['history', platform.container_id])
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual('There are 1 Experiment cache in history.', mock_console.call_args_list[0].args[0])
+        self.assertIn(normalize_path(f"{platform.job_directory}"),
+                      mock_console.call_args_list[2].args[0])
+        self.assertEqual(f'SUITE_NAME      : {suite.name}', cleaned_str(mock_console.call_args_list[3][0][0]))
+        self.assertEqual(f'SUITE_ID        : {suite.id}', cleaned_str(mock_console.call_args_list[4][0][0]))
+        self.assertEqual(f'EXPERIMENT_NAME : {experiment.name}', cleaned_str(mock_console.call_args_list[5][0][0]))
+        self.assertEqual(f'EXPERIMENT_ID   : {experiment.id}', cleaned_str(mock_console.call_args_list[6][0][0]))
+        self.assertEqual(f'CONTAINER       : {platform.container_id}',
+                          cleaned_str(mock_console.call_args_list[7][0][0]))
+        match_created_time = re.match(r'^CREATED         : \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$',
+                                      cleaned_str(mock_console.call_args_list[8][0][0]))
+        self.assertTrue(match_created_time)
+
+        # clean up container
+        result = self.runner.invoke(container_cli.container, ['stop-container', platform.container_id, '--remove'])
+        self.assertEqual(result.exit_code, 0)
+
+    def test_history_help(self):
+        result = self.runner.invoke(container_cli.container, ['history', "--help"])
+        expected_help = ('Usage: container history [OPTIONS] [CONTAINER_ID]\n'
+                         '\n'
+                         '  View the job history.\n'
+                         '\n'
+                         '  Arguments:\n'
+                         '\n'
+                         '    CONTAINER_ID: Container ID\n'
+                         '\n'
+                         'Options:\n'
+                         '  -l, --limit INTEGER  Max number of jobs 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()