E2E test file-based scripts in workflows

gaggle · gaggle · commit d1e248c0af61 · 2025-11-26T10:32:33.000+01:00
diff --git a/.github/actions/run-e2e/action.yml b/.github/actions/run-e2e/action.yml
@@ -16,12 +16,29 @@ runs:
       run: |
         sed -i 's/\(  image: \).*/\1${{ inputs.image-name }}/' action.yml
       shell: bash
+    - name: Create script files
+      if: ${{ matrix.file_content }}
+      shell: bash
+      run: |
+        echo "Creating files for test: ${{ matrix.name }}"
+        # Use jq to iterate over the JSON object
+        echo '${{ toJSON(matrix.file_content) }}' | jq -r 'to_entries[] | @json' | while IFS= read -r entry; do
+          path=$(echo "$entry" | jq -r '.key')
+          content=$(echo "$entry" | jq -r '.value')
+          
+          # Create directory if needed
+          dir=$(dirname "$path")
+          mkdir -p "$dir"
+          
+          # Write the file content
+          echo "$content" > "$path"
+          echo "Created file: $path"
+        done
     - name: Run gaggle/elixir_script
       id: run
       uses: ./
       with:
-        script: |
-          ${{ matrix.script }}
+        script: ${{ matrix.script }}
     - name: Assert output
       if: ${{ !!matrix.expected }}
       run: |
diff --git a/.github/workflows/ci-cd.yml b/.github/workflows/ci-cd.yml
@@ -79,7 +79,7 @@ jobs:
         with:
           otp-version: ${{ needs.version.outputs.otp-version }}
           elixir-version: ${{ needs.version.outputs.elixir-version }}
-      - run: bin/audit --skip-check-image
+      - run: pkgx +invisible-island.net/ncurses -- bin/audit --skip-check-image
 
   build:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/examples.yml b/.github/workflows/examples.yml
@@ -33,7 +33,6 @@ jobs:
 
       - name: Get result
         run: echo "${{steps.script.outputs.result}}"
-
   io-is-visible-in-logs:
     runs-on: ubuntu-latest
     steps:
@@ -45,7 +44,6 @@ jobs:
 
       - name: Get result
         run: echo "${{steps.script.outputs.result}}"
-
   event-context-is-available:
     runs-on: ubuntu-latest
     steps:
@@ -58,7 +56,6 @@ jobs:
 
       - name: Get result
         run: echo "${{steps.script.outputs.result}}"
-
   the-entire-context-can-be-inspected:
     runs-on: ubuntu-latest
     steps:
@@ -70,7 +67,6 @@ jobs:
 
       - name: Get result
         run: echo "${{steps.script.outputs.result}}"
-
   multiline-scripts-are-possible:
     runs-on: ubuntu-latest
     steps:
@@ -83,7 +79,6 @@ jobs:
 
       - name: Get result
         run: echo "${{steps.script.outputs.result}}"
-
   oh-hi-mark-greeter:
     runs-on: ubuntu-latest
     steps:
@@ -98,7 +93,6 @@ jobs:
 
       - name: Get result
         run: echo "${{steps.script.outputs.result}}"
-
   can-use-the-github-api-via-tentacat:
     runs-on: ubuntu-latest
     steps:
@@ -111,7 +105,6 @@ jobs:
 
       - name: Get result
         run: echo "${{steps.script.outputs.result}}"
-
   can-grab-information-via-the-github-api:
     runs-on: ubuntu-latest
     steps:
@@ -124,7 +117,6 @@ jobs:
 
       - name: Get result
         run: echo "${{steps.script.outputs.result}}"
-
   can-interact-with-repositories-via-github-api:
     runs-on: ubuntu-latest
     steps:
@@ -137,3 +129,138 @@ jobs:
 
       - name: Get result
         run: echo "${{steps.script.outputs.result}}"
