Check opis on GHA

Author: Tom-Willemsen

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/workflows/lint.yml

@@ -1,6 +1,56 @@
 name: lint
 on: [pull_request]
 jobs:
+  check-opi-format:
+    runs-on: "windows-latest"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: OPI checker dependencies
+        run: python -m pip install -r base/uk.ac.stfc.isis.ibex.opis/requirements.txt
+      - name: Run OPI checker
+        run: python base/uk.ac.stfc.isis.ibex.opis/check_opi_format.py -strict -directory base/uk.ac.stfc.isis.ibex.opis
+      - name: Validate OPIs
+        run: python base/uk.ac.stfc.isis.ibex.opis/validate_opis.py
+
+  check-build:
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Run check_build
+        working-directory: ./build
+        run: python check_build.py ../base
+        
+  scriptgenerator-tests:
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install dependencies
+        run: python -m pip install -r ./base/uk.ac.stfc.isis.ibex.scriptgenerator/python_support/requirements.txt
+      - name: Run scriptgenerator tests
+        working-directory: ./base/uk.ac.stfc.isis.ibex.scriptgenerator/python_support
+        run: python -m unittest discover
+        
+  checkstyle:
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '21'
+      - name: checkstyle
+        working-directory: ./base/uk.ac.stfc.isis.ibex.client.tycho.parent
+        run: mvn checkstyle:check
+  
   code-ql:
     strategy:
       matrix:

base/uk.ac.stfc.isis.ibex.opis/requirements.txt

@@ -0,0 +1,4 @@
+lxml
+pyhamcrest
+pywin32
+xmlrunner

base/uk.ac.stfc.isis.ibex.scriptgenerator/python_support/requirements.txt

@@ -0,0 +1,4 @@
+genie
+gitpython
+py4j
+pyhamcrest

base/uk.ac.stfc.isis.ibex.scriptgenerator/python_support/test_generator.py

@@ -1,73 +1,94 @@
 import unittest
-from mock import MagicMock
-from script_definition_loader import Generator, ScriptDefinitionWrapper
-from typing import Dict, AnyStr, List
+from typing import AnyStr, Dict, List
+from unittest.mock import MagicMock
+
 from hamcrest.core import assert_that, equal_to
-from hamcrest.library.text import matches_regexp
+from script_definition_loader import Generator, ScriptDefinitionWrapper
 from test_script_definitions.valid_script_definition import DoRun as ValidDoRun
-from pprint import pprint
-import pathlib
 
 
 class TestGenerator(unittest.TestCase):
-
-    def _get_estimates_for_single_action(self, scriptDefinition):
-        wrapper = ScriptDefinitionWrapper("test", scriptDefinition)
-        estimates: Dict[int, int] = self.generator.estimateTime([
-            {"param1": "param1Val", "param2": "param2Val"}
-        ], wrapper, {})
+    def _get_estimates_for_single_action(self, script_definition):
+        wrapper = ScriptDefinitionWrapper("test", script_definition)
+        estimates: Dict[int, int] = self.generator.estimateTime(
+            [{"param1": "param1Val", "param2": "param2Val"}], wrapper, {}
+        )
         return estimates
 
     def setUp(self):
         self.generator: Generator = Generator(repo_path="test_script_definitions")
 
     def test_GIVEN_script_definitions_return_invalid_WHEN_get_generator_invalidity_reasons_THEN_context_as_expected(
-            self):
+        self,
+    ):
         # Arrange
         mock_script_definition: ScriptDefinitionWrapper = MagicMock()
         mock_script_definition.parametersValid.return_value = "invalid reason"
