Improvements in Job config, adds support to Wait options (#37)

* Parse new option in config.yml

- Docker dependences now require specification of a port where the service respond
to TCP connections. This will be used to sync the initialization of benchmark
containers that rely in external services e.g. databases. The runner will then try
to ping the service in the port specified before initializing the benchmarks run.

deps:
 docker:
 - image: pg:latest
   wait:
    - port: 5454

Signed-off-by: Tallys Martins <[email protected]>

* Apply review changes

Signed-off-by: Tallys Martins <[email protected]>

Author: tallysmartins

lib/elixir_bench/benchmarks/config.ex

@@ -15,6 +15,10 @@ defmodule ElixirBench.Benchmarks.Config do
       embeds_many :docker, Docker, primary_key: {:image, :string, []} do
         field :container_name, :string
         field :environment, {:map, :string}, default: %{}
+
+        embeds_one :wait, Wait, primary_key: false do
+          field :port, :integer
+        end
       end
     end
   end
@@ -25,8 +29,16 @@ defmodule ElixirBench.Benchmarks.Config do
 
     config
     |> cast(attrs, [:elixir, :erlang, :environment])
-    |> validate_inclusion(:elixir, supported_elixir_version)
-    |> validate_inclusion(:erlang, supported_erlang_version)
+    |> validate_inclusion(
+      :elixir,
+      supported_elixir_version,
+      message: "elixir version not supported"
+    )
+    |> validate_inclusion(
+      :erlang,
+      supported_erlang_version,
+      message: "erlang version not supported"
+    )
     |> cast_embed(:deps, with: &deps_changeset/2)
   end
 
@@ -40,5 +52,12 @@ defmodule ElixirBench.Benchmarks.Config do
     docker
     |> cast(attrs, [:image, :container_name, :environment])
     |> validate_required([:image])
+    |> cast_embed(:wait, with: &wait_changeset/2, required: true)
+  end
+
+  defp wait_changeset(wait, attrs) do
+    wait
+    |> cast(attrs, [:port])
+    |> validate_required([:port])
   end
 end

lib/elixir_bench/github/client_in_memory.ex

@@ -14,10 +14,12 @@ defmodule ElixirBench.Github.ClientInMemory do
          "docker" => [
            %{
              "container_name" => "postgres",
+             "wait" => %{port: "123"},
              "image" => "postgres:9.6.6-alpine"
            },
            %{
              "container_name" => "mysql",
+             "wait" => %{port: "321"},
              "environment" => %{
                "MYSQL_ALLOW_EMPTY_PASSWORD" => "true"
              },

lib/elixir_bench_web/router.ex

@@ -38,7 +38,7 @@ defmodule ElixirBenchWeb.Router do
         assign(conn, :runner, runner)
 
       {:error, _reason} ->
-        send_resp(conn, :unauthorized, Jason.encode!(%{error: "unauthorized"}))
+        halt(conn)
     end
   end
 end

lib/elixir_bench_web/views/job_view.ex

@@ -34,11 +34,14 @@ defmodule ElixirBenchWeb.JobView do
 
   defp render_docker(nil), do: []
 
-  def render_each_docker(docker) do
+  defp render_each_docker(docker) do
     %{
       image: docker.image,
       environment: docker.environment,
-      container_name: docker.container_name
+      container_name: docker.container_name,
+      wait: %{
+        port: docker.wait.port
+      }
     }
   end
 end

test/elixir_bench/benchmarks/config_test.exs

@@ -0,0 +1,130 @@
+defmodule ConfigTest do
+  use ElixirBench.DataCase
+  alias ElixirBench.Benchmarks.Config
+
+  describe "changeset/2" do
+    test "return config with default values if no input attrs is given" do
+      elixir_version = Confex.fetch_env!(:elixir_bench, :default_elixir_version)
+      erlang_version = Confex.fetch_env!(:elixir_bench, :default_erlang_version)
+
+      changeset = Config.changeset(%Config{}, %{})
+
+      assert %Config{
+               elixir: ^elixir_version,
+               erlang: ^erlang_version,
+               environment: %{},
+               deps: nil
+             } = changeset.data
+
+      assert changeset.valid?
+    end
+
+    test "return unsupported versions error if elixir and erlang are not supported" do
+      supported_elixir = Confex.fetch_env!(:elixir_bench, :supported_elixir_versions)
+      supported_erlang = Confex.fetch_env!(:elixir_bench, :supported_erlang_versions)
+
+      refute "99" in supported_elixir
+      refute "99" in supported_erlang
+
+      changeset = Config.changeset(%Config{}, %{elixir: "99", erlang: "99"})
+      refute changeset.valid?
+
+      assert %{elixir: ["elixir version not supported"], erlang: ["erlang version not supported"]} =
+               errors_on(changeset)
+
+      supported_elixir = hd(supported_elixir)
+      supported_erlang = hd(supported_erlang)
+
+      changeset =
+        Config.changeset(%Config{}, %{elixir: supported_elixir, erlang: supported_erlang})
+
+      assert changeset.valid?
+    end
+
+    test "return config given valid docker deps attrs" do
+      docker_deps = [
+        %{
+          image: "postgres:latest",
+          environment: %{password: "root"},
+          container_name: "pg",
+          wait: %{port: 5432}
+        },
+        %{
+          image: "mysql:latest",
+          container_name: "mysql",
+          wait: %{port: 3306}
+        }
+      ]
+
+      changeset = Config.changeset(%Config{}, %{deps: %{docker: docker_deps}})
+
+      assert changeset.valid?
+
+      changeset = Ecto.Changeset.apply_changes(changeset)
+
+      assert %{
+               deps: %{
+                 docker: [
+                   %{
+                     image: "postgres:latest",
+                     environment: %{password: "root"},
+                     container_name: "pg",
+                     wait: %{port: 5432}
+                   },
+                   %{
+                     image: "mysql:latest",
+                     container_name: "mysql",
+                     wait: %{port: 3306}
+                   }
+                 ]
+               }
+             } = changeset
+    end
+
+    test "allow empty docker deps in config" do
+      changeset = Config.changeset(%Config{}, %{deps: %{}})
+      assert changeset.valid?
+      assert %Config{deps: nil} = changeset.data
+
+      changeset = Config.changeset(%Config{}, %{deps: %{docker: []}})
+      assert changeset.valid?
+      assert %Config{deps: nil} = changeset.data
+
+      changeset = Config.changeset(%Config{}, %{deps: %{docker: %{}}})
+      assert changeset.valid?
+      assert %Config{deps: nil} = changeset.data
+    end
+
+    test "return error given invalid docker deps fields" do
+      docker_deps = [%{some_field: "some value"}]
+      changeset = Config.changeset(%Config{}, %{deps: %{docker: docker_deps}})
+
+      refute changeset.valid?
+      assert %{deps: %{docker: [%{wait: ["can't be blank"]}]}} = errors_on(changeset)
+      assert %{deps: %{docker: [%{image: ["can't be blank"]}]}} = errors_on(changeset)
+
+      docker_deps = [%{image: 1, wait: 1}]
+      changeset = Config.changeset(%Config{}, %{deps: %{docker: docker_deps}})
+
+      refute changeset.valid?
+      assert %{deps: %{docker: [%{wait: ["is invalid"]}]}} = errors_on(changeset)
+      assert %{deps: %{docker: [%{image: ["is invalid"]}]}} = errors_on(changeset)
+
+      docker_deps = [%{image: "pg:latest", wait: %{}}]
+      changeset = Config.changeset(%Config{}, %{deps: %{docker: docker_deps}})
+
+      refute changeset.valid?
+      assert %{deps: %{docker: [%{wait: %{port: ["can't be blank"]}}]}} = errors_on(changeset)
+    end
+
+    test "ignore non docker deps" do
+      changeset =
+        Config.changeset(%Config{}, %{
+          deps: %{some_dep: [%{image: "some_image", wait: %{port: 124}}]}
+        })
+
+      assert changeset.valid?
+      assert %Config{deps: nil} = changeset.data
+    end
+  end
+end

test/elixir_bench_web/controllers/job_controller_test.exs

@@ -0,0 +1,59 @@
+defmodule ElixirBenchWeb.JobControllerTest do
+  use ElixirBenchWeb.ConnCase, async: false
+
+  import ElixirBenchWeb.TestHelpers
+
+  describe "claim/2" do
+    test "respond 404 when there is no job to be claimed", context do
+      conn =
+        context.conn
+        |> authenticate!
+        |> post("/runner-api/jobs/claim", %{})
+
+      assert response(conn, 404) =~ "Page not found"
+    end
+
+    test "return job data when claimed with success", context do
+      %{branch_name: branch, commit_sha: commit_sha, uuid: uuid, repo: repo, config: config} =
+        insert(:job)
+
+      %{elixir: elixir, erlang: erlang, environment: env} = config
+      repo_slug = "#{repo.owner}/#{repo.name}"
+
+      {:ok, %{"data" => data}} =
+        context.conn
+        |> authenticate!
+        |> post("/runner-api/jobs/claim", %{})
+        |> decode_response_body
+
+      assert %{
+               "branch_name" => ^branch,
+               "commit_sha" => ^commit_sha,
+               "config" => %{
+                 "deps" => %{"docker" => []},
+                 "elixir_version" => ^elixir,
+                 "environment_variables" => ^env,
+                 "erlang_version" => ^erlang
+               },
+               "id" => ^uuid,
+               "repo_slug" => ^repo_slug
+             } = data
+    end
+
+    test "return error if runner authentication fails", context do
+      resp =
+        context.conn
+        |> put_req_header("authorization", "Basic " <> Base.encode64("test:test"))
+        |> post("/runner-api/jobs/claim", %{})
+
+      assert "401 Unauthorized" = resp.resp_body
+    end
+  end
+
+  defp authenticate!(conn) do
+    %{name: name, api_key: api_key} = insert(:runner)
+
+    conn
+    |> put_req_header("authorization", "Basic " <> Base.encode64("#{name}:#{api_key}"))
+  end
+end

test/elixir_bench_web/views/job_view_test.exs

@@ -0,0 +1,52 @@
+defmodule ElixirBenchWeb.JobViewTest do
+  use ElixirBenchWeb.ConnCase, async: true
+
+  # Bring render/3 and render_to_string/3 for testing custom views
+  import Phoenix.View
+
+  test "render index.json given job without docker dependencies and environment variables" do
+    repo = build(:repo, %{owner: "owner", name: "name"})
+    job = build(:job, repo: repo)
+
+    %{uuid: uuid, branch_name: branch, commit_sha: commit_sha, config: config} = job
+    %{elixir: elixir, erlang: erlang} = config
+
+    %{data: [job_data]} = render(ElixirBenchWeb.JobView, "index.json", %{jobs: [job], repo: repo})
+
+    assert %{
+             branch_name: ^branch,
+             commit_sha: ^commit_sha,
+             config: %{
+               deps: %{docker: []},
+               elixir_version: ^elixir,
+               environment_variables: %{},
+               erlang_version: ^erlang
+             },
+             id: ^uuid,
+             repo_slug: "owner/name"
+           } = job_data
+  end
+
+  test "render index.json given job with docker dependencies" do
+    repo = build(:repo)
+    job = build(:job, repo: repo) |> with_docker_deps
+
+    %{config: %{deps: %{docker: [dep]}, environment: environment}} = job
+
+    %{container_name: container_name, environment: docker_env, image: image, wait: %{port: port}} =
+      dep
+
+    %{data: [job_data]} = render(ElixirBenchWeb.JobView, "index.json", %{jobs: [job], repo: repo})
+
+    assert %{
+             environment_variables: ^environment
+           } = job_data.config
+
+    assert %{
+             container_name: ^container_name,
+             environment: ^docker_env,
+             image: ^image,
+             wait: %{port: ^port}
+           } = hd(job_data.config.deps.docker)
+  end
+end

test/support/factory/elixir_bench_factory.ex

@@ -2,7 +2,8 @@ defmodule ElixirBench.Factory do
   use ExMachina.Ecto, repo: ElixirBench.Repo
 
   alias ElixirBench.Repos
-  alias ElixirBench.Benchmarks.{Benchmark, Measurement, Job, Runner}
+  alias ElixirBench.Benchmarks.{Benchmark, Measurement, Job, Runner, Config}
+  alias Config.{Dep, Dep.Docker, Dep.Docker.Wait}
 
   def runner_factory do
     %Runner{
@@ -35,10 +36,33 @@ defmodule ElixirBench.Factory do
       elixir_version: "1.5.2",
       erlang_version: "20.1",
       repo: build(:repo),
-      uuid: Ecto.UUID.generate()
+      uuid: Ecto.UUID.generate(),
+      config: build(:config)
     }
   end
 
+  def config_factory do
+    %Config{
+      elixir: "1.5.2",
+      erlang: "20.1"
+    }
+  end
+
+  def with_docker_deps(%Job{} = job) do
+    deps = %Dep{
+      docker: [
+        %Docker{
+          container_name: "postgres",
+          image: "postgres:9.6.6-alpine",
+          wait: %Wait{port: 5432},
+          environment: %{"MYSQL_ALLOW_EMPTY_PASSWORD" => "true"}
+        }
+      ]
+    }
+
+    %{job | config: %{job.config | deps: deps}}
+  end
+
   def measurement_factory do
     repo = insert(:repo)