+  file-scripts-can-define-and-use-modules:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Create script files
+        run: |
+          mkdir -p ./.github/scripts
+          cat > ./.github/scripts/pr_analyzer.exs << 'EOFMARKER'
+              defmodule PRAnalyzer do
+                def analyze(context) do
+                  %{
+                    event: context.event_name,
+                    workflow: context.workflow,
+                    job: context.job,
+                    ref: context.ref
+                  }
+                end
+
+                def format_message(analysis) do
+                  "PR Analysis: event=#{analysis.event}"
+                end
+              end
+
+              # Use the module to analyze and format
+              analysis = PRAnalyzer.analyze(context)
+              PRAnalyzer.format_message(analysis)
+          EOFMARKER
+
+      - uses: gaggle/elixir_script@v0
+        id: script
+        with:
+          script: ./.github/scripts/pr_analyzer.exs
+
+      - name: Get result
+        run: echo "${{steps.script.outputs.result}}"
+  file-scripts-can-use-relative-require-for-helper-modules:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Create script files
+        run: |
+          mkdir -p ./scripts
+          cat > ./scripts/helpers.exs << 'EOFMARKER'
+              defmodule Helpers do
+                def format_workflow(_context) do
+                  "Script loaded from: ./scripts/main.exs"
+                end
+              end
+          EOFMARKER
+          mkdir -p ./scripts
+          cat > ./scripts/main.exs << 'EOFMARKER'
+              Code.require_file("helpers.exs", __DIR__)
+              Helpers.format_workflow(context)
+          EOFMARKER
+
+      - uses: gaggle/elixir_script@v0
+        id: script
+        with:
+          script: ./scripts/main.exs
+
+      - name: Get result
+        run: echo "${{steps.script.outputs.result}}"
+  bootstrap-pattern-delegates-to-testable-module:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Create script files
+        run: |
+          mkdir -p .
+          cat > main.ex << 'EOFMARKER'
+              defmodule Main do
+                def run(_context) do
+                  "Bootstrap test passed!"
+                end
+              end
+          EOFMARKER
+
+      - uses: gaggle/elixir_script@v0
+        id: script
+        with:
+          script: |
+            # Bootstrap: load and run the main module
+            Code.require_file("main.ex", ".")
+            Main.run(context)
+
+      - name: Get result
+        run: echo "${{steps.script.outputs.result}}"
+  bootstrap-with-complex-module-structure:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Create script files
+        run: |
+          mkdir -p lib
+          cat > lib/analyzer.ex << 'EOFMARKER'
+              defmodule Analyzer do
+                def analyze_event(context) do
+                  %{
+                    type: context.event_name,
+                    branch: extract_branch(context.ref)
+                  }
+                end
+
+                defp extract_branch(ref) do
+                  ref |> String.split("/") |> List.last()
+                end
+              end
+          EOFMARKER
+          mkdir -p lib
+          cat > lib/app.ex << 'EOFMARKER'
+              defmodule App do
+                def start(context, _client) do
+                  context
+                  |> Analyzer.analyze_event()
+                  |> Formatter.format_analysis()
+                end
+              end
+          EOFMARKER
+          mkdir -p lib
+          cat > lib/formatter.ex << 'EOFMARKER'
+              defmodule Formatter do
+                def format_analysis(analysis) do
+                  "Event type: #{String.capitalize(analysis.type)}"
+                end
+              end
+          EOFMARKER
+
+      - uses: gaggle/elixir_script@v0
+        id: script
+        with:
+          script: |
+            # Minimal bootstrap that loads and runs the application
+            Code.require_file("lib/analyzer.ex", ".")
+            Code.require_file("lib/formatter.ex", ".")
+            Code.require_file("lib/app.ex", ".")
+            App.start(context, client)
+
+      - name: Get result
+        run: echo "${{steps.script.outputs.result}}"
diff --git a/lib/e2e.ex b/lib/e2e.ex
@@ -3,7 +3,7 @@ defmodule ElixirScript.E2e.Entry do
   A struct representing the data for an E2E test
   """
 
-  defstruct id: nil, name: nil, script: nil, file: nil, expected: nil
+  defstruct id: nil, name: nil, script: nil, file_content: nil, expected: nil
 end
 
 defmodule ElixirScript.E2e do
@@ -25,18 +25,18 @@ defmodule ElixirScript.E2e do
   defp process_entry(entry) do
     name = Map.fetch!(entry, :name)
     script = Map.get(entry, :script)
-    file = Map.get(entry, :file)
+    file_content = Map.get(entry, :file_content)
     expected = Map.get(entry, :expected)
 
-    if !script && !file do
-      raise(KeyError, "key :script or :file not found in: #{inspect(entry)}")
+    if !script do
+      raise(KeyError, "key :script not found in: #{inspect(entry)}")
     end
 
     %Entry{
       id: slugify(name),
       name: name,
       script: script,
-      file: file,
+      file_content: file_content,
       expected: expected
     }
   end
diff --git a/lib/mix/tasks/e2e/set_github_matrix.ex b/lib/mix/tasks/e2e/set_github_matrix.ex
@@ -40,7 +40,7 @@ defmodule Mix.Tasks.E2e.SetGithubMatrix do
 
   # Converts an `Entry` struct to a map for JSON encoding.
   defp entry_to_map_for_json(%Entry{} = entry) do
-    Map.take(entry, [:name, :script, :expected])
+    Map.take(entry, [:name, :script, :expected, :file_content])
   end
 
   # Encodes the provided entries into a JSON structure for GitHub Actions matrix.
diff --git a/lib/mix/tasks/e2e/update_examples_workflow.ex b/lib/mix/tasks/e2e/update_examples_workflow.ex
@@ -55,9 +55,7 @@ defmodule Mix.Tasks.E2e.UpdateExamplesWorkflow do
   end
 
   def generate_workflow(entries) do
-    jobs =
-      Enum.map_join(entries, "\n", fn entry -> generate_job(entry) end)
-      |> indent_string(2)
+    jobs = Enum.map_join(entries, &generate_job/1)
 
     """
     # CI output from these examples are available here:
