coder · sreya · Dec 8, 2023 · Dec 6, 2023 · Dec 6, 2023 · Dec 7, 2023
diff --git a/coderd/database/dbmem/dbmem.go b/coderd/database/dbmem/dbmem.go
@@ -7289,12 +7289,7 @@ func (q *FakeQuerier) GetAuthorizedWorkspaces(ctx context.Context, arg database.
 			}
 		}
 
-		// We omit locked workspaces by default.
-		if arg.IsDormant == "" && workspace.DormantAt.Valid {
-			continue
-		}
-
-		if arg.IsDormant != "" && !workspace.DormantAt.Valid {
+		if arg.Dormant && !workspace.DormantAt.Valid {
 			continue
 		}
 

diff --git a/coderd/database/modelqueries.go b/coderd/database/modelqueries.go
@@ -221,7 +221,7 @@ func (q *sqlQuerier) GetAuthorizedWorkspaces(ctx context.Context, arg GetWorkspa
 		arg.Name,
 		arg.HasAgent,
 		arg.AgentInactiveDisconnectTimeoutSeconds,
-		arg.IsDormant,
+		arg.Dormant,
 		arg.LastUsedBefore,
 		arg.LastUsedAfter,
 		arg.Offset,

diff --git a/coderd/database/queries.sql.go b/coderd/database/queries.sql.go
diff --git a/coderd/database/queries/workspaces.sql b/coderd/database/queries/workspaces.sql
@@ -239,13 +239,11 @@ WHERE
 			) > 0
 		ELSE true
 	END
-	-- Filter by dormant workspaces. By default we do not return dormant
-	-- workspaces since they are considered soft-deleted.
+	-- Filter by dormant workspaces.
 	AND CASE
-		WHEN @is_dormant :: text != '' THEN
+		WHEN @dormant :: boolean != 'false' THEN
 			dormant_at IS NOT NULL
-		ELSE
-			dormant_at IS NULL
+		ELSE true
 	END
 	-- Filter by last_used
 	AND CASE

diff --git a/coderd/searchquery/search.go b/coderd/searchquery/search.go
@@ -107,7 +107,7 @@ func Workspaces(query string, page codersdk.Pagination, agentInactiveDisconnectT
 	filter.Name = parser.String(values, "", "name")
 	filter.Status = string(httpapi.ParseCustom(parser, values, "", "status", httpapi.ParseEnum[database.WorkspaceStatus]))
 	filter.HasAgent = parser.String(values, "", "has-agent")
-	filter.IsDormant = parser.String(values, "", "is-dormant")
+	filter.Dormant = parser.Boolean(values, false, "dormant")
 	filter.LastUsedAfter = parser.Time3339Nano(values, time.Time{}, "last_used_after")
 	filter.LastUsedBefore = parser.Time3339Nano(values, time.Time{}, "last_used_before")
 

diff --git a/coderd/workspaces_test.go b/coderd/workspaces_test.go
@@ -1503,43 +1503,50 @@ func TestWorkspaceFilterManual(t *testing.T) {
 		}, testutil.IntervalMedium, "agent status timeout")
 	})
 
