coder · rodrimaia · May 22, 2023 · May 18, 2023 · May 19, 2023 · May 19, 2023
diff --git a/coderd/workspaces.go b/coderd/workspaces.go
@@ -1147,16 +1147,34 @@ func convertWorkspaces(workspaces []database.Workspace, data workspaceData) ([]c
 			&owner,
 		))
 	}
-	sort.Slice(apiWorkspaces, func(i, j int) bool {
-		iw := apiWorkspaces[i]
-		jw := apiWorkspaces[j]
+
+	sortWorkspaces(apiWorkspaces)
+
+	return apiWorkspaces, nil
+}
+
+func sortWorkspaces(workspaces []codersdk.Workspace) {
+	sort.Slice(workspaces, func(i, j int) bool {
+		iw := workspaces[i]
+		jw := workspaces[j]
+
+		if iw.LatestBuild.Status == codersdk.WorkspaceStatusRunning && jw.LatestBuild.Status != codersdk.WorkspaceStatusRunning {
+			return true
+		}
+
+		if jw.LatestBuild.Status == codersdk.WorkspaceStatusRunning && iw.LatestBuild.Status != codersdk.WorkspaceStatusRunning {
+			return false
+		}
+
+		if iw.OwnerID != jw.OwnerID {
+			return iw.OwnerName < jw.OwnerName
+		}
+
 		if jw.LastUsedAt.IsZero() && iw.LastUsedAt.IsZero() {
 			return iw.Name < jw.Name
 		}
 		return iw.LastUsedAt.After(jw.LastUsedAt)
 	})
-
-	return apiWorkspaces, nil
 }
 
 func convertWorkspace(

diff --git a/coderd/workspaces_internal_test.go b/coderd/workspaces_internal_test.go
@@ -1,9 +1,11 @@
 package coderd
 
 import (
+	"fmt"
 	"testing"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
 	"github.com/coder/coder/coderd/database"
@@ -80,3 +82,106 @@ func Test_calculateDeletingAt(t *testing.T) {
 		})
 	}
 }
+
+func TestSortWorkspaces(t *testing.T) {
+	t.Parallel()
+
+	t.Run("Running First", func(t *testing.T) {
+		t.Parallel()
+		workspaces := []codersdk.Workspace{
+			WorkspaceFactory(t, "test-workspace-sort-1", uuid.New(), "user1", codersdk.WorkspaceStatusPending),
+			WorkspaceFactory(t, "test-workspace-sort-2", uuid.New(), "user2", codersdk.WorkspaceStatusRunning),
+			WorkspaceFactory(t, "test-workspace-sort-3", uuid.New(), "user2", codersdk.WorkspaceStatusRunning),
+			WorkspaceFactory(t, "test-workspace-sort-4", uuid.New(), "user1", codersdk.WorkspaceStatusPending),
+		}
+
+		sortWorkspaces(workspaces)
+
+		require.Equal(t, workspaces[0].LatestBuild.Status, codersdk.WorkspaceStatusRunning)
+		require.Equal(t, workspaces[1].LatestBuild.Status, codersdk.WorkspaceStatusRunning)
+		require.Equal(t, workspaces[2].LatestBuild.Status, codersdk.WorkspaceStatusPending)
+		require.Equal(t, workspaces[3].LatestBuild.Status, codersdk.WorkspaceStatusPending)
+	})
+
+	t.Run("Then sort by owner Name", func(t *testing.T) {
+		t.Parallel()
+		workspaces := []codersdk.Workspace{
+			WorkspaceFactory(t, "test-workspace-sort-1", uuid.New(), "userZ", codersdk.WorkspaceStatusRunning),
+			WorkspaceFactory(t, "test-workspace-sort-2", uuid.New(), "userA", codersdk.WorkspaceStatusRunning),
+			WorkspaceFactory(t, "test-workspace-sort-3", uuid.New(), "userB", codersdk.WorkspaceStatusRunning),
+		}
+
+		sortWorkspaces(workspaces)
+
+		t.Log("uuid ", uuid.New().String())
+		t.Log("uuid ", uuid.New().String())
+
+		require.Equal(t, "userA", workspaces[0].OwnerName)
+		require.Equal(t, "userB", workspaces[1].OwnerName)
+		require.Equal(t, "userZ", workspaces[2].OwnerName)
+	})
+
+	t.Run("Then sort by last used at (recent first)", func(t *testing.T) {
+		t.Parallel()
+		var workspaces []codersdk.Workspace
+
+		useruuid := uuid.New()
+
+		for i := 0; i < 4; i++ {
+			workspaces = append(workspaces, WorkspaceFactory(t, fmt.Sprintf("test-workspace-sort-%d", i+1), useruuid, "user2", codersdk.WorkspaceStatusRunning))
+		}
+
+		sortWorkspaces(workspaces)
+
+		// in this case, the last used at is the creation time
+		require.Equal(t, workspaces[0].Name, "test-workspace-sort-4")
+		require.Equal(t, workspaces[1].Name, "test-workspace-sort-3")
+		require.Equal(t, workspaces[2].Name, "test-workspace-sort-2")
+		require.Equal(t, workspaces[3].Name, "test-workspace-sort-1")
+	})
+}
+
+func WorkspaceFactory(t *testing.T, name string, ownerID uuid.UUID, ownerName string, status codersdk.WorkspaceStatus) codersdk.Workspace {
+	t.Helper()
+	return codersdk.Workspace{
+		ID:                                   uuid.New(),
+		CreatedAt:                            time.Time{},
+		UpdatedAt:                            time.Time{},
+		OwnerID:                              ownerID,
+		OwnerName:                            ownerName,
+		OrganizationID:                       [16]byte{},
+		TemplateID:                           [16]byte{},
+		TemplateName:                         name,
+		TemplateDisplayName:                  name,
+		TemplateIcon:                         "",
+		TemplateAllowUserCancelWorkspaceJobs: false,
+		LatestBuild: codersdk.WorkspaceBuild{
+			ID:                  uuid.New(),
+			CreatedAt:           time.Time{},
+			UpdatedAt:           time.Time{},
+			WorkspaceID:         [16]byte{},
+			WorkspaceName:       name,
+			WorkspaceOwnerID:    [16]byte{},
+			WorkspaceOwnerName:  ownerName,
+			TemplateVersionID:   [16]byte{},
+			TemplateVersionName: name,
+			BuildNumber:         0,
+			Transition:          "",
+			InitiatorID:         [16]byte{},
+			InitiatorUsername:   name,
+			Job:                 codersdk.ProvisionerJob{},
+			Reason:              "",
+			Resources:           []codersdk.WorkspaceResource{},
+			Deadline:            codersdk.NullTime{},
+			MaxDeadline:         codersdk.NullTime{},
+			Status:              status,
+			DailyCost:           0,
+		},
+		Outdated:          false,
+		Name:              name,
+		AutostartSchedule: new(string),
+		TTLMillis:         new(int64),
+		LastUsedAt:        time.Now(),
+		DeletingAt:        &time.Time{},
+	}
+}
diff --git a/coderd/workspaces_test.go b/coderd/workspaces_test.go
@@ -198,6 +198,50 @@ func TestAdminViewAllWorkspaces(t *testing.T) {
 	require.Equal(t, 0, len(memberViewWorkspaces.Workspaces), "member in other org should see 0 workspaces")
 }
 