-        validityCheck: List[Dict[int, AnyStr]] = self.generator.getValidityErrors({}, [
-            {"param1": "param1Val", "param2": "param2Val"},
-            {"param1": "param1Val", "param2": "param2Val"}
-        ], mock_script_definition)
+        validity_check: List[Dict[int, AnyStr]] = self.generator.getValidityErrors(
+            {},
+            [
+                {"param1": "param1Val", "param2": "param2Val"},
+                {"param1": "param1Val", "param2": "param2Val"},
+            ],
+            mock_script_definition,
+        )
         # Act and Assert
-        assert_that(validityCheck, equal_to([{}, {0: "invalid reason", 1: "invalid reason"}]),
-                    "2 actions, both invalid with reason")
+        assert_that(
+            validity_check,
+            equal_to([{}, {0: "invalid reason", 1: "invalid reason"}]),
+            "2 actions, both invalid with reason",
+        )
 
     def test_GIVEN_script_definitions_return_invalid_WHEN_get_generator_invalidity_reasons_with_global_THEN_context_as_expected(
-            self):
+        self,
+    ):
         # Arrange
         mock_script_definition: ScriptDefinitionWrapper = MagicMock()
         mock_script_definition.parametersValid.return_value = "invalid reason"
         mock_script_definition.globalParamsValid.return_value = "invalid reason"
-        validityCheck: List[Dict[int, AnyStr]] = self.generator.getValidityErrors({"global1": "global1Val"}, [
-            {"param1": "param1Val", "param2": "param2Val"},
-            {"param1": "param1Val", "param2": "param2Val"}
-        ], mock_script_definition)
+        validity_check: List[Dict[int, AnyStr]] = self.generator.getValidityErrors(
+            {"global1": "global1Val"},
+            [
+                {"param1": "param1Val", "param2": "param2Val"},
+                {"param1": "param1Val", "param2": "param2Val"},
+            ],
+            mock_script_definition,
+        )
         # Act and Assert
-        assert_that(validityCheck, equal_to([{0: 'invalid reason'}, {0: "invalid reason", 1: "invalid reason"}]),
-                    "1 global, 2 actions, all invalid with reason")
-
-    def test_GIVEN_script_definition_return_valid_WHEN_get_generator_invalidity_reasons_THEN_no_content(self):
+        assert_that(
+            validity_check,
+            equal_to([{0: "invalid reason"}, {0: "invalid reason", 1: "invalid reason"}]),
+            "1 global, 2 actions, all invalid with reason",
+        )
+
+    def test_GIVEN_script_definition_return_valid_WHEN_get_generator_invalidity_reasons_THEN_no_content(
+        self,
+    ):
         # Arrange
         mock_script_definition: ScriptDefinitionWrapper = MagicMock()
         mock_script_definition.parametersValid.return_value = None
-        validityCheck: List[Dict[int, AnyStr]] = self.generator.getValidityErrors({}, [
-            {"param1": "param1Val", "param2": "param2Val"},
-            {"param1": "param1Val", "param2": "param2Val"}
-        ], mock_script_definition)
+        validity_check: List[Dict[int, AnyStr]] = self.generator.getValidityErrors(
+            {},
+            [
+                {"param1": "param1Val", "param2": "param2Val"},
+                {"param1": "param1Val", "param2": "param2Val"},
+            ],
+            mock_script_definition,
+        )
         # Act and Assert
-        assert_that(validityCheck, equal_to([{}, {}]), "2 actions, both valid")
+        assert_that(validity_check, equal_to([{}, {}]), "2 actions, both valid")
 
-    def test_GIVEN_script_definition_return_valid_WHEN_get_generator_global_invalidity_reasons_THEN_no_content(self):
+    def test_GIVEN_script_definition_return_valid_WHEN_get_generator_global_invalidity_reasons_THEN_no_content(
+        self,
+    ):
         # Arrange
         mock_script_definition: ScriptDefinitionWrapper = MagicMock()
         mock_script_definition.globalParamsValid.return_value = None