-	t.Run("IsDormant", func(t *testing.T) {
+	t.Run("Dormant", func(t *testing.T) {
 		// this test has a licensed counterpart in enterprise/coderd/workspaces_test.go: FilterQueryHasDeletingByAndLicensed
 		t.Parallel()
-		client := coderdtest.New(t, &coderdtest.Options{
-			IncludeProvisionerDaemon: true,
-		})
+		client, db := coderdtest.NewWithDatabase(t, nil)
 		user := coderdtest.CreateFirstUser(t, client)
-		authToken := uuid.NewString()
-		version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{
-			Parse:          echo.ParseComplete,
-			ProvisionPlan:  echo.PlanComplete,
-			ProvisionApply: echo.ProvisionApplyWithAgent(authToken),
-		})
-		template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
-		_ = coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)
+		template := dbfake.TemplateVersion(t, db).Seed(database.TemplateVersion{
+			OrganizationID: user.OrganizationID,
+			CreatedBy:      user.UserID,
+		}).Do().Template
 
 		// update template with inactivity ttl
 		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 		defer cancel()
 
-		dormantWorkspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
-		_ = coderdtest.AwaitWorkspaceBuildJobCompleted(t, client, dormantWorkspace.LatestBuild.ID)
+		dormantWorkspace := dbfake.WorkspaceBuild(t, db, database.Workspace{
+			TemplateID:     template.ID,
+			OwnerID:        user.UserID,
+			OrganizationID: user.OrganizationID,
+		}).Do().Workspace
 
 		// Create another workspace to validate that we do not return active workspaces.
-		_ = coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
-		_ = coderdtest.AwaitWorkspaceBuildJobCompleted(t, client, dormantWorkspace.LatestBuild.ID)
+		_ = dbfake.WorkspaceBuild(t, db, database.Workspace{
+			TemplateID:     template.ID,
+			OwnerID:        user.UserID,
+			OrganizationID: user.OrganizationID,
+		}).Do()
 
 		err := client.UpdateWorkspaceDormancy(ctx, dormantWorkspace.ID, codersdk.UpdateWorkspaceDormancy{
 			Dormant: true,
 		})
 		require.NoError(t, err)
 
-		res, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{
-			FilterQuery: "is-dormant:true",
+		// Test that no filter returns both workspaces.
+		res, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{})
+		require.NoError(t, err)
+		require.Len(t, res.Workspaces, 2)
+
+		// Test that filtering for dormant only returns our dormant workspace.
+		res, err = client.Workspaces(ctx, codersdk.WorkspaceFilter{
+			FilterQuery: "dormant:true",
 		})
 		require.NoError(t, err)
 		require.Len(t, res.Workspaces, 1)
+		require.Equal(t, dormantWorkspace.ID, res.Workspaces[0].ID)
 		require.NotNil(t, res.Workspaces[0].DormantAt)
 	})
 

