tests: threat Framework as an internal Session object

Signed-off-by: Andrea Cervesato <andrea.cervesato@suse.com>

Author: acerv

libkirk/tests/conftest.py

@@ -3,16 +3,12 @@
 """
 
 import os
-from typing import Dict, List
 
 import pytest
 
 import libkirk
 import libkirk.com
-from libkirk.data import Suite, Test
-from libkirk.framework import Framework
-from libkirk.results import TestResults
-from libkirk.sut import SUT
+import libkirk.sut
 
 
 @pytest.fixture(scope="session")
@@ -42,170 +38,38 @@ def _discover_plugins():
     libkirk.sut.discover(os.path.join(currdir, ".."), extend=False)
 
 
-class DummyFramework(Framework):
+@pytest.fixture
+def ltpdir(tmpdir):
     """
-    A generic framework created for testing.
+    Setup the temporary folder with LTP tests.
     """
+    os.environ["LTPROOT"] = str(tmpdir)
 
-    def __init__(self) -> None:
-        self._root = None
-
-    def setup(self, **kwargs: Dict[str, str]) -> None:
-        self._root = kwargs.get("root", "/")
-        self._env = kwargs.get("env", None)
-
-    @property
-    def name(self) -> str:
-        return "dummy"
-
-    @property
-    def config_help(self) -> Dict[str, str]:
-        return {}
-
-    async def get_suites(self, sut: SUT) -> List[str]:
-        return ["suite01", "suite02", "sleep", "environ", "kernel_panic"]
-
-    async def find_command(self, sut: SUT, command: str) -> Test:
-        return Test(name=command, cmd=command)
-
-    async def find_suite(self, sut: SUT, name: str) -> Suite:
-        if name in "suite01":
-            test0 = Test(
-                name="test01",
-                cwd=self._root,
-                env=self._env,
-                cmd="echo",
-                args=["-n", "ciao0"],
-                parallelizable=False,
-            )
-
-            test1 = Test(
-                name="test02",
-                cwd=self._root,
-                env=self._env,
-                cmd="echo",
-                args=["-n", "ciao0"],
-                parallelizable=False,
-            )
-
-            return Suite(name, [test0, test1])
-        if name == "suite02":
-            test0 = Test(
-                name="test01",
-                cwd=self._root,
-                env=self._env,
-                cmd="echo",
-                args=["-n", "ciao0"],
-                parallelizable=False,
-            )
-
-            test1 = Test(
-                name="test02",
-                cwd=self._root,
-                env=self._env,
-                cmd="sleep",
-                args=["0.2", "&&", "echo", "-n", "ciao1"],
-                parallelizable=True,
-            )
-
-            return Suite(name, [test0, test1])
-        elif name == "sleep":
-            test0 = Test(
-                name="test01",
-                cwd=self._root,
-                env=self._env,
-                cmd="sleep",
-                args=["2"],
-                parallelizable=False,
-            )
-
-            test1 = Test(
-                name="test02",
-                cwd=self._root,
-                env=self._env,
-                cmd="sleep",
-                args=["2"],
-                parallelizable=False,
-            )
-
-            return Suite(name, [test0, test1])
-        elif name == "environ":
-            test0 = Test(
-                name="test01",
-                cwd=self._root,
-                env=self._env,
-                cmd="echo",
-                args=["-n", "$hello"],
-                parallelizable=False,
-            )
-
-            return Suite(name, [test0])
-        elif name == "kernel_panic":
-            test0 = Test(
-                name="test01",
-                cwd=self._root,
-                env=self._env,
-                cmd="echo",
-                args=["Kernel", "panic"],
-                parallelizable=False,
-            )
-
-            test1 = Test(
-                name="test01",
-                cwd=self._root,
-                env=self._env,
-                cmd="sleep",
-                args=["0.2"],
-                parallelizable=False,
-            )
-
-            return Suite(name, [test0, test1])
-
-        return None
-
-    async def read_result(
-        self, test: Test, stdout: str, retcode: int, exec_t: float
-    ) -> TestResults:
-        passed = 0
-        failed = 0
-        skipped = 0
-        broken = 0
-        skipped = 0
-        warnings = 0
-        error = retcode == -1
-
-        if retcode == 0:
-            passed = 1
-        elif retcode == 4:
-            warnings = 1
-        elif retcode == 32:
-            skipped = 1
-        elif not error:
-            failed = 1
-
-        if error:
-            broken = 1
-
-        result = TestResults(
-            test=test,
-            passed=passed,
-            failed=failed,
-            broken=broken,
-            skipped=skipped,
-            warnings=warnings,
-            exec_time=exec_t,
-            retcode=retcode,
-            stdout=stdout,
-        )
-
-        return result
+    tmpdir.mkdir("testcases").mkdir("bin")
+    runtest = tmpdir.mkdir("runtest")
 
+    suite01 = runtest / "suite01"
+    suite01.write_text(
+        "test01 echo -n ciao\ntest02 echo -n ciao\n",
+        encoding="utf-8")
 
-@pytest.fixture
-def dummy_framework():
-    """
-    A fummy framework implementation used for testing.
-    """
-    obj = DummyFramework()
-    obj.setup(root="/tmp")
-    yield obj
+    suite02 = runtest / "suite02"
+    suite02.write_text(
+        "test01 echo -n ciao\ntest02 sleep 0.2 && echo -n ciao",
+        encoding="utf-8")
+
+    sleep = runtest / "sleep"
+    sleep.write_text(
+        "sleep01 sleep 2\nsleep02 sleep 2",
+        encoding="utf-8")
+
+    environ = runtest / "environ"
+    environ.write_text("test01 echo -n $hello",
+        encoding="utf-8")
+
+    kernel_panic = runtest / "kernel_panic"
+    kernel_panic.write_text(
+        "test01 echo 'Kernel panic'\ntest02 sleep 0.2",
+        encoding="utf-8")
+
+    return tmpdir

libkirk/tests/test_ltp.py

@@ -35,20 +35,20 @@ async def sut(self):
         await obj.stop()
 
     @pytest.fixture
-    def framework(self, tmpdir):
+    def framework(self):
         """
         LTP framework object.
         """
         fw = LTPFramework()
-        fw.setup(root=str(tmpdir))
-
         yield fw
 
     @pytest.fixture(autouse=True)
     def prepare_tmpdir(self, tmpdir):
         """
         Prepare the temporary directory adding runtest folder.
         """
+        os.environ["LTPROOT"] = str(tmpdir)
+
         # create simple testing suites
         content = ""
         for i in range(self.TESTS_NUM):
@@ -83,13 +83,7 @@ def prepare_tmpdir(self, tmpdir):
         test_sh = testcases / "test.sh"
         test_sh.write("#!/bin/bash\necho $1 $2\n")
 
-    async def test_name(self, framework):
-        """
-        Test that name property is not empty.
-        """
-        assert framework.name == "ltp"
-
-    async def test_get_suites(self, framework, sut, tmpdir):
+    async def test_get_suites(self, framework, sut):
         """
         Test get_suites method.
         """
@@ -142,12 +136,11 @@ async def test_find_suite(self, framework, sut, tmpdir):
             assert "TMPDIR" in test.env
             assert "LTP_COLORIZE_OUTPUT" in test.env
 
-    async def test_find_suite_max_runtime(self, sut, tmpdir):
+    async def test_find_suite_max_runtime(self, sut):
         """
         Test find_suite method when max_runtime is defined.
         """
-        framework = LTPFramework()
-        framework.setup(root=str(tmpdir), max_runtime=5)
+        framework = LTPFramework(max_runtime=5)
 
         suite = await framework.find_suite(sut, "slow_suite")
         assert len(suite.tests) == 0