Simulate testing

.github/workflows/app-test-build-deploy.yaml

@@ -318,28 +318,19 @@ jobs:
         if: startsWith(matrix.os, 'windows') && contains(needs.determine-build-type.outputs.type, 'release')
         shell: cmd
         env:
-          SM_HOST: ${{ secrets.SM_HOST_V2 }}
+          SM_HOST: ${{ secrets.SM_HOST }}
           SM_CLIENT_CERT_FILE: "D:\\Certificate_pkcs12.p12"
-          SM_CLIENT_CERT_PASSWORD: ${{secrets.SM_CLIENT_CERT_PASSWORD_V2}}
-          SM_API_KEY: ${{secrets.SM_API_KEY_V2}}
+          SM_CLIENT_CERT_PASSWORD: ${{secrets.SM_CLIENT_CERT_PASSWORD}}
+          SM_API_KEY: ${{secrets.SM_API_KEY}}
         run: |
-          curl -X GET  https://one.digicert.com/signingmanager/api-ui/v1/releases/Keylockertools-windows-x64.msi/download -H "x-api-key:${{secrets.SM_API_KEY_V2}}" -o Keylockertools-windows-x64.msi
+          curl -X GET  https://one.digicert.com/signingmanager/api-ui/v1/releases/Keylockertools-windows-x64.msi/download -H "x-api-key:${{secrets.SM_API_KEY}}" -o Keylockertools-windows-x64.msi
           msiexec /i Keylockertools-windows-x64.msi /quiet /qn
           smksp_registrar.exe list
           smctl.exe keypair ls
           C:\Windows\System32\certutil.exe -csp "DigiCert Signing Manager KSP" -key -user
           smksp_cert_sync.exe
           smctl.exe healthcheck --all
 
-      # Do the frontend dist bundle
-      - name: 'bundle ${{matrix.variant}} frontend'
-        env:
-          OT_APP_MIXPANEL_ID: ${{ secrets.OT_APP_MIXPANEL_ID }}
-          OT_APP_INTERCOM_ID: ${{ secrets.OT_APP_INTERCOM_ID }}
-          OPENTRONS_PROJECT: ${{ steps.project.outputs.project }}
-        run: |
-          make -C app dist
-
       # build the desktop app and deploy it
       - name: 'build ${{matrix.variant}} app for ${{ matrix.os }}'
         if: matrix.target == 'desktop'
@@ -348,14 +339,18 @@ jobs:
           OT_APP_MIXPANEL_ID: ${{ secrets.OT_APP_MIXPANEL_ID }}
           OT_APP_INTERCOM_ID: ${{ secrets.OT_APP_INTERCOM_ID }}
           WINDOWS_SIGN: ${{ format('{0}', contains(needs.determine-build-type.outputs.type, 'release')) }}
-          SM_CODE_SIGNING_CERT_SHA1_HASH: ${{secrets.SM_CODE_SIGNING_CERT_SHA1_HASH_V2}}
-          SM_KEYPAIR_ALIAS: ${{secrets.SM_KEYPAIR_ALIAS_V2}}
+          SM_HOST: ${{secrets.SM_HOST}}
+          SM_CLIENT_CERT_FILE: "D:\\Certificate_pkcs12.p12"
+          SM_CLIENT_CERT_PASSWORD: ${{secrets.SM_CLIENT_CERT_PASSWORD}}
+          SM_API_KEY: ${{secrets.SM_API_KEY}}
+          SM_CODE_SIGNING_CERT_SHA1_HASH: ${{secrets.SM_CODE_SIGNING_CERT_SHA1_HASH}}
+          SM_KEYPAIR_ALIAS: ${{secrets.SM_KEYPAIR_ALIAS}}
           WINDOWS_CSC_FILEPATH: "D:\\opentrons_labworks_inc.crt"
-          CSC_LINK: ${{ secrets.OT_APP_CSC_MACOS_V2 }}
-          CSC_KEY_PASSWORD: ${{ secrets.OT_APP_CSC_KEY_MACOS_V2 }}
-          APPLE_ID: ${{ secrets.OT_APP_APPLE_ID_V2 }}
-          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.OT_APP_APPLE_ID_PASSWORD_V2 }}
-          APPLE_TEAM_ID: ${{ secrets.OT_APP_APPLE_TEAM_ID_V2 }}
+          CSC_LINK: ${{ secrets.OT_APP_CSC_MACOS }}
+          CSC_KEY_PASSWORD: ${{ secrets.OT_APP_CSC_KEY_MACOS }}
+          APPLE_ID: ${{ secrets.OT_APP_APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.OT_APP_APPLE_ID_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.OT_APP_APPLE_TEAM_ID }}
           HOST_PYTHON: python
           OPENTRONS_PROJECT: ${{ steps.project.outputs.project }}
           OT_APP_DEPLOY_BUCKET: ${{ steps.project.outputs.bucket }}

