Write and test describe endpoint

Author: VeljkoMaksimovic

ee/ephemeral_environments/lib/ephemeral_environments/grpc/ephemeral_environments_server.ex

@@ -26,8 +26,21 @@ defmodule EphemeralEnvironments.Grpc.EphemeralEnvironmentsServer do
     end
   end
 
-  def describe(_request, _stream) do
-    %DescribeResponse{}
+  def describe(request, _stream) do
+    case EphemeralEnvironments.Service.EphemeralEnvironmentType.describe(
+           request.id,
+           request.org_id
+         ) do
+      {:ok, environment_type} ->
+        # Note: instances field will be added once we implement instance management
+        %{environment_type: environment_type, instances: []}
+
+      {:error, :not_found} ->
+        raise GRPC.RPCError, status: :not_found, message: "Environment type not found"
+
+      {:error, error_message} ->
+        raise GRPC.RPCError, status: :unknown, message: error_message
+    end
   end
 
   def create(request, _stream) do

ee/ephemeral_environments/lib/ephemeral_environments/service/ephemeral_environment_type.ex

@@ -22,6 +22,27 @@ defmodule EphemeralEnvironments.Service.EphemeralEnvironmentType do
     {:ok, environment_types}
   end
 
+  @doc """
+  Describes a specific ephemeral environment type by ID and org_id.
+
+  ## Parameters
+    - id: String UUID of the environment type
+    - org_id: String UUID of the organization
+
+  ## Returns
+    - {:ok, map} on success
+    - {:error, :not_found} if the environment type doesn't exist
+  """
+  def describe(id, org_id) when is_binary(id) and is_binary(org_id) do
+    Schema
+    |> where([e], e.id == ^id and e.org_id == ^org_id)
+    |> Repo.one()
+    |> case do
+      nil -> {:error, :not_found}
+      record -> {:ok, struct_to_map(record)}
+    end
+  end
+
   @doc """
   Creates a new ephemeral environment type.
 
@@ -58,6 +79,14 @@ defmodule EphemeralEnvironments.Service.EphemeralEnvironmentType do
     struct
     |> Map.from_struct()
     |> Map.drop([:__meta__])
+    |> rename_timestamp_fields()
+  end
+
+  # Rename Ecto's inserted_at to created_at to match proto definition
+  defp rename_timestamp_fields(map) do
+    map
+    |> Map.put(:created_at, map[:inserted_at])
+    |> Map.delete(:inserted_at)
   end
 
   defp format_errors(changeset) do

ee/ephemeral_environments/test/grpc/ephemeral_environments_server_test.exs

@@ -3,12 +3,14 @@ defmodule EphemeralEnvironments.Grpc.EphemeralEnvironmentsServerTest do
 
   alias EphemeralEnvironments.Repo
   alias EphemeralEnvironments.Repo.EphemeralEnvironmentType, as: Schema
+  alias Support.Factories
 
   alias InternalApi.EphemeralEnvironments.{
     CreateRequest,
     EphemeralEnvironmentType,
     EphemeralEnvironments,
-    ListRequest
+    ListRequest,
+    DescribeRequest
   }
 
   @org_id Ecto.UUID.generate()
@@ -35,14 +37,11 @@ defmodule EphemeralEnvironments.Grpc.EphemeralEnvironmentsServerTest do
 
     test "returns all environment types for a specific org", %{channel: channel} do
       # Create environment types for the test org
-      {:ok, env1} =
-        Support.Factories.EphemeralEnvironmentsType.insert(org_id: @org_id, name: "Development")
-
-      {:ok, env1} =
-        Support.Factories.EphemeralEnvironmentsType.insert(org_id: @org_id, name: "Staging")
+      {:ok, _} = Factories.EphemeralEnvironmentsType.insert(org_id: @org_id, name: "Development")
+      {:ok, _} = Factories.EphemeralEnvironmentsType.insert(org_id: @org_id, name: "Staging")
 
       # Create environment type for a different org (should not be returned)
-      {:ok, _} = Support.Factories.EphemeralEnvironmentsType.insert(org_id: Ecto.UUID.generate())
+      {:ok, _} = Factories.EphemeralEnvironmentsType.insert(org_id: Ecto.UUID.generate())
 
       request = %ListRequest{org_id: @org_id}
       {:ok, response} = EphemeralEnvironments.Stub.list(channel, request)
@@ -61,11 +60,11 @@ defmodule EphemeralEnvironments.Grpc.EphemeralEnvironmentsServerTest do
     test "handles multiple orgs correctly", %{channel: channel} do
       org2_id = Ecto.UUID.generate()
 
-      {:ok, _} = Support.Factories.EphemeralEnvironmentsType.insert(org_id: @org_id)
-      {:ok, _} = Support.Factories.EphemeralEnvironmentsType.insert(org_id: @org_id)
+      {:ok, _} = Factories.EphemeralEnvironmentsType.insert(org_id: @org_id)
+      {:ok, _} = Factories.EphemeralEnvironmentsType.insert(org_id: @org_id)
 
       # Create environment types for org2
-      {:ok, _} = Support.Factories.EphemeralEnvironmentsType.insert(org_id: org2_id)
+      {:ok, _} = Factories.EphemeralEnvironmentsType.insert(org_id: org2_id)
 
       # Request for org1
       request1 = %ListRequest{org_id: @org_id}
@@ -82,6 +81,50 @@ defmodule EphemeralEnvironments.Grpc.EphemeralEnvironmentsServerTest do
   end
 
   describe "describe/2" do
+    test "returns environment type when it exists", %{channel: channel} do
+      {:ok, env_type} =
+        Factories.EphemeralEnvironmentsType.insert(
+          org_id: @org_id,
+          name: "Production",
+          description: "Production environment",
+          created_by: @user_id,
+          state: :ready,
+          max_number_of_instances: 20
+        )
+
+      request = %DescribeRequest{id: env_type.id, org_id: @org_id}
+
+      {:ok, response} = EphemeralEnvironments.Stub.describe(channel, request)
+
+      assert response.environment_type.id == env_type.id
+      assert response.environment_type.org_id == @org_id
+      assert response.environment_type.name == "Production"
+      assert response.environment_type.description == "Production environment"
+      assert response.environment_type.created_by == @user_id
+      assert response.environment_type.last_updated_by == @user_id
+      assert response.environment_type.state == :TYPE_STATE_READY
+      assert response.environment_type.max_number_of_instances == 20
+      assert_recent_timestamp(DateTime.from_unix!(response.environment_type.created_at.seconds))
+      assert_recent_timestamp(DateTime.from_unix!(response.environment_type.updated_at.seconds))
+      assert response.instances == []
+    end
+
+    test "returns not_found error when environment type doesn't exist", %{channel: channel} do
+      request = %DescribeRequest{id: Ecto.UUID.generate(), org_id: @org_id}
+      {:error, %GRPC.RPCError{} = error} = EphemeralEnvironments.Stub.describe(channel, request)
+
+      assert error.status == 5
+      assert error.message == "Environment type not found"
+    end
+
+    test "returns not_found when querying with wrong org_id", %{channel: channel} do
+      {:ok, env_type} = Factories.EphemeralEnvironmentsType.insert(org_id: @org_id)
+      request = %DescribeRequest{id: env_type.id, org_id: Ecto.UUID.generate()}
+      {:error, %GRPC.RPCError{} = error} = EphemeralEnvironments.Stub.describe(channel, request)
+
+      assert error.status == 5
+      assert error.message == "Environment type not found"
+    end
   end
 
   describe "create/2" do
@@ -117,20 +160,20 @@ defmodule EphemeralEnvironments.Grpc.EphemeralEnvironmentsServerTest do
       assert env_type.state == :TYPE_STATE_DRAFT
       assert env_type.max_number_of_instances == 5
       assert_recent_timestamp(DateTime.from_unix!(env_type.updated_at.seconds))
+      assert_recent_timestamp(DateTime.from_unix!(env_type.created_at.seconds))
 
       # Validate database record exists
       assert Repo.get(Schema, env_type.id)
     end
 
     test "fails to create environment type with duplicate name in same org", %{channel: channel} do
-      {:ok, _} = Support.Factories.EphemeralEnvironmentsType.insert(org_id: @org_id, name: "Test")
+      {:ok, _} = Factories.EphemeralEnvironmentsType.insert(org_id: @org_id, name: "Test")
 
       duplicate_request = %CreateRequest{
         environment_type: %EphemeralEnvironmentType{
           org_id: @org_id,
           name: "Test",
-          max_number_of_instances: 1,
-          created_by: @user_id
+          max_number_of_instances: 1
         }
       }
 
@@ -141,14 +184,13 @@ defmodule EphemeralEnvironments.Grpc.EphemeralEnvironmentsServerTest do
     end
 
     test "allows same name in different orgs", %{channel: channel} do
-      {:ok, _} = Support.Factories.EphemeralEnvironmentsType.insert(org_id: @org_id, name: "Test")
+      {:ok, _} = Factories.EphemeralEnvironmentsType.insert(org_id: @org_id, name: "Test")
 
       request = %CreateRequest{
         environment_type: %EphemeralEnvironmentType{
           org_id: Ecto.UUID.generate(),
           name: "Test",
-          max_number_of_instances: 1,
-          created_by: @user_id
+          max_number_of_instances: 1
         }
       }