test/compiler_test.exs

defmodule Forge.CompilerTest do
  use ExUnit.Case
  alias Forge.Compiler
  alias Forge.Provenance
  alias Forge.Hash

  @moduletag :compiler

  describe "Forge.Compiler" do
    @tag :basic
    test "compiles simple module" do
      source = """
      defmodule TestModule do
        def add(a, b), do: a + b
        def sub(a, b), do: a - b
      end
      """

      {:ok, result} = Compiler.compile(source)

      assert result.artifact_id != nil
      assert result.source == source
      assert result.ast != nil
      assert result.quoted != nil
      assert result.forms != nil
      assert result.beam_path != nil
      assert result.beam_binary != nil
      assert result.errors == []
      assert result.metrics.source_size > 0
      assert result.metrics.beam_size > 0
    end

    @tag :basic
    test "compiles module with pattern matching" do
      source = """
      defmodule TestPattern do
        def match([head | tail]), do: {head, tail}
        def match([]), do: :empty
      end
      """

      {:ok, result} = Compiler.compile(source)

      assert result.errors == []
      assert result.function_count >= 2
    end

    @tag :basic
    test "compiles module with recursion" do
      source = """
      defmodule TestRecursion do
        def factorial(0), do: 1
        def factorial(n), do: n * factorial(n - 1)
      end
      """

      {:ok, result} = Compiler.compile(source)

      assert result.errors == []
    end

    @tag :error_handling
    test "handles syntax errors" do
      source = """
      defmodule TestError do
        def bad do
          this is not valid elixir
        end
      end
      """

      {:error, _reason, details} = Compiler.compile(source)

      assert details.errors != []
      assert details.provenance != nil
    end

    @tag :metadata
    test "extracts compiler version" do
      assert Compiler.otp_version() != nil
      assert Compiler.elixir_version() != nil
      assert Compiler.arch() != nil
      assert Compiler.os() != nil
    end

    @tag :provenance
    test "creates provenance chain" do
      source = "defmodule P.Test do def ok, do: :ok end"

      {:ok, result} = Compiler.compile(source)

      assert result.provenance != nil
      assert result.provenance.artifact_id != nil
      assert result.provenance.stages[:source] != nil
      assert result.provenance.compiler != nil
      assert result.provenance.target != nil
    end

    @tag :provenance
    test "provenance chain includes all stages" do
      source = "defmodule P.Test2 do def add(a, b), do: a + b end"

      {:ok, result} = Compiler.compile(source)

      chain = result.provenance

      assert chain.stages[:source] != nil
      assert chain.stages[:ast] != nil
      assert chain.stages[:quoted] != nil
      assert chain.stages[:erlang_forms] != nil
      assert chain.stages[:beam] != nil
    end

    @tag :provenance
    test "provenance chain is verifiable" do
      source = "defmodule P.Test3 do def mul(a, b), do: a * b end"

      {:ok, result} = Compiler.compile(source)

      assert Provenance.verify(result.provenance) == {:ok, true}
    end

    @tag :hashing
    test "source hash is computed" do
      source = "defmodule P.Test4 do def div(a, b), do: a / b end"

      {:ok, result} = Compiler.compile(source)
      source_hash = result.provenance.stages[:source]

      assert source_hash != nil
      assert byte_size(source_hash) == 32
    end

    @tag :metrics
    test "metrics are collected" do
      source = """
      defmodule TestMetrics do
        def one, do: 1
        def two, do: 2
        def three, do: 3
      end
      """

      {:ok, result} = Compiler.compile(source)

      assert result.metrics.source_size == byte_size(source)
      assert result.metrics.beam_size > 0
      assert result.metrics.function_count >= 3
    end

    @tag :compilation_options
    test "accepts compilation options" do
      source = "defmodule P.Test5 do def id(x), do: x end"
      options = %{compiler_flags: ["-Werror"]}

      # This should still compile even with warnings-as-errors
      # because our test source has no warnings
      {:ok, result} = Compiler.compile(source, options)

      assert result.errors == []
    end

    @tag :artifact_id
    test "generates unique artifact IDs" do
      source1 = "defmodule A do def f, do: 1 end"
      source2 = "defmodule B do def f, do: 2 end"

      {:ok, result1} = Compiler.compile(source1)
      {:ok, result2} = Compiler.compile(source2)

      assert result1.artifact_id != result2.artifact_id
    end

    @tag :deterministic
    test "produces deterministic results for same source" do
      source = "defmodule Deterministic do def same, do: :same end"

      {:ok, result1} = Compiler.compile(source)
      {:ok, result2} = Compiler.compile(source)

      assert result1.artifact_id == result2.artifact_id
      assert result1.provenance.stages[:source] == result2.provenance.stages[:source]
    end
  end
end