Adds Github webhook endpoint (#25)

* Adds Github webhook endpoint

* Adds Github namespace to WebHooksController

Signed-off-by: Tallys Martins <tallysmartins@gmail.com>

* Apply review changes one

* Apply review changes 2

- closes #26

Author: tallysmartins

lib/elixir_bench/repos/repos.ex

@@ -48,6 +48,8 @@ defmodule ElixirBench.Repos do
     Repo.delete(repo)
   end
 
+  defp parse_slug(slug, callback) when is_nil(slug), do: {:error, :invalid_slug}
+
   defp parse_slug(slug, callback) do
     case String.split(slug, "/", trim: true, parts: 2) do
       [owner, name] -> callback.(owner, name)

lib/elixir_bench_web/controllers/fallback_controller.ex

@@ -12,9 +12,27 @@ defmodule ElixirBenchWeb.FallbackController do
     |> render(ElixirBenchWeb.ChangesetView, "error.json", changeset: changeset)
   end
 
+  def call(conn, {:error, :bad_request}) do
+    conn
+    |> put_status(:bad_request)
+    |> render(ElixirBenchWeb.ErrorView, :"400")
+  end
+
   def call(conn, {:error, :not_found}) do
     conn
     |> put_status(:not_found)
     |> render(ElixirBenchWeb.ErrorView, :"404")
   end
+
+  def call(conn, {:error, :unprocessable_entity}) do
+    conn
+    |> put_status(:unprocessable_entity)
+    |> render(ElixirBenchWeb.ErrorView, :"422")
+  end
+
+  def call(conn, {:error, :failed_config_fetch}) do
+    conn
+    |> put_status(:internal_server_error)
+    |> render(ElixirBenchWeb.ErrorView, :"500")
+  end
 end

lib/elixir_bench_web/controllers/github/webhooks_controller.ex

@@ -0,0 +1,95 @@
+defmodule ElixirBenchWeb.Github.WebHooks do
+  use ElixirBenchWeb, :controller
+
+  alias ElixirBench.{Benchmarks, Repos}
+
+  action_fallback(ElixirBenchWeb.FallbackController)
+  @accepted_events ["ping", "push", "pull_request"]
+
+  def handle(conn, params) do
+    with {:ok, payload} <- check_payload_params(params),
+         {:ok, event_name} <- validate_event_headers(conn) do
+      event_name
+      |> extract_job_attrs(payload)
+      |> process_event(conn)
+    end
+  end
+
+  defp extract_job_attrs("push", payload) do
+    slug = get_in(payload, ["repository", "full_name"])
+    branch_name = get_in(payload, ["ref"])
+    commit_sha = get_in(payload, ["after"])
+
+    %{slug: slug, branch_name: branch_name, commit_sha: commit_sha}
+  end
+
+  defp extract_job_attrs("pull_request", payload) do
+    # data is fetched from sender's repository refered as "head"
+    slug = get_in(payload, ["pull_request", "head", "repo", "full_name"])
+    branch_name = get_in(payload, ["pull_request", "head", "ref"])
+    commit_sha = get_in(payload, ["pull_request", "head", "sha"])
+
+    %{slug: slug, branch_name: branch_name, commit_sha: commit_sha}
+  end
+
+  defp extract_job_attrs(event, _payload), do: event
+
+  defp process_event(job_data, conn) when is_map(job_data) do
+    %{slug: slug, branch_name: branch_name, commit_sha: commit_sha} = job_data
+
+    with {:ok, %Repos.Repo{} = repo} <- Repos.fetch_repo_by_slug(slug),
+         {:ok, job} <-
+           Benchmarks.create_job(repo, %{branch_name: branch_name, commit_sha: commit_sha}) do
+      conn
+      |> render(ElixirBenchWeb.JobView, "show.json", job: job, repo: repo)
+    else
+      {:error, error} -> handle_errors({:error, error})
+    end
+  end
+
+  defp process_event(job_data, conn) do
+    case job_data do
+      "ping" ->
+        json(conn, %{message: "pong"})
+
+      _ ->
+        handle_errors({:error, :unprocessable_entity})
+    end
+  end
+
+  defp check_payload_params(params) do
+    if p = params["payload"] do
+      case Antidote.decode(p) do
+        {:ok, payload} ->
+          {:ok, payload}
+
+        {:error, reason} ->
+          handle_errors({:error, reason})
+      end
+    else
+      handle_errors({:error, :bad_request})
+    end
+  end
+
+  defp validate_event_headers(conn) do
+    with [event] <- get_req_header(conn, "x-github-event"),
+         true <- event in @accepted_events do
+      {:ok, event}
+    else
+      _ -> handle_errors({:error, :unprocessable_entity})
+    end
+  end
+
+  defp handle_errors(errors) do
+    case errors do
+      {:error, %Ecto.Changeset{} = changeset} ->
+        {:error, changeset}
+
+      {:error, :unprocessable_entity} ->
+        {:error, :unprocessable_entity}
+
+      _ ->
+        {:error, :bad_request}
+    end
+  end
+end

lib/elixir_bench_web/router.ex

@@ -18,6 +18,12 @@ defmodule ElixirBenchWeb.Router do
     put("/jobs/:id", JobController, :update)
   end
 
+  scope "/hooks", ElixirBenchWeb do
+    pipe_through [:api]
+
+    post("/handle", Github.WebHooks, :handle)
+  end
+
   scope "/api" do
     pipe_through :api
 

lib/elixir_bench_web/views/error_view.ex

@@ -1,10 +1,18 @@
 defmodule ElixirBenchWeb.ErrorView do
   use ElixirBenchWeb, :view
 
+  def render("400.json", _assigns) do
+    %{errors: %{detail: "Bad request"}}
+  end
+
   def render("404.json", _assigns) do
     %{errors: %{detail: "Page not found"}}
   end
 
+  def render("422.json", _assigns) do
+    %{errors: %{detail: "Unprocessable entity"}}
+  end
+
   def render("500.json", _assigns) do
     %{errors: %{detail: "Internal server error"}}
   end

test/elixir_bench_web/controllers/github/webhooks_controller_test.exs

@@ -0,0 +1,139 @@
+defmodule ElixirBenchWeb.Github.WebHooksControllerTest do
+  use ElixirBenchWeb.ConnCase, async: false
+
+  import ElixirBenchWeb.TestHelpers
+
+  alias ElixirBench.{Repos.Repo, Benchmarks.Job}
+
+  @github_repo_attrs %{name: "public-repo", owner: "baxterthehacker"}
+
+  describe "handle/2" do
+    test "create job given pull request event", context do
+      insert(:repo, @github_repo_attrs)
+      params = %{"payload" => pull_request_payload()}
+
+      assert_difference(Repo, 0) do
+        assert_difference(Job, 1) do
+          {:ok, %{"data" => data}} =
+            context.conn
+            |> set_headers("pull_request")
+            |> post("/hooks/handle", params)
+            |> decode_response_body
+        end
+      end
+
+      assert %{"branch_name" => "changes", "repo_slug" => "baxterthehacker/public-repo"} = data
+    end
+
+    test "create job given push event", context do
+      insert(:repo, @github_repo_attrs)
+      params = %{"payload" => push_payload()}
+
+      assert_difference(Repo, 0) do
+        assert_difference(Job, 1) do
+          {:ok, %{"data" => data}} =
+            context.conn
+            |> set_headers("push")
+            |> post("/hooks/handle", params)
+            |> decode_response_body
+        end
+      end
+
+      assert %{"branch_name" => "changes", "repo_slug" => "baxterthehacker/public-repo"} = data
+    end
+
+    test "respond to ping event", context do
+      response =
+        context.conn
+        |> set_headers("ping")
+        |> post("/hooks/handle", %{"payload" => ~s({"data": "some data"})})
+
+      assert {:ok, %{"message" => "pong"}} = decode_response_body(response)
+      assert 200 = response.status
+    end
+
+    test "not break given unexpected pull request event payload scheme", context do
+      insert(:repo, @github_repo_attrs)
+      params = %{"payload" => ~s({"data": "some data"})}
+
+      assert_difference(Repo, 0) do
+        assert_difference(Job, 0) do
+          {:ok, %{"errors" => errors}} =
+            context.conn
+            |> set_headers("pull_request")
+            |> post("/hooks/handle", params)
+            |> decode_response_body
+        end
+      end
+
+      assert %{"detail" => "Bad request"} = errors
+    end
+
+    test "not break given unexpected push event payload scheme", context do
+      insert(:repo, @github_repo_attrs)
+      params = %{"payload" => ~s({"data": "some data"})}
+
+      assert_difference(Repo, 0) do
+        assert_difference(Job, 0) do
+          {:ok, %{"errors" => errors}} =
+            context.conn
+            |> set_headers("push")
+            |> post("/hooks/handle", params)
+            |> decode_response_body
+        end
+      end
+
+      assert %{"detail" => "Bad request"} = errors
+    end
+
+    test "return error given unprocessable event in header", context do
+      insert(:repo, @github_repo_attrs)
+      params = %{"payload" => push_payload()}
+
+      {:ok, %{"errors" => errors}} =
+        context.conn
+        |> set_headers("randomevent")
+        |> post("/hooks/handle", params)
+        |> decode_response_body
+
+      assert %{"detail" => "Unprocessable entity"} = errors
+    end
+
+    test "return error when event headers not present", context do
+      insert(:repo, @github_repo_attrs)
+      params = %{"payload" => push_payload()}
+
+      {:ok, %{"errors" => errors}} =
+        context.conn
+        |> post("/hooks/handle", params)
+        |> decode_response_body
+
+      assert %{"detail" => "Unprocessable entity"} = errors
+    end
+
+    test "return error when payload missing", context do
+      insert(:repo, @github_repo_attrs)
+
+      {:ok, %{"errors" => errors}} =
+        context.conn
+        |> set_headers("pull_request")
+        |> post("/hooks/handle", %{"payload" => ""})
+        |> decode_response_body
+
+      assert %{"detail" => "Bad request"} = errors
+
+      {:ok, %{"errors" => errors}} =
+        context.conn
+        |> set_headers("pull_request")
+        |> post("/hooks/handle")
+        |> decode_response_body
+
+      assert %{"detail" => "Bad request"} = errors
+    end
+  end
+
+  defp set_headers(conn, event) do
+    conn
+    |> put_req_header("x-github-event", event)
+  end
+end

test/elixir_bench_web/schema/schema_test.exs

@@ -458,10 +458,4 @@ defmodule ElixirBenchWeb.SchemaTest do
     conn
     |> post("/api", AbsintheHelpers.query_skeleton(query))
   end
-
-  defp decode_response_body(response) do
-    response
-    |> Map.get(:resp_body)
-    |> Antidote.decode()
-  end
 end

test/support/conn_case.ex

@@ -21,6 +21,7 @@ defmodule ElixirBenchWeb.ConnCase do
       use Phoenix.ConnTest
       import ElixirBenchWeb.Router.Helpers
       import ElixirBench.Factory
+      import ElixirBench.GithubFactory
 
       # The default endpoint for testing
       @endpoint ElixirBenchWeb.Endpoint

test/support/factory.ex …/support/factory/elixir_bench_factory.extest/support/factory.ex renamed to test/support/factory/elixir_bench_factory.ex test/support/factory.ex renamed to test/support/factory/elixir_bench_factory.ex

@@ -0,0 +1,28 @@
+defmodule ElixirBench.GithubFactory do
+  @fixtures_dir "test/support/fixtures"
+
+  # Returns the payload of a pull request activity in a given repository.
+  # Payload example is read from fixtures/pull_request.json and was copied from
+  # https://developer.github.com/v3/activity/events/types/#pullrequestevent
+  def pull_request_payload() do
+    case read_file("pull_request.json") do
+      {:ok, data} -> data
+      {:error, _} -> ""
+    end
+  end
+
+  # Returns the payload of a push activity in a given repository.
+  # Payload example is read from fixtures/push.json and was copied from
+  # https://developer.github.com/v3/activity/events/types/#pushevent
+  def push_payload() do
+    case read_file("push.json") do
+      {:ok, data} -> data
+      {:error, _} -> ""
+    end
+  end
+
+  def read_file(file) do
+    Path.join(@fixtures_dir, file)
+    |> File.read()
+  end
+end