@tsplc/build 0.0.0-stage → 0.2.0

package/python/test_codesys_online.py

@@ -0,0 +1,184 @@
+import os
+import sys
+import tempfile
+import unittest
+from types import SimpleNamespace
+from unittest.mock import Mock, patch
+
+
+class TargetInvocationException(Exception):
+    def __init__(self, inner):
+        super().__init__('Exception has been thrown by the target of an invocation')
+        self.InnerException = inner
+
+
+# Only .NET imports are unavailable in CPython. The operation orchestrator and
+# compiler diagnostic gate below are the maintained code, not copied logic.
+with patch.dict(sys.modules, {
+    'System': SimpleNamespace(Activator=None, AppDomain=None, Array=None, Object=None,
+                              Enum=SimpleNamespace(Parse=lambda kind, value: value),
+                              Environment=SimpleNamespace(ProcessorCount=2)),
+    'System.Net': SimpleNamespace(Dns=SimpleNamespace(GetHostAddresses=lambda host: ['127.0.0.1']),
+                                  IPAddress=SimpleNamespace(Parse=lambda address: address)),
+    'System.Reflection': SimpleNamespace(BindingFlags=None, TargetInvocationException=TargetInvocationException),
+}):
+    import codesys_online
+
+
+class OnlineLifecycleTests(unittest.TestCase):
+    def setUp(self):
+        self.events = []
+        self.messages = []
+        self.ids = {'codeId': 'downloaded-code', 'dataId': 'downloaded-data'}
+        self.app = SimpleNamespace(
+            guid='application-guid', parent=SimpleNamespace(is_device=True),
+            get_children=lambda: [], get_name=lambda: 'Application',
+            is_uptodate=False, is_online_change_possible=True,
+        )
+        self.app.parent.set_gateway_and_ip_address = Mock()
+        self.project = SimpleNamespace(active_application=self.app, save=Mock(), close=Mock())
+        self.source_imported = False
+        self.wrapper = None
+        self.core = SimpleNamespace(Logout=Mock(), Login=Mock(return_value=True),
+                                    CreateBootProject=Mock(), Download=Mock())
+        self.boot_method = Mock()
+        self.boot_method.Invoke.side_effect = lambda core, args: core.CreateBootProject()
+        self.boot_api = SimpleNamespace(GetMethod=Mock(return_value=self.boot_method))
+
+        def clean():
+            self.events.append('clean')
+        def compile_source():
+            self.assertTrue(self.source_imported)
+            self.events.append('compile')
+        self.app.clean = Mock(side_effect=clean)
+        self.app.rebuild = Mock(side_effect=compile_source)
+        self.app.build = Mock(side_effect=compile_source)
+        self.app.generate_code = Mock(side_effect=lambda: self.events.append('generate'))
+
+        def wrapper(application):
+            self.events.append('online-wrapper')
+            self.wrapper = SimpleNamespace(
+                login=Mock(), start=Mock(), logout=Mock(), Dispose=Mock(),
+                read_value=Mock(return_value='42'),
+            )
+            return self.wrapper
+        self.engine = SimpleNamespace(
+            projects=SimpleNamespace(open=Mock(return_value=self.project)),
+            online=SimpleNamespace(
+                gateways=SimpleNamespace(add_new_gateway=Mock(return_value=SimpleNamespace(guid='gateway'))),
+                create_online_device=Mock(return_value=SimpleNamespace(Dispose=Mock())),
+                create_online_application=Mock(side_effect=wrapper),
+            ),
+            OnlineChangeOption=SimpleNamespace(Never='Never'),
+            Severity=SimpleNamespace(Error=1, FatalError=2),
+            system=SimpleNamespace(
+                get_message_categories=lambda: ['compiler'],
+                clear_messages=lambda category: self.messages.clear(),
+                get_message_objects=lambda category, severity: self.messages,
+            ),
+        )
+        def imported(*args):
+            self.events.append('import')
+            self.source_imported = True
+        replacements = {
+            'apply_controller': Mock(side_effect=lambda *args: self.events.append('controller')),
+            'import_objects': Mock(side_effect=imported),
+            'core_application': Mock(return_value=self.core),
+            'session_login': Mock(),
+            'controller_ids': Mock(return_value=self.ids),
+            'controller_state': Mock(return_value='run'),
+            'require_current_boot_project': Mock(),
+            'load_downloaded_reference': Mock(return_value=self.ids),
+            'reconcile': Mock(),
+            'generate_online_code': Mock(),
+            'consolidated_manager': Mock(return_value=SimpleNamespace(GetCompileContext=Mock())),
+            'context_ids': Mock(return_value=self.ids),
+            'loaded_type': Mock(side_effect=lambda name:
+                                self.boot_api if name == '_3S.CoDeSys.Core.Online.IOnlineApplication3' else None),
+        }
+        patcher = patch.multiple(codesys_online, **replacements)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.request = {
+            'project': 'Application.project', 'operation': 'download', 'symbols': False,
+            'objects': [], 'removeObjects': ['Visualization Manager'],
+            'online': {'gateway': {'host': 'gateway', 'port': 1217},
+                       'device': {'host': 'plc', 'port': 11740}},
+        }
+
+    def test_download_rebuilds_imported_tree_before_online_login(self):
+        result = codesys_online.run_online(self.engine, self.request)
+        self.assertEqual(self.events, ['import', 'clean', 'compile', 'generate', 'online-wrapper'])
+        self.assertEqual(result['controllerIds'], self.ids)
+        self.core.CreateBootProject.assert_called_once()
+        self.boot_api.GetMethod.assert_called_once_with('CreateBootProject')
+        self.boot_method.Invoke.assert_called_once_with(self.core, None)
+        self.project.close.assert_called_once()
+        self.app.build.assert_not_called()
+
+    def test_download_switches_the_template_controller_before_importing(self):
+        self.request['controller'] = {'type': 4102, 'id': '0000 0005', 'version': '4.22.0.0'}
+        codesys_online.run_online(self.engine, self.request)
+        self.assertEqual(self.events[:2], ['controller', 'import'])
+
+    def test_invalid_full_download_source_never_creates_online_wrapper_or_transfers(self):
+        self.app.rebuild.side_effect = RuntimeError('Invalid source declaration')
+        with self.assertRaisesRegex(RuntimeError, 'Invalid source declaration'):
+            codesys_online.run_online(self.engine, self.request)
+        self.engine.online.create_online_application.assert_not_called()
+        self.core.CreateBootProject.assert_not_called()
+        self.project.close.assert_called_once()
+
+    def test_online_change_keeps_the_downloaded_reference_and_builds_incrementally(self):
+        # The downloaded project already carries the controller.
+        self.request.update(operation='online-change', controller={
+            'type': 4102, 'id': '0000 0005', 'version': '4.22.0.0',
+        }, baseline={
+            'applicationGuid': self.app.guid, 'controllerIds': self.ids, 'objects': [],
+        })
+        result = codesys_online.run_online(self.engine, self.request)
+        self.assertEqual(self.events, ['online-wrapper', 'import', 'compile'])
+        self.app.clean.assert_not_called()
+        self.app.rebuild.assert_not_called()
+        self.app.generate_code.assert_not_called()
+        self.core.Download.assert_called_once_with(True, 'UseProjectSetting')
+        self.assertEqual(result['state'], 'run')
+
+    def test_full_download_rejects_library_errors_reported_after_transfer(self):
+        def report_library_error(core):
+            self.messages.append(SimpleNamespace(text="Could not open library '#VisuShared'."))
+        codesys_online.session_login.side_effect = report_library_error
+        with self.assertRaisesRegex(RuntimeError, "Could not open library '#VisuShared'"):
+            codesys_online.run_online(self.engine, self.request)
+        self.core.CreateBootProject.assert_called_once()
+        self.project.close.assert_called_once()
+
+    def test_full_download_reports_device_placeholders_a_login_cannot_resolve(self):
+        def report_unresolved_placeholder(core):
+            self.messages.append(SimpleNamespace(text="Could not open library '#System_VisuInputs'. "
+                                                 "(Reason: The placeholder library 'System_VisuInputs' could not be resolved.)"))
+        codesys_online.session_login.side_effect = report_unresolved_placeholder
+        with tempfile.TemporaryDirectory() as directory:
+            self.request['progress'] = os.path.join(directory, 'progress.log')
+            result = codesys_online.run_online(self.engine, self.request)
+            with open(self.request['progress']) as log:
+                self.assertIn('nothing resolves: #System_VisuInputs', log.read())
+        self.assertEqual(result['state'], 'run')
+
+    def test_boot_failure_preserves_vendor_clr_stack_and_never_confirms_completion(self):
+        stack = ('System.ArgumentException: The path is not of a legal form.\n'
+                 '   at System.IO.Path.GetFullPath(String path)\n'
+                 '   at Vendor.BootProvider.PrepareTransfer()')
+        self.core.CreateBootProject.side_effect = TargetInvocationException(
+            SimpleNamespace(ToString=lambda: stack))
+        with self.assertRaises(RuntimeError) as failure:
+            codesys_online.run_online(self.engine, self.request)
+        self.assertEqual(str(failure.exception), 'Controller boot project creation failed:\n' + stack)
+        self.core.CreateBootProject.assert_called_once()
+        codesys_online.require_current_boot_project.assert_not_called()
+        codesys_online.session_login.assert_not_called()
+        self.project.close.assert_called_once()
+
+
+if __name__ == '__main__':
+    unittest.main()

