Publish api can now create assessment

lib/polar/machines.ex

@@ -21,7 +21,7 @@ defmodule Polar.Machines do
 
   alias __MODULE__.Assessment
 
-  defdelegate create_assessment(check, params),
+  defdelegate create_assessment(version, params),
     to: Assessment.Manager,
     as: :create
 end

lib/polar/machines/assessment.ex

@@ -15,19 +15,18 @@ defmodule Polar.Machines.Assessment do
   |> governs(:current_state, on: Event)
 
   @valid_attrs ~w(
-    version_id 
+    check_id 
     cluster_id
   )a
 
   @required_attrs ~w(
-    version_id
+    check_id
     cluster_id
   )a
 
   schema "assessments" do
     field :current_state, :string, default: "created"
 
-    field :check_slug, :string, virtual: true
     belongs_to :check, Check
     belongs_to :cluster, Cluster
 

lib/polar/machines/assessment/manager.ex

@@ -2,8 +2,8 @@ defmodule Polar.Machines.Assessment.Manager do
   alias Polar.Repo
   alias Polar.Machines.Assessment
 
-  def create(check, params) do
-    %Assessment{check_id: check.id}
+  def create(version, params) do
+    %Assessment{version_id: version.id}
     |> Assessment.changeset(params)
     |> Repo.insert()
   end

lib/polar_web/controllers/publish/testing/assessment_controller.ex

@@ -4,17 +4,19 @@ defmodule PolarWeb.Publish.Testing.AssessmentController do
   alias Polar.Repo
   alias Polar.Machines
 
-  alias Polar.Machines.Check
+  alias Polar.Streams.Version
 
   def create(conn, %{
-        "check_id" => check_id,
+        "version_id" => version_id,
         "assessment" => assessment_params
       }) do
-    with %Check{} = check <- Repo.get(Check, check_id),
+    with %Version{} = check <- Repo.get(Version, version_id),
          {:ok, assessment} <- Machines.create_assessment(check, assessment_params) do
       assessment = Repo.preload(assessment, [:check])
 
-      render(conn, :create, %{assessment: assessment})
+      conn
+      |> put_status(:created)
+      |> render(:create, %{assessment: assessment})
     end
   end
 end

lib/polar_web/router.ex

@@ -113,7 +113,7 @@ defmodule PolarWeb.Router do
 
         resources "/assessments/:assessment_id/events", EventController, only: [:create]
 
-        scope "/checks/:check_id" do
+        scope "/versions/:version_id" do
           resources "/assessments", Testing.AssessmentController, only: [:create]
         end
       end

test/polar/machines/assessment/manager_test.exs

@@ -45,8 +45,8 @@ defmodule Polar.Machines.Assessment.ManagerTest do
   describe "create assessment" do
     test "successfully create assessment", %{check: check, cluster: cluster, version: version} do
       assert {:ok, assessment} =
-               Machines.create_assessment(check, %{
-                 version_id: version.id,
+               Machines.create_assessment(version, %{
+                 check_id: check.id,
                  cluster_id: cluster.id
                })
 

test/polar/machines/assessment/transitions_test.exs

@@ -43,8 +43,8 @@ defmodule Polar.Machines.Assessment.TransitionsTest do
       Streams.create_version(product, valid_version_attributes(2))
 
     {:ok, assessment} =
-      Machines.create_assessment(check, %{
-        version_id: version.id,
+      Machines.create_assessment(version, %{
+        check_id: check.id,
         cluster_id: cluster.id
       })
 

test/polar_web/controllers/publish/testing/assessment_controller_test.exs

@@ -0,0 +1,81 @@
+defmodule PolarWeb.Publish.Testing.AssessmentControllerTest do
+  use PolarWeb.ConnCase
+
+  alias Polar.Accounts
+  alias Polar.Machines
+  alias Polar.Streams
+
+  import Polar.AccountsFixtures
+  import Polar.StreamsFixtures
+
+  setup do
+    password = Accounts.generate_automation_password()
+
+    bot = bot_fixture(%{password: password})
+
+    user = Accounts.get_user_by_email_and_password(bot.email, password)
+
+    session_token =
+      Accounts.generate_user_session_token(user)
+      |> Base.encode64()
+
+    conn =
+      build_conn()
+      |> put_req_header("authorization", session_token)
+
+    {:ok, check} =
+      Machines.create_check(%{
+        name: "ipv4-issuing",
+        description: "issue ipv4 correctly"
+      })
+
+    {:ok, cluster} =
+      Machines.create_cluster(%{
+        name: "example",
+        type: "lxd",
+        arch: "amd64",
+        credential_endpoint: "some.cluster.com:8443",
+        credential_password: "sometoken",
+        credential_password_confirmation: "sometoken"
+      })
+
+    {:ok, product} =
+      Streams.create_product(%{
+        aliases: ["alpine/3.19", "alpine/3.19/default"],
+        arch: "amd64",
+        os: "Alpine",
+        release: "3.19",
+        release_title: "3.19",
+        variant: "default",
+        requirements: %{
+          secureboot: "false"
+        }
+      })
+
+    {:ok, version} =
+      Streams.create_version(product, valid_version_attributes(2))
+
+    {:ok, version: version, cluster: cluster, check: check, conn: conn}
+  end
+
+  describe "POST /publish/testing/versions/:version_id/assessments" do
+    test "successfully create assessment", %{
+      version: version,
+      conn: conn,
+      check: check,
+      cluster: cluster
+    } do
+      conn =
+        post(conn, ~p"/publish/testing/versions/#{version.id}/assessments", %{
+          "assessment" => %{
+            "check_id" => check.id,
+            "cluster_id" => cluster.id
+          }
+        })
+
+      assert %{"data" => data} = json_response(conn, 201)
+
+      assert %{"id" => _id, "current_state" => "created", "check" => _check} = data
+    end
+  end
+end