-        validityCheck: List[Dict[int, AnyStr]] = self.generator.getValidityErrors(
-            {"param1": "param1Val", "param2": "param2Val"}, [],
-            mock_script_definition)
+        validity_check: List[Dict[int, AnyStr]] = self.generator.getValidityErrors(
+            {"param1": "param1Val", "param2": "param2Val"}, [], mock_script_definition
+        )
         # Act and Assert
-        assert_that(validityCheck, equal_to([{}, {}]), "2 globals, both valid")
+        assert_that(validity_check, equal_to([{}, {}]), "2 globals, both valid")
 
     # Allows us to return whether invalid or not based on passed vals
     def params_valid_side_effect(self, params, global_params) -> AnyStr:
@@ -77,39 +98,46 @@ def params_valid_side_effect(self, params, global_params) -> AnyStr:
             return "invalid"
 
     def test_GIVEN_script_definition_return_valid_and_invalid_WHEN_get_generator_invalidity_reasons_THEN_content_as_expected(
-            self):
+        self,
+    ):
         # Arrange
         mock_script_definition: ScriptDefinitionWrapper = MagicMock()
         mock_script_definition.parametersValid.side_effect = self.params_valid_side_effect
-        validityCheck: List[Dict[int, AnyStr]] = self.generator.getValidityErrors({}, [
-            {"param1": "param1Val"}, {"param2": "param2Val"}
-        ], mock_script_definition)
+        validity_check: List[Dict[int, AnyStr]] = self.generator.getValidityErrors(
+            {}, [{"param1": "param1Val"}, {"param2": "param2Val"}], mock_script_definition
+        )
         # Act and Assert
-        assert_that(validityCheck, equal_to([{}, {1: "invalid"}]), "2 actions, one invalid with reason")
+        assert_that(
+            validity_check, equal_to([{}, {1: "invalid"}]), "2 actions, one invalid with reason"
+        )
 
     def test_GIVEN_valid_parameters_and_int_estimate_WHEN_estimate_time_THEN_return_estimate(self):
         # Arrange
-        mock_script_definition: ScriptDefinition = MagicMock()
+        mock_script_definition = MagicMock()
         mock_script_definition.parameters_valid.return_value = None
         mock_script_definition.estimate_time.return_value = 2
         estimates = self._get_estimates_for_single_action(mock_script_definition)
 
         # Act and Assert
         assert_that(estimates, equal_to({0: 2}))
 
-    def test_GIVEN_valid_parameters_and_float_estimate_WHEN_estimate_time_THEN_round_estimate_and_return_it(self):
+    def test_GIVEN_valid_parameters_and_float_estimate_WHEN_estimate_time_THEN_round_estimate_and_return_it(
+        self,
+    ):
         # Arrange
-        mock_script_definition: ScriptDefinition = MagicMock()
+        mock_script_definition = MagicMock()
         mock_script_definition.parameters_valid.return_value = None
         mock_script_definition.estimate_time.return_value = 2.0
         estimates = self._get_estimates_for_single_action(mock_script_definition)
 
         # Act and Assert
         assert_that(estimates, equal_to({0: 2}))
 
-    def test_GIVEN_valid_parameters_and_string_estimate_WHEN_estimate_time_THEN_return_empty_dict(self):
+    def test_GIVEN_valid_parameters_and_string_estimate_WHEN_estimate_time_THEN_return_empty_dict(
+        self,
+    ):
         # Arrange
-        mock_script_definition: ScriptDefinition = MagicMock()
+        mock_script_definition = MagicMock()
         mock_script_definition.parameters_valid.return_value = None
         mock_script_definition.estimate_time.return_value = "wrong type"
         estimates = self._get_estimates_for_single_action(mock_script_definition)
@@ -119,17 +147,19 @@ def test_GIVEN_valid_parameters_and_string_estimate_WHEN_estimate_time_THEN_retu
 
     def test_GIVEN_valid_parameters_and_no_estimate_WHEN_estimate_time_THEN_return_empty_dict(self):
         # Arrange