package/python/test_installer_packages.py

@@ -0,0 +1,216 @@
+"""Exercise the installer's extraction against the pinned MSI package inventory."""
+import csv
+import io
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import unittest
+import zipfile
+from pathlib import Path
+
+
+installer = (Path(__file__).parent.parent / 'docker' / 'install' / 'install.sh').read_text()
+marker = 'python3 - "$msi" "$work/setup-files.tsv" "$WINEPREFIX/drive_c" <<\'PY\'\n'
+extractor = installer.split(marker, 1)[1].split('\nPY\n', 1)[0]
+
+# These identities are from the SP22 Patch 3 MSI's ISSetupFile table.
+packages = {
+    'CODESYS Scripting 4.2.0.0': 'scripting',
+    'CODESYS RISC Front End 4.0.2.0': 'risc',
+    'CODESYS Code Generator ARM64 4.0.1.0': 'arm64',
+    'CODESYS Library Dependency Inspection 1.1.0.0': 'library-inspection',
+    'CODESYS Base Libraries 4.0.1.0': 'base-libraries',
+    'CODESYS Visualization Support 4.7.0.0': 'visualization-support',
+    'CODESYS Math Libraries 4.0.0.0': 'math-libraries',
+    'CODESYS Recipes 4.7.0.0': 'recipes',
+    'CODESYS Trace 4.4.0.0': 'trace',
+    'CODESYS Communication 4.8.0.0': 'communication',
+    'CODESYS Visualization 4.10.0.0': 'visualization',
+    'CODESYS Ethernet Adapter 4.2.0.0': 'ethernet-adapter',
+    'CODESYS EDS Import 4.3.0.0': 'eds-import',
+    'CODESYS NetX 4.1.0.0': 'netx',
+    'CODESYS EtherNetIP 4.9.1.0': 'ethernetip',
+    'CODESYS SoftMotion 4.20.2.0': 'softmotion',
+}
+
+
+class InstallerPackageTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(temporary.cleanup)
+        self.root = Path(temporary.name)
+        self.output = self.root / 'output'
+        self.output.mkdir()
+        self.table = self.root / 'setup-files.tsv'
+        self.rows = []
+        for name, output in packages.items():
+            stream = 'ISSetupFile.' + output
+            self.rows.append({'FileName': 'Packages\\' + name + '.package', 'Stream': stream})
+            with zipfile.ZipFile(self.root / stream, 'w') as archive:
+                archive.writestr('package.manifest', '<Package/>')
+        tool = self.root / 'msiinfo'
+        tool.write_text(
+            '#!' + sys.executable + '\n'
+            'import pathlib, sys\n'
+            'sys.stdout.buffer.write((pathlib.Path(sys.argv[2]) / sys.argv[3]).read_bytes())\n'
+        )
+        tool.chmod(0o755)
+
+    def extract(self):
+        with self.table.open('w', newline='') as output:
+            writer = csv.DictWriter(output, ['FileName', 'Stream'], delimiter='\t')
+            writer.writeheader()
+            writer.writerows(self.rows)
+        return subprocess.run(
+            [sys.executable, '-c', extractor, str(self.root), str(self.table), str(self.output)],
+            env={**os.environ, 'PATH': str(self.root) + os.pathsep + os.environ['PATH']},
+            capture_output=True,
+            text=True,
+        )
+
+    def test_extracts_complete_symbol_publishing_dependencies_in_installable_order(self):
+        result = self.extract()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(
+            {path.stem for path in self.output.iterdir()},
+            set(packages.values()),
+        )
+        # Component selection must preserve the original vendor archive bytes.
+        for name in packages.values():
+            self.assertEqual(
+                (self.output / (name + '.package')).read_bytes(),
+                (self.root / ('ISSetupFile.' + name)).read_bytes(),
+            )
+        order = re.search(r'for package in (.+); do', installer).group(1).split()
+        self.assertEqual(set(order), set(packages.values()))
+        self.assertLess(order.index('library-inspection'), order.index('math-libraries'))
+        for prerequisite in (
+            'visualization-support', 'trace', 'recipes', 'communication',
+            'base-libraries', 'math-libraries',
+        ):
+            self.assertLess(order.index(prerequisite), order.index('visualization'))
+
+    def test_visualization_uses_official_headless_components(self):
+        self.assertIn('set "packageComponents="', installer)
+        self.assertIn(
+            'if "%~1"=="visualization" set "packageComponents=--components=2;3;4"',
+            installer,
+        )
+        self.assertIn('"C:\\%~1.package" %packageComponents%', installer)
+
+    def test_rejects_missing_visualization_prerequisite_before_package_installation(self):
+        self.rows = [row for row in self.rows if row['Stream'] != 'ISSetupFile.trace']
+        result = self.extract()
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn('Missing bundled packages: Packages\\CODESYS Trace 4.4.0.0.package', result.stderr)
+
+    def test_rejects_corrupt_embedded_package_data(self):
+        archive = io.BytesIO()
+        with zipfile.ZipFile(archive, 'w') as package:
+            package.writestr('package.manifest', 'unchanged manifest')
+        corrupted = archive.getvalue().replace(b'unchanged manifest', b'corrupted manifest', 1)
+        (self.root / 'ISSetupFile.visualization').write_bytes(corrupted)
+        result = self.extract()
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn('Corrupt package: Packages\\CODESYS Visualization 4.10.0.0.package', result.stderr)
+
+    def test_generated_package_command_captures_windows_status_before_printing(self):
+        prefix = self.output / 'drive_c'
+        prefix.mkdir()
+        start = installer.index("printf '%s\\r\\n' '@echo off'")
+        end = installer.index('# Symbol publishing', start)
+        result = subprocess.run(
+            ['sh', '-eu', '-c', installer[start:end]],
+            env={**os.environ, 'WINEPREFIX': str(self.output)},
+            capture_output=True, text=True,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        command = (prefix / 'install-package.cmd').read_bytes().decode().splitlines()
+        call = next(index for index, line in enumerate(command) if line.startswith('PackageManagerCLI.exe '))
+        self.assertEqual(command[call + 1], 'set "packageStatus=%errorlevel%"')
+        self.assertEqual(command[call + 2],
+            'if not "%packageStatus%"=="0" echo PackageManagerCLI Windows exit status: %packageStatus%')
+        self.assertEqual(command[call + 3], 'exit /b %packageStatus%')
+
+    def run_package_loop(self, failed_package, log_bytes='Finalizing the original package'.encode('utf-16'), failed_logger=False):
+        prefix = self.output / 'drive_c'
+        prefix.mkdir()
+        log = prefix / 'package-install.log'
+        if log_bytes is None:
+            log.mkdir()  # A path that exists but cannot be read as a log file.
+        else:
+            log.write_bytes(log_bytes)
+        calls = self.root / 'calls.jsonl'
+        tool = self.root / 'timeout'
+        tool.write_text(
+            '#!' + sys.executable + '\n'
+            'import json, os, pathlib, shlex, sys\n'
+            'command = sys.argv[sys.argv.index("-c") + 1]\n'
+            'package = shlex.split(command)[-1]\n'
+            'debug = os.environ.get("WINEDEBUG", "")\n'
+            'with pathlib.Path(os.environ["INSTALLER_TEST_CALLS"]).open("a") as out:\n'
+            ' out.write(json.dumps({"package": package, "debug": debug}) + "\\n")\n'
+            'if package == os.environ["INSTALLER_TEST_FAILURE"]:\n'
+            ' if "err+seh" in debug: print("fixture err:seh:NtRaiseException Unhandled exception code c0000005", file=sys.stderr)\n'
+            ' sys.exit(5)\n'
+        )
+        tool.chmod(0o755)
+        if failed_logger:
+            logger = self.root / 'python3'
+            logger.write_text('#!/bin/sh\necho "Fixture log helper failed" >&2\nexit 19\n')
+            logger.chmod(0o755)
+        start = installer.index('for package in ')
+        end = installer.index('\ndone\n', start) + len('\ndone\n')
+        # Exercise the real shell failure/logging loop with a controlled process result.
+        script = installer[:installer.index('work=/tmp/codesys-setup')] + installer[start:end]
+        result = subprocess.run(
+            ['sh', '-c', script],
+            env={**os.environ, 'WINEPREFIX': str(self.output), 'WINEDEBUG': '-all',
+                'PATH': str(self.root) + os.pathsep + os.environ['PATH'],
+                'INSTALLER_TEST_CALLS': str(calls), 'INSTALLER_TEST_FAILURE': failed_package},
+            capture_output=True, text=True,
+        )
+        return result, [json.loads(line) for line in calls.read_text().splitlines()]
+
+    def test_package_failure_keeps_exit_status_and_fatal_diagnostics_without_continuing(self):
+        result, calls = self.run_package_loop('visualization-support')
+        self.assertEqual(result.returncode, 5)
+        self.assertIn('Unhandled exception code c0000005', result.stderr)
+        self.assertIn('Package visualization-support installer exited with status 5', result.stdout)
+        self.assertIn('Finalizing the original package', result.stdout)
+        self.assertEqual(calls[-1]['package'], 'visualization-support')
+        self.assertNotIn('Installed visualization-support package', result.stdout)
+        self.assertTrue(all(call['debug'] == '-all,err+seh' for call in calls))
+
+    def test_successful_package_loop_remains_successful(self):
+        result, calls = self.run_package_loop('')
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual({call['package'] for call in calls}, set(packages.values()))
+        self.assertEqual(result.stdout.count('Installed '), len(packages))
+        self.assertEqual(result.stderr, '')
+
+    def test_truncated_utf16_log_never_masks_package_failure(self):
+        result, calls = self.run_package_loop('visualization-support', b'\xff\xfe\x00')
+        self.assertEqual(result.returncode, 5)
+        self.assertIn('Package visualization-support installer exited with status 5', result.stdout)
+        self.assertNotIn('UnicodeDecodeError', result.stderr)
+        self.assertEqual(calls[-1]['package'], 'visualization-support')
+
+    def test_unreadable_package_log_never_masks_package_failure(self):
+        result, calls = self.run_package_loop('visualization-support', None)
+        self.assertEqual(result.returncode, 5)
+        self.assertIn('Could not read package install log', result.stderr)
+        self.assertEqual(calls[-1]['package'], 'visualization-support')
+
+    def test_failed_log_helper_never_masks_package_failure(self):
+        result, calls = self.run_package_loop('visualization-support', failed_logger=True)
+        self.assertEqual(result.returncode, 5)
+        self.assertIn('Fixture log helper failed', result.stderr)
+        self.assertEqual(calls[-1]['package'], 'visualization-support')
+
+
+if __name__ == '__main__':
+    unittest.main()