+func TestWorkspacesSortOrder(t *testing.T) {
+	// the correct sorting order is:
+	// 1. first show workspaces that are currently running,
+	// 2. then sort by user_name,
+	// 3. then sort by last_used_at (descending),
+	t.Parallel()
+	client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})
+	firstUser := coderdtest.CreateFirstUser(t, client)
+	version := coderdtest.CreateTemplateVersion(t, client, firstUser.OrganizationID, nil)
+	coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
+	template := coderdtest.CreateTemplate(t, client, firstUser.OrganizationID, version.ID)
+	workspace1 := coderdtest.CreateWorkspace(t, client, firstUser.OrganizationID, template.ID, func(ctr *codersdk.CreateWorkspaceRequest) {
+		ctr.Name = "test-workspace-sort-1"
+	})
+	coderdtest.AwaitWorkspaceBuildJob(t, client, workspace1.LatestBuild.ID)
+
+	workspace2 := coderdtest.CreateWorkspace(t, client, firstUser.OrganizationID, template.ID, func(ctr *codersdk.CreateWorkspaceRequest) {
+		ctr.Name = "test-workspace-sort-2"
+	})
+	coderdtest.AwaitWorkspaceBuildJob(t, client, workspace2.LatestBuild.ID)
+
+	build2 := coderdtest.CreateWorkspaceBuild(t, client, workspace2, database.WorkspaceTransitionStop)
+	coderdtest.AwaitWorkspaceBuildJob(t, client, build2.ID)
+
+	workspace3 := coderdtest.CreateWorkspace(t, client, firstUser.OrganizationID, template.ID, func(ctr *codersdk.CreateWorkspaceRequest) {
+		ctr.Name = "test-workspace-sort-3"
+	})
+	coderdtest.AwaitWorkspaceBuildJob(t, client, workspace3.LatestBuild.ID)
+
+	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
+	defer cancel()
+
+	workspacesResponse, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{})
+	require.NoError(t, err, "(first) fetch workspaces")
+	require.Equal(t, 3, len(workspacesResponse.Workspaces), "should be 3 workspaces present")
+
+	require.Equal(t, codersdk.WorkspaceStatusRunning, workspacesResponse.Workspaces[0].LatestBuild.Status, "should be the first item in the list because it is running")
+	require.Equal(t, codersdk.WorkspaceStatusRunning, workspacesResponse.Workspaces[1].LatestBuild.Status)
+	require.Equal(t, codersdk.WorkspaceStatusStopped, workspacesResponse.Workspaces[2].LatestBuild.Status, "The stopped workspace should be last")
+
+	require.Equal(t, workspace3.ID, workspacesResponse.Workspaces[0].ID, "If both are running, and have the same owner, sort by last used (in this case, the last one created)")
+
+}
+
 func TestPostWorkspacesByOrganization(t *testing.T) {
 	t.Parallel()
 	t.Run("InvalidTemplate", func(t *testing.T) {