-        mock_script_definition: ScriptDefinition = MagicMock()
+        mock_script_definition = MagicMock()
         mock_script_definition.parameters_valid.return_value = None
         mock_script_definition.estimate_time.return_value = None
         estimates = self._get_estimates_for_single_action(mock_script_definition)
 
         # Act and Assert
         assert_that(estimates, equal_to({}))
 
-    def test_GIVEN_invalid_parameters_and_int_estimate_WHEN_estimate_time_THEN_return_empty_dict(self):
+    def test_GIVEN_invalid_parameters_and_int_estimate_WHEN_estimate_time_THEN_return_empty_dict(
+        self,
+    ):
         # Arrange
-        mock_script_definition: ScriptDefinition = MagicMock()
+        mock_script_definition = MagicMock()
         mock_script_definition.parameters_valid.return_value = "some error"
         mock_script_definition.estimate_time.return_value = 2
         estimates = self._get_estimates_for_single_action(mock_script_definition)
@@ -139,8 +169,7 @@ def test_GIVEN_invalid_parameters_and_int_estimate_WHEN_estimate_time_THEN_retur
 
     def test_GIVEN_valid_script_definition_WHEN_generate_THEN_new_script_is_as_expected(self):
         # Arrange
-        expected_script_lines: List[AnyStr] = \
-            """# pylint: skip-file
+        expected_script_lines: List[AnyStr] = """# pylint: skip-file
 
 from genie_python import genie as g
 
@@ -187,27 +216,39 @@ def runscript():
 
 value = b'789c030000000001'""".split("\n")
         params = [{"param1": "1", "param2": "2"}, {"param1": "1", "param2": "2"}]
-        script_definition: ScriptDefinitionWrapper = ScriptDefinitionWrapper(name="valid_script_definition",
-                                                                             script_definition=ValidDoRun())
+        script_definition: ScriptDefinitionWrapper = ScriptDefinitionWrapper(
+            name="valid_script_definition", script_definition=ValidDoRun()
+        )
         # Act
         generated_script: str = self.generator.generate(params, "", {}, script_definition)
         # Assert
-        self.assertIsNotNone(generated_script, "ScriptDefinitionWrapper is valid, so should not return None")
+        self.assertIsNotNone(
+            generated_script, "ScriptDefinitionWrapper is valid, so should not return None"
+        )
 
         generated_lines = generated_script.split("\n")
-        assert_that(len(generated_lines), equal_to(len(expected_script_lines)),
-                    "Should have the same amount of lines if they match")
+        assert_that(
+            len(generated_lines),
+            equal_to(len(expected_script_lines)),
+            "Should have the same amount of lines if they match",
+        )
 
         for i in range(len(generated_lines)):
-            assert_that(generated_lines[i], equal_to(expected_script_lines[i]),
-                        "Each line of the generated script should match the expected line")
+            assert_that(
+                generated_lines[i],
+                equal_to(expected_script_lines[i]),
+                "Each line of the generated script should match the expected line",
+            )
 
     def test_GIVEN_invalid_script_definition_params_WHEN_generate_THEN_return_none(self):
         # Arrange
         params = [{"param1": "invalid", "param2": "2"}, {"param1": "1", "param2": "2"}]
-        script_definition: ScriptDefinitionWrapper = ScriptDefinitionWrapper(name="valid_script_definition",
-                                                                             script_definition=ValidDoRun())
+        script_definition: ScriptDefinitionWrapper = ScriptDefinitionWrapper(
+            name="valid_script_definition", script_definition=ValidDoRun()
+        )
         # Act
         generated_script: str = self.generator.generate(params, "", {}, script_definition)
         # Assert
-        self.assertIsNone(generated_script, "ScriptDefinitionWrapper is invalid, so should return None")
+        self.assertIsNone(
+            generated_script, "ScriptDefinitionWrapper is invalid, so should return None"
+        )