abr-testing/abr_testing/protocol_simulation/abr_sim_check.py

@@ -1,34 +1,109 @@
 """Check ABR Protocols Simulate Successfully."""
 from abr_testing.protocol_simulation import simulation_metrics
 import os
-import traceback
 from pathlib import Path
+from typing import Dict, List, Tuple, Union
+import traceback
 
 
-def run(file_to_simulate: Path) -> None:
+def run(
+    file_dict: Dict[str, Dict[str, Union[str, Path]]], labware_defs: List[Path]
+) -> None:
     """Simulate protocol and raise errors."""
-    protocol_name = file_to_simulate.stem
-    try:
-        simulation_metrics.main(file_to_simulate, False)
-    except Exception:
-        print(f"Error in protocol: {protocol_name}")
-        traceback.print_exc()
+    for file in file_dict:
+        path = file_dict[file]["path"]
+        csv_params = ""
+        try:
+            csv_params = str(file_dict[file]["csv"])
+        except KeyError:
+            pass
+        try:
+            print(f"Simulating {file}")
+            simulation_metrics.main(
+                protocol_file_path=Path(path),
+                save=False,
+                parameters=csv_params,
+                extra_files=labware_defs,
+            )
+        except Exception as e:
+            traceback.print_exc()
+            print(str(e))
+        print("\n")
+
+
+def search(seq: str, dictionary: dict) -> str:
+    """Search for specific sequence in file."""
+    for key in dictionary.keys():
+        parts = key.split("_")
+        if parts[0] == seq:
+            return key
+    return ""
+
+
+def get_files() -> Tuple[Dict[str, Dict[str, Union[str, Path]]], List[Path]]:
+    """Map protocols with corresponding csv files."""
+    file_dict: Dict[str, Dict[str, Union[str, Path]]] = {}
+    labware_defs = []
+    for root, directories, _ in os.walk(root_dir):
+        for directory in directories:
+            if directory == "active_protocols":
+                active_dir = os.path.join(root, directory)
+                for file in os.listdir(
+                    active_dir
+                ):  # Iterate over files in `active_protocols`
+                    if file.endswith(".py") and file not in exclude:
+                        file_dict[file] = {}
+                        file_dict[file]["path"] = Path(
+                            os.path.abspath(
+                                os.path.join(root_dir, os.path.join(directory, file))
+                            )
+                        )
+            if directory == "csv_parameters":
+                active_dir = os.path.join(root, directory)
+                for file in os.listdir(
+                    active_dir
+                ):  # Iterate over files in `active_protocols`
+                    if file.endswith(".csv") and file not in exclude:
+                        search_str = file.split("_")[0]
+                        protocol = search(search_str, file_dict)
+                        if protocol:
+                            file_dict[protocol]["csv"] = str(
+                                os.path.abspath(
+                                    os.path.join(
+                                        root_dir, os.path.join(directory, file)
+                                    )
+                                )
+                            )
+            if directory == "custom_labware":
+                active_dir = os.path.join(root, directory)
+                for file in os.listdir(
+                    active_dir
+                ):  # Iterate over files in `active_protocols`
+                    if file.endswith(".json") and file not in exclude:
+                        labware_defs.append(
+                            Path(
+                                os.path.abspath(
+                                    os.path.join(
+                                        root_dir, os.path.join(directory, file)
+                                    )
+                                )
+                            )
+                        )
+    return (file_dict, labware_defs)
 
 
 if __name__ == "__main__":
     # Directory to search
+    global root_dir
     root_dir = "abr_testing/protocols"
-
+    global exclude
     exclude = [
         "__init__.py",
+        "helpers.py",
         "shared_vars_and_funcs.py",
+        "9_parameters.csv",
     ]
-    # Walk through the root directory and its subdirectories
-    for root, dirs, files in os.walk(root_dir):
-        for file in files:
-            if file.endswith(".py"):  # If it's a Python file
-                if file in exclude:
-                    continue
-                file_path = Path(os.path.join(root, file))
-                print(f"Simulating protocol: {file_path.stem}")
-                run(file_path)
+    print("Simulating Protocols")
+    file_dict, labware_defs = get_files()
+    # print(file_dict)
+    run(file_dict, labware_defs)