diff --git a/enterprise/coderd/workspaces_test.go b/enterprise/coderd/workspaces_test.go
@@ -991,53 +991,55 @@ func TestExecutorAutostartBlocked(t *testing.T) {
 func TestWorkspacesFiltering(t *testing.T) {
 	t.Parallel()
 
-	t.Run("IsDormant", func(t *testing.T) {
+	t.Run("Dormant", func(t *testing.T) {
 		t.Parallel()
 
 		ctx := testutil.Context(t, testutil.WaitMedium)
-		client, user := coderdenttest.New(t, &coderdenttest.Options{
+		client, db, owner := coderdenttest.NewWithDatabase(t, &coderdenttest.Options{
 			Options: &coderdtest.Options{
-				IncludeProvisionerDaemon: true,
-				TemplateScheduleStore:    schedule.NewEnterpriseTemplateScheduleStore(agplUserQuietHoursScheduleStore()),
+				TemplateScheduleStore: schedule.NewEnterpriseTemplateScheduleStore(agplUserQuietHoursScheduleStore()),
 			},
 			LicenseOptions: &coderdenttest.LicenseOptions{
 				Features: license.Features{codersdk.FeatureAdvancedTemplateScheduling: 1},
 			},
 		})
-		templateAdmin, _ := coderdtest.CreateAnotherUser(t, client, user.OrganizationID, rbac.RoleTemplateAdmin())
+		templateAdminClient, templateAdmin := coderdtest.CreateAnotherUser(t, client, owner.OrganizationID, rbac.RoleTemplateAdmin())
 
-		// Create a template version that passes to get a functioning workspace.
-		version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{
-			Parse:          echo.ParseComplete,
-			ProvisionPlan:  echo.PlanComplete,
-			ProvisionApply: echo.ApplyComplete,
-		})
-		coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)
-
-		template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
+		resp := dbfake.TemplateVersion(t, db).Seed(database.TemplateVersion{
+			OrganizationID: owner.OrganizationID,
+			CreatedBy:      owner.UserID,
+		}).Do()
 
-		dormantWS1 := coderdtest.CreateWorkspace(t, templateAdmin, user.OrganizationID, template.ID)
-		coderdtest.AwaitWorkspaceBuildJobCompleted(t, templateAdmin, dormantWS1.LatestBuild.ID)
+		dormantWS1 := dbfake.WorkspaceBuild(t, db, database.Workspace{
+			OwnerID:        templateAdmin.ID,
+			OrganizationID: owner.OrganizationID,
+		}).Do().Workspace
 
-		dormantWS2 := coderdtest.CreateWorkspace(t, templateAdmin, user.OrganizationID, template.ID)
-		coderdtest.AwaitWorkspaceBuildJobCompleted(t, templateAdmin, dormantWS2.LatestBuild.ID)
+		dormantWS2 := dbfake.WorkspaceBuild(t, db, database.Workspace{
+			OwnerID:        templateAdmin.ID,
+			OrganizationID: owner.OrganizationID,
+			TemplateID:     resp.Template.ID,
+		}).Do().Workspace
 
-		activeWS := coderdtest.CreateWorkspace(t, templateAdmin, user.OrganizationID, template.ID)
-		coderdtest.AwaitWorkspaceBuildJobCompleted(t, templateAdmin, activeWS.LatestBuild.ID)
+		_ = dbfake.WorkspaceBuild(t, db, database.Workspace{
+			OwnerID:        templateAdmin.ID,
+			OrganizationID: owner.OrganizationID,
+			TemplateID:     resp.Template.ID,
+		}).Do().Workspace
 
-		err := templateAdmin.UpdateWorkspaceDormancy(ctx, dormantWS1.ID, codersdk.UpdateWorkspaceDormancy{Dormant: true})
+		err := templateAdminClient.UpdateWorkspaceDormancy(ctx, dormantWS1.ID, codersdk.UpdateWorkspaceDormancy{Dormant: true})
 		require.NoError(t, err)
 
-		err = templateAdmin.UpdateWorkspaceDormancy(ctx, dormantWS2.ID, codersdk.UpdateWorkspaceDormancy{Dormant: true})
+		err = templateAdminClient.UpdateWorkspaceDormancy(ctx, dormantWS2.ID, codersdk.UpdateWorkspaceDormancy{Dormant: true})
 		require.NoError(t, err)
 
-		resp, err := templateAdmin.Workspaces(ctx, codersdk.WorkspaceFilter{
-			FilterQuery: "is-dormant:true",
+		workspaces, err := templateAdminClient.Workspaces(ctx, codersdk.WorkspaceFilter{
+			FilterQuery: "dormant:true",
 		})
 		require.NoError(t, err)
-		require.Len(t, resp.Workspaces, 2)
+		require.Len(t, workspaces.Workspaces, 2)
 
-		for _, ws := range resp.Workspaces {
+		for _, ws := range workspaces.Workspaces {
 			if ws.ID != dormantWS1.ID && ws.ID != dormantWS2.ID {
 				t.Fatalf("Unexpected workspace %+v", ws)
 			}

diff --git a/site/src/components/WorkspaceDeletion/DormantWorkspaceBanner.tsx b/site/src/components/WorkspaceDeletion/DormantWorkspaceBanner.tsx
@@ -1,7 +1,5 @@
 import { formatDistanceToNow } from "date-fns";
-import Link from "@mui/material/Link";
-import { type FC } from "react";
-import { Link as RouterLink } from "react-router-dom";
+import { ReactNode, type FC } from "react";
 import type { Workspace } from "api/typesGenerated";
 import { useIsWorkspaceActionsEnabled } from "components/Dashboard/DashboardProvider";
 import { Alert } from "components/Alert/Alert";
@@ -12,90 +10,67 @@ export enum Count {
 }
 
 interface DormantWorkspaceBannerProps {
-  workspaces?: Workspace[];
+  workspace: Workspace;
   onDismiss: () => void;
   shouldRedisplayBanner: boolean;
-  count?: Count;
 }
 
 export const DormantWorkspaceBanner: FC<DormantWorkspaceBannerProps> = ({
-  workspaces,
+  workspace,
   onDismiss,
   shouldRedisplayBanner,
-  count = Count.Singular,
 }) => {
   const experimentEnabled = useIsWorkspaceActionsEnabled();
 
-  if (!workspaces) {
-    return null;
-  }
-
-  const hasDormantWorkspaces = workspaces.find(
-    (workspace) => workspace.dormant_at,
-  );
-
-  const hasDeletionScheduledWorkspaces = workspaces.find(
-    (workspace) => workspace.deleting_at,
-  );
-
   if (
     // Only show this if the experiment is included.
     !experimentEnabled ||
-    !hasDormantWorkspaces ||
+    !workspace.dormant_at ||
     // Banners should be redisplayed after dismissal when additional workspaces are newly scheduled for deletion
     !shouldRedisplayBanner
   ) {
     return null;
   }
 
-  const formatDate = (dateStr: string): string => {
+  const formatDate = (dateStr: string, timestamp: boolean): string => {
     const date = new Date(dateStr);
     return date.toLocaleDateString(undefined, {
       month: "long",
       day: "numeric",
       year: "numeric",
+      ...(timestamp ? { hour: "numeric", minute: "numeric" } : {}),
     });
   };
 
-  const alertText = (): string => {
-    if (workspaces.length === 1) {
-      if (
-        hasDeletionScheduledWorkspaces &&
-        hasDeletionScheduledWorkspaces.deleting_at &&
-        hasDeletionScheduledWorkspaces.dormant_at
-      ) {
-        return `This workspace has been dormant for ${formatDistanceToNow(
-          Date.parse(hasDeletionScheduledWorkspaces.dormant_at),
-        )} and is scheduled to be deleted on ${formatDate(
-          hasDeletionScheduledWorkspaces.deleting_at,
-        )} . To keep it you must activate the workspace.`;
-      } else if (hasDormantWorkspaces && hasDormantWorkspaces.dormant_at) {
-        return `This workspace has been dormant for ${formatDistanceToNow(
-          Date.parse(hasDormantWorkspaces.dormant_at),
-        )}
-        and cannot be interacted
-		with. Dormant workspaces are eligible for
-		permanent deletion. To prevent deletion, activate
-		the workspace.`;
-      }
+  const alertText = (): ReactNode => {
+    if (workspace.deleting_at && workspace.dormant_at) {
+      return (
+        <>
+          This workspace has not been used for{" "}
+          {formatDistanceToNow(Date.parse(workspace.last_used_at))} and was
+          marked dormant on {formatDate(workspace.dormant_at, false)}. It is
+          scheduled to be deleted on {formatDate(workspace.deleting_at, true)}.
+          To keep it you must activate the workspace.
+        </>
+      );
+    } else if (workspace.dormant_at) {
+      return (
+        <>
+          This workspace has not been used for{" "}
+          {formatDistanceToNow(Date.parse(workspace.last_used_at))} and was
+          marked dormant on {formatDate(workspace.dormant_at, false)}. It is not
+          scheduled for auto-deletion but will become a candidate if
+          auto-deletion is enabled on this template. To keep it you must
+          activate the workspace.
+        </>
+      );
     }
     return "";
   };
 
   return (
     <Alert severity="warning" onDismiss={onDismiss} dismissible>
-      {count === Count.Singular ? (
-        alertText()
-      ) : (
-        <>
-          <span>There are</span>{" "}
-          <Link component={RouterLink} to="/workspaces?filter=is-dormant:true">
-            workspaces
-          </Link>{" "}
-          that may be deleted soon due to inactivity. Activate the workspaces
-          you wish to retain.
-        </>
-      )}
+      {alertText()}
     </Alert>
   );
 };