defmodule PlugTestExample do
  @moduledoc """
  Examples of testing SOAP endpoints using Plug.Test.
  """

  # A simple Plug that handles SOAP requests
  defmodule TestSOAPPlug do
    import Plug.Conn

    def init(opts), do: opts

    def call(conn, _opts) do
      {:ok, body, conn} = read_body(conn)

      # Simple routing based on SOAPAction header
      soap_action = get_req_header(conn, "soapaction") |> List.first() || ""

      response = case soap_action do
        action when action in ["Add", "\"Add\""] ->
          handle_add(body)

        action when action in ["Subtract", "\"Subtract\""] ->
          handle_subtract(body)

        _ ->
          create_fault("Client", "Unknown operation")
      end

      conn
      |> put_resp_content_type("text/xml")
      |> send_resp(200, response)
    end

    defp handle_add(body) do
      # Extract values (simplified for demo)
      a = extract_value(body, "a") || "0"
      b = extract_value(body, "b") || "0"

      {a_num, _} = Float.parse(a)
      {b_num, _} = Float.parse(b)
      result = a_num + b_num

      """
      1.0
      
        
          
            #{result}
          
        
      
      """
    end

    defp handle_subtract(body) do
      a = extract_value(body, "a") || "0"
      b = extract_value(body, "b") || "0"

      {a_num, _} = Float.parse(a)
      {b_num, _} = Float.parse(b)
      result = a_num - b_num

      """
      1.0
      
        
          
            #{result}
          
        
      
      """
    end

    defp create_fault(code, message) do
      """
      1.0
      
        
          
            soap:#{code}
            #{message}
          
        
      
      """
    end

    defp extract_value(body, element) do
      case Regex.run(~r/<#{element}>([^<]+)<\/#{element}>/, body) do
        [_, value] -> value
        _ -> nil
      end
    end
  end

  def test_add_endpoint do
    IO.puts("Testing Add Endpoint with Plug.Test")
    IO.puts("=" |> String.duplicate(40))

    soap_request = """
    1.0
    
      
        
          15.5
          4.5
        
      
    
    """

    conn = Plug.Test.conn(:post, "/soap", soap_request)
           |> Plug.Conn.put_req_header("content-type", "text/xml")
           |> Plug.Conn.put_req_header("soapaction", "Add")

    conn = TestSOAPPlug.call(conn, [])

    IO.puts("Response status: #{conn.status}")
    IO.puts("Response body:")
    IO.puts(conn.resp_body)

    if String.contains?(conn.resp_body, "20.0") do
      IO.puts("\n[PASS] Add operation returned correct result")
    else
      IO.puts("\n[FAIL] Unexpected result")
    end
  end

  def test_unknown_operation do
    IO.puts("\nTesting Unknown Operation")
    IO.puts("=" |> String.duplicate(40))

    conn = Plug.Test.conn(:post, "/soap", "")
           |> Plug.Conn.put_req_header("content-type", "text/xml")
           |> Plug.Conn.put_req_header("soapaction", "UnknownOperation")

    conn = TestSOAPPlug.call(conn, [])

    IO.puts("Response status: #{conn.status}")

    if String.contains?(conn.resp_body, "soap:Fault") do
      IO.puts("[PASS] Received SOAP fault for unknown operation")
    else
      IO.puts("[FAIL] Expected SOAP fault")
    end
  end
end

# Run Plug.Test examples
PlugTestExample.test_add_endpoint()
PlugTestExample.test_unknown_operation()

Integration Testing

Integration tests verify that components work together correctly.

Environment-Based Test Configuration

defmodule IntegrationTestConfig do
  @moduledoc """
  Configuration patterns for integration testing.
  """

  def show_test_helper_config do
    IO.puts("Test Helper Configuration Pattern")
    IO.puts("=" |> String.duplicate(40))

    config = """
    # test/test_helper.exs

    # Configure ExUnit
    ExUnit.start()

    # Exclude external API tests by default
    ExUnit.configure(exclude: [:external_api, :slow])

    # Set up test environment
    Application.put_env(:my_app, :soap_timeout, 5_000)
    Application.put_env(:my_app, :enable_request_logging, true)

    # Start required services
    {:ok, _} = Application.ensure_all_started(:bypass)

    # Helpful utilities for tests
    defmodule TestHelpers do
      def build_soap_envelope(body) do
        \"\"\"
        1.0UTF-8
        
          
            \#{body}
          
        
        \"\"\"
      end

      def assert_soap_success(response) do
        refute String.contains?(response, "soap:Fault"),
               "Expected success but got SOAP fault"
      end

      def assert_soap_fault(response, expected_code \\\\ nil) do
        assert String.contains?(response, "soap:Fault"),
               "Expected SOAP fault but got success"

        if expected_code do
          assert String.contains?(response, expected_code),
                 "Expected fault code \#{expected_code}"
        end
      end
    end
    """

    IO.puts(config)
  end

  def show_integration_test_pattern do
    IO.puts("\nIntegration Test Pattern")
    IO.puts("=" |> String.duplicate(40))

    pattern = """
    # test/integration/country_info_service_test.exs

    defmodule CountryInfoServiceTest do
      use ExUnit.Case, async: false

      # Tag all tests in this module as external API tests
      @moduletag :external_api
      @moduletag timeout: 60_000

      @wsdl_url "http://webservices.oorsprong.org/websamples.countryinfo/CountryInfoService.wso?WSDL"

      setup do
        # Skip if service is unavailable
        case Lather.DynamicClient.new(@wsdl_url, timeout: 30_000) do
          {:ok, client} ->
            {:ok, client: client}

          {:error, reason} ->
            {:skip, "Service unavailable: \#{inspect(reason)}"}
        end
      end

      describe "ListOfCountryNamesByName" do
        test "returns list of countries", %{client: client} do
          {:ok, response} = Lather.DynamicClient.call(
            client,
            "ListOfCountryNamesByName",
            %{}
          )

          assert is_map(response)
          # Countries should be present
          assert Map.has_key?(response, "ListOfCountryNamesByNameResult") or
                 Map.has_key?(response, "tCountryCodeAndName")
        end
      end

      describe "CountryName" do
        test "returns country name for valid code", %{client: client} do
          {:ok, response} = Lather.DynamicClient.call(
            client,
            "CountryName",
            %{"sCountryISOCode" => "US"}
          )

          assert response["CountryNameResult"] == "United States"
        end

        test "handles invalid country code", %{client: client} do
          {:ok, response} = Lather.DynamicClient.call(
            client,
            "CountryName",
            %{"sCountryISOCode" => "XX"}
          )

          # Should return empty or error message
          result = response["CountryNameResult"]
          assert result == "" or result == "Country not found"
        end
      end
    end
    """

    IO.puts(pattern)
  end

  def show_running_tests do
    IO.puts("\nRunning Integration Tests")
    IO.puts("=" |> String.duplicate(40))

    commands = """
    # Regular test run (excludes external API tests)
    mix test

    # Include external API tests
    mix test --include external_api

    # Run only external API tests
    mix test --only external_api

    # Run specific integration test file
    mix test --include external_api test/integration/country_info_test.exs

    # Run with verbose output
    mix test --include external_api --trace

    # Run with seed for reproducibility
    mix test --include external_api --seed 12345
    """

    IO.puts(commands)
  end
end

# Show integration testing patterns
IntegrationTestConfig.show_test_helper_config()
IntegrationTestConfig.show_integration_test_pattern()
IntegrationTestConfig.show_running_tests()

Contract Testing

Contract testing ensures your code adheres to the WSDL specification.

WSDL as Contract

defmodule ContractTesting do
  @moduledoc """
  Contract testing patterns for SOAP services.
  """

  def validate_response_against_schema do
    IO.puts("Contract Testing: Response Validation")
    IO.puts("=" |> String.duplicate(40))

    # Example: Validate response structure matches WSDL definition
    expected_schema = %{
      "GetWeatherResponse" => %{
        required_fields: ["GetWeatherResult"],
        field_types: %{
          "GetWeatherResult" => :string
        }
      },
      "AddResponse" => %{
        required_fields: ["result"],
        field_types: %{
          "result" => :decimal
        }
      }
    }

    # Test responses
    test_responses = [
      {"GetWeatherResponse", %{"GetWeatherResult" => "Sunny, 72F"}, :valid},
      {"GetWeatherResponse", %{}, :invalid},
      {"AddResponse", %{"result" => "15.5"}, :valid},
      {"AddResponse", %{"wrong_field" => "15.5"}, :invalid}
    ]

    Enum.each(test_responses, fn {operation, response, expected_result} ->
      IO.puts("\nValidating #{operation}:")
      IO.puts("  Response: #{inspect(response)}")

      schema = Map.get(expected_schema, operation)
      result = validate_response(response, schema)

      case {result, expected_result} do
        {:valid, :valid} ->
          IO.puts("  [PASS] Valid response as expected")

        {:invalid, :invalid} ->
          IO.puts("  [PASS] Invalid response detected as expected")

        {actual, expected} ->
          IO.puts("  [FAIL] Expected #{expected}, got #{actual}")
      end
    end)
  end

  defp validate_response(response, schema) when is_map(schema) do
    required_present = Enum.all?(schema.required_fields, fn field ->
      Map.has_key?(response, field)
    end)

    if required_present, do: :valid, else: :invalid
  end

  def detect_breaking_changes do
    IO.puts("\nDetecting Breaking Changes")
    IO.puts("=" |> String.duplicate(40))

    # Compare old vs new WSDL
    old_operations = ["GetWeather", "GetCities", "AddCity"]
    new_operations = ["GetWeather", "GetCities", "UpdateCity"]  # AddCity removed, UpdateCity added

    old_params = %{
      "GetWeather" => ["city", "country"],
      "GetCities" => ["country"]
    }

    new_params = %{
      "GetWeather" => ["city", "country", "units"],  # New optional param
      "GetCities" => ["country", "region"]  # New required param (breaking!)
    }

    IO.puts("\nOperation Changes:")

    # Removed operations (breaking)
    removed = old_operations -- new_operations
    if length(removed) > 0 do
      IO.puts("  [BREAKING] Removed operations: #{inspect(removed)}")
    end

    # Added operations (non-breaking)
    added = new_operations -- old_operations
    if length(added) > 0 do
      IO.puts("  [INFO] New operations: #{inspect(added)}")
    end

    IO.puts("\nParameter Changes:")

    Enum.each(old_params, fn {op, old_params_list} ->
      new_params_list = Map.get(new_params, op, [])

      added_params = new_params_list -- old_params_list
      removed_params = old_params_list -- new_params_list

      if length(added_params) > 0 do
        IO.puts("  [WARN] #{op}: New parameters #{inspect(added_params)}")
        IO.puts("         (Breaking if required)")
      end

      if length(removed_params) > 0 do
        IO.puts("  [BREAKING] #{op}: Removed parameters #{inspect(removed_params)}")
      end
    end)
  end

  def show_contract_test_example do
    IO.puts("\nContract Test Example")
    IO.puts("=" |> String.duplicate(40))

    test_code = """
    defmodule ContractTest do
      use ExUnit.Case

      @wsdl_url "http://example.com/service?wsdl"

      describe "WSDL contract validation" do
        setup do
          {:ok, client} = Lather.DynamicClient.new(@wsdl_url)
          {:ok, client: client}
        end

        test "service exposes expected operations", %{client: client} do
          operations = Lather.DynamicClient.list_operations(client)

          # These operations MUST exist (contract requirement)
          assert "GetWeather" in operations
          assert "GetForecast" in operations
          assert "GetAlerts" in operations
        end

        test "GetWeather has expected input parameters", %{client: client} do
          {:ok, info} = Lather.DynamicClient.get_operation_info(client, "GetWeather")

          param_names = Enum.map(info.input_parts, & &1.name)

          assert "city" in param_names
          assert "country" in param_names
        end

        test "GetWeather has expected output structure", %{client: client} do
          {:ok, info} = Lather.DynamicClient.get_operation_info(client, "GetWeather")

          output_names = Enum.map(info.output_parts, & &1.name)

          assert "GetWeatherResult" in output_names or
                 "temperature" in output_names
        end
      end
    end
    """

    IO.puts(test_code)
  end
end

# Run contract testing examples
ContractTesting.validate_response_against_schema()
ContractTesting.detect_breaking_changes()
ContractTesting.show_contract_test_example()

Test Fixtures and Factories

Creating reusable test data makes tests cleaner and more maintainable.

SOAP Message Fixtures

defmodule TestFixtures do
  @moduledoc """
  Test fixtures for SOAP messages and responses.
  """

  # SOAP Envelope wrapper
  def soap_envelope(body) do
    """
    1.0UTF-8
    
      
        #{body}
      
    
    """
  end

  # Weather service fixtures
  def weather_response(temperature, conditions) do
    soap_envelope("""
      
        
          #{temperature}
          #{conditions}
          45
          10
          #{DateTime.utc_now() |> DateTime.to_iso8601()}
        
      
    """)
  end

  def weather_not_found_response(city) do
    soap_envelope("""
      
        
          City not found: #{city}
        
      
    """)
  end

  # Country service fixtures
  def country_list_response(countries) do
    country_xml = Enum.map_join(countries, "\n", fn {code, name} ->
      """
            
              #{code}
              #{name}
            
      """
    end)

    soap_envelope("""
      
        
          #{country_xml}
        
      
    """)
  end

  # SOAP Fault fixtures
  def client_fault(message, detail \\ nil) do
    detail_xml = if detail do
      "#{detail}"
    else
      ""
    end

    soap_envelope("""
      
        soap:Client
        #{message}
        #{detail_xml}
      
    """)
  end

  def server_fault(message) do
    soap_envelope("""
      
        soap:Server
        #{message}
      
    """)
  end

  def authentication_fault do
    client_fault(
      "Authentication required",
      "AUTH_001"
    )
  end

  def demonstrate_fixtures do
    IO.puts("Test Fixture Examples")
    IO.puts("=" |> String.duplicate(40))

    IO.puts("\n1. Weather Response:")
    IO.puts(weather_response("72", "Sunny") |> String.slice(0, 300) <> "...")

    IO.puts("\n2. Country List Response:")
    countries = [{"US", "United States"}, {"CA", "Canada"}, {"MX", "Mexico"}]
    IO.puts(country_list_response(countries) |> String.slice(0, 400) <> "...")

    IO.puts("\n3. Client Fault:")
    IO.puts(client_fault("Invalid parameter"))

    IO.puts("\n4. Authentication Fault:")
    IO.puts(authentication_fault())
  end
end

# Demonstrate fixtures
TestFixtures.demonstrate_fixtures()

Parameter Factories

defmodule TestFactories do
  @moduledoc """
  Factory functions for generating test parameters.
  """

  # Counter for unique IDs
  def unique_id do
    System.unique_integer([:positive])
  end

  # Weather service parameters
  def weather_params(overrides \\ %{}) do
    Map.merge(%{
      "CityName" => "New York",
      "CountryName" => "United States"
    }, overrides)
  end

  def weather_params_list(count) do
    cities = [
      {"New York", "United States"},
      {"London", "United Kingdom"},
      {"Tokyo", "Japan"},
      {"Sydney", "Australia"},
      {"Paris", "France"},
      {"Berlin", "Germany"},
      {"Toronto", "Canada"},
      {"Mumbai", "India"}
    ]

    cities
    |> Enum.take(count)
    |> Enum.map(fn {city, country} ->
      weather_params(%{"CityName" => city, "CountryName" => country})
    end)
  end

  # Calculator service parameters
  def calculator_params(operation, overrides \\ %{}) do
    base = case operation do
      :add -> %{"a" => "10.0", "b" => "5.0"}
      :subtract -> %{"a" => "10.0", "b" => "5.0"}
      :multiply -> %{"a" => "10.0", "b" => "5.0"}
      :divide -> %{"a" => "10.0", "b" => "2.0"}
    end

    Map.merge(base, overrides)
  end

  def random_calculator_params(operation) do
    a = :rand.uniform(1000) / 10
    b = if operation == :divide do
      # Avoid division by zero
      max(:rand.uniform(1000) / 10, 0.1)
    else
      :rand.uniform(1000) / 10
    end

    calculator_params(operation, %{
      "a" => Float.to_string(a),
      "b" => Float.to_string(b)
    })
  end

  # User/Customer parameters
  def user_params(overrides \\ %{}) do
    id = unique_id()

    Map.merge(%{
      "userId" => "USER_#{id}",
      "firstName" => "Test",
      "lastName" => "User#{id}",
      "email" => "test.user#{id}@example.com",
      "phone" => "+1555#{String.pad_leading("#{id}", 7, "0")}",
      "active" => true
    }, overrides)
  end

  # Order parameters
  def order_params(overrides \\ %{}) do
    id = unique_id()

    Map.merge(%{
      "orderId" => "ORD_#{id}",
      "customerId" => "CUST_#{id}",
      "items" => [
        %{"productId" => "PROD_1", "quantity" => 2, "price" => "19.99"},
        %{"productId" => "PROD_2", "quantity" => 1, "price" => "49.99"}
      ],
      "totalAmount" => "89.97",
      "status" => "pending"
    }, overrides)
  end

  def demonstrate_factories do
    IO.puts("Test Factory Examples")
    IO.puts("=" |> String.duplicate(40))

    IO.puts("\n1. Weather Parameters:")
    IO.inspect(weather_params(), pretty: true)

    IO.puts("\n2. Weather Parameters with Override:")
    IO.inspect(weather_params(%{"CityName" => "London"}), pretty: true)

    IO.puts("\n3. Multiple Weather Parameters:")
    IO.inspect(weather_params_list(3), pretty: true)

    IO.puts("\n4. Calculator Parameters:")
    IO.inspect(calculator_params(:divide), pretty: true)

    IO.puts("\n5. Random Calculator Parameters:")
    IO.inspect(random_calculator_params(:multiply), pretty: true)

    IO.puts("\n6. User Parameters:")
    IO.inspect(user_params(), pretty: true)

    IO.puts("\n7. Order Parameters:")
    IO.inspect(order_params(), pretty: true)
  end
end

# Demonstrate factories
TestFactories.demonstrate_factories()

Performance Testing

Performance testing ensures your SOAP integrations can handle expected load.

Benchmarking Operations

defmodule PerformanceTesting do
  @moduledoc """
  Performance testing utilities for SOAP operations.
  """

  def benchmark_xml_parsing do
    IO.puts("Benchmarking XML Parsing")
    IO.puts("=" |> String.duplicate(40))

    # Generate test XML of various sizes
    small_xml = TestFixtures.weather_response("72", "Sunny")

    medium_xml = TestFixtures.country_list_response(
      Enum.map(1..100, fn i -> {"C#{i}", "Country #{i}"} end)
    )

    large_xml = TestFixtures.country_list_response(
      Enum.map(1..1000, fn i -> {"C#{i}", "Country #{i}"} end)
    )

    IO.puts("\nXML sizes:")
    IO.puts("  Small:  #{byte_size(small_xml)} bytes")
    IO.puts("  Medium: #{byte_size(medium_xml)} bytes")
    IO.puts("  Large:  #{byte_size(large_xml)} bytes")

    # Benchmark parsing
    IO.puts("\nParsing benchmarks (100 iterations):")

    Enum.each([
      {"Small", small_xml},
      {"Medium", medium_xml},
      {"Large", large_xml}
    ], fn {name, xml} ->
      {time, _} = :timer.tc(fn ->
        Enum.each(1..100, fn _ ->
          Lather.XMLParser.parse_soap_response(xml)
        end)
      end)

      avg_time = time / 100 / 1000  # Convert to ms
      IO.puts("  #{name}: #{Float.round(avg_time, 3)} ms average")
    end)
  end

  def benchmark_request_building do
    IO.puts("\nBenchmarking Request Building")
    IO.puts("=" |> String.duplicate(40))

    simple_params = %{"city" => "New York", "country" => "US"}

    complex_params = %{
      "request" => %{
        "criteria" => %{
          "filters" => Enum.map(1..10, fn i ->
            %{"field" => "field#{i}", "value" => "value#{i}"}
          end),
          "sorting" => [%{"field" => "name", "direction" => "asc"}],
          "pagination" => %{"page" => 1, "size" => 50}
        }
      }
    }

    IO.puts("\nRequest building benchmarks (1000 iterations):")

    Enum.each([
      {"Simple params", simple_params},
      {"Complex params", complex_params}
    ], fn {name, params} ->
      {time, _} = :timer.tc(fn ->
        Enum.each(1..1000, fn _ ->
          Lather.XMLBuilder.build_params(params, "TestOperation", "http://example.com")
        end)
      end)

      avg_time = time / 1000  # microseconds per iteration
      IO.puts("  #{name}: #{Float.round(avg_time, 1)} us average")
    end)
  end

  def simulate_concurrent_load do
    IO.puts("\nSimulating Concurrent Load")
    IO.puts("=" |> String.duplicate(40))

    # Set up a mock service
    bypass = Bypass.open()

    Bypass.stub(bypass, "POST", "/soap", fn conn ->
      # Simulate some processing time
      Process.sleep(10)

      conn
      |> Plug.Conn.put_resp_content_type("text/xml")
      |> Plug.Conn.resp(200, TestFixtures.weather_response("72", "Sunny"))
    end)

    endpoint = "http://localhost:#{bypass.port}/soap"

    # Run concurrent requests
    concurrency_levels = [1, 5, 10, 20]

    IO.puts("\nConcurrent request performance:")

    Enum.each(concurrency_levels, fn concurrency ->
      requests = Enum.map(1..100, fn _ ->
        Task.async(fn ->
          request = Finch.build(:post, endpoint, [
            {"content-type", "text/xml"},
            {"soapaction", "GetWeather"}
          ], "")

          {time, result} = :timer.tc(fn ->
            Finch.request(request, Lather.Finch, receive_timeout: 5_000)
          end)

          {time, result}
        end)
      end)
      |> Enum.chunk_every(concurrency)
      |> Enum.flat_map(fn chunk ->
        Task.await_many(chunk, 10_000)
      end)

      times = Enum.map(requests, fn {time, _} -> time end)
      successes = Enum.count(requests, fn {_, result} -> match?({:ok, _}, result) end)

      avg_time = Enum.sum(times) / length(times) / 1000
      p99_time = times |> Enum.sort() |> Enum.at(round(length(times) * 0.99)) |> Kernel./(1000)

      IO.puts("  Concurrency #{concurrency}:")
      IO.puts("    Success rate: #{successes}/#{length(requests)}")
      IO.puts("    Avg response: #{Float.round(avg_time, 1)} ms")
      IO.puts("    P99 response: #{Float.round(p99_time, 1)} ms")
    end)

    Bypass.down(bypass)
  end
end

# Run performance tests
PerformanceTesting.benchmark_xml_parsing()
PerformanceTesting.benchmark_request_building()
PerformanceTesting.simulate_concurrent_load()