@@ -85,29 +83,67 @@ defmodule Mix.Tasks.E2e.UpdateExamplesWorkflow do
   end
 
   defp generate_job(%Entry{} = entry) do
-    pre_indented_script_lines =
-      entry.script |> String.trim_trailing() |> dedent_string |> indent_string(10)
+    action_ref = "gaggle/elixir_script" <> "@" <> "v0"
 
-    #                                           ↑
-    # No trailing empty lines because we tightly control how script-lines are placed within the template
-    #                                                                                                  ↑↑
-    # In the job template below "script" is indented 8, so the script itself needs 10 indents
+    file_creation_step = generate_file_creation_step(entry.file_content)
+    script_yaml = format_script_yaml(entry.script)
 
     """
-    #{entry.id}:
-      runs-on: ubuntu-latest
-      steps:
-        - uses: gaggle/elixir_script@v0
-          id: script
-          with:
-            script: |
-    #{pre_indented_script_lines}
-
-        - name: Get result
-          run: echo "\${{steps.script.outputs.result}}"
+      #{entry.id}:
+        runs-on: ubuntu-latest
+        steps:
+    #{file_creation_step}      - uses: #{action_ref}
+            id: script
+            with:
+    #{script_yaml}
+
+          - name: Get result
+            run: echo "\${{steps.script.outputs.result}}"
     """
   end
 
+  defp generate_file_creation_step(nil), do: ""
+
+  defp generate_file_creation_step(file_content) do
+    file_steps =
+      file_content
+      |> Enum.map_join("\n", fn {path, content} ->
+        dir = Path.dirname(path)
+        trimmed_content = String.trim_trailing(content)
+        indented_content = indent_string(trimmed_content, 14)
+
+        "          mkdir -p #{dir}\n" <>
+          "          cat > #{path} << 'EOFMARKER'\n" <>
+          "#{indented_content}\n" <>
+          "          EOFMARKER"
+      end)
+
+    """
+          - name: Create script files
+            run: |
+    #{file_steps}
+
+    """
+  end
+
+  defp format_script_yaml(script) do
+    trimmed_script = String.trim(script)
+
+    # Check if it's a file path (same logic as ScriptRunner.is_file_path?)
+    is_file_path = String.starts_with?(trimmed_script, ["./", "../", "/"])
+
+    if is_file_path do
+      # File path - use inline format
+      "          script: #{trimmed_script}"
+    else
+      # Inline code - use pipe format with proper indentation
+      indented_script =
+        script |> String.trim_trailing() |> dedent_string |> indent_string(12)
+
+      "          script: |\n#{indented_script}"
+    end
+  end
+
   @spec indent_string(String.t(), non_neg_integer()) :: String.t()
   defp indent_string(str, indent) do
     indentation = String.duplicate(" ", indent)
diff --git a/test/e2e_data.exs b/test/e2e_data.exs
diff --git a/test/e2e_test.exs b/test/e2e_test.exs
