test: Consistent user ordering in dbfake

Emyrk · Emyrk · commit e1dd559f9384 · 2023-03-03T10:52:42.000-06:00
diff --git a/cli/root_test.go b/cli/root_test.go
@@ -13,7 +13,6 @@ import (
 	"runtime"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
@@ -198,32 +197,13 @@ func prepareTestData(t *testing.T) (*codersdk.Client, map[string]string) {
 		IncludeProvisionerDaemon: true,
 	})
 	firstUser := coderdtest.CreateFirstUser(t, rootClient)
-
-	firstUserData, err := rootClient.User(ctx, firstUser.UserID.String())
+	secondUser, err := rootClient.CreateUser(ctx, codersdk.CreateUserRequest{
+		Email:          "testuser2@coder.com",
+		Username:       "testuser2",
+		Password:       coderdtest.FirstUserParams.Password,
+		OrganizationID: firstUser.OrganizationID,
+	})
 	require.NoError(t, err)
-
-	var secondUser codersdk.User
-	for {
-		secondUser, err = rootClient.CreateUser(ctx, codersdk.CreateUserRequest{
-			Email:          "testuser2@coder.com",
-			Username:       "testuser2",
-			Password:       coderdtest.FirstUserParams.Password,
-			OrganizationID: firstUser.OrganizationID,
-		})
-		require.NoError(t, err)
-
-		// If the second user has the same timestamp as the first user, delete it and try again.
-		// This is because user order is determined by creation time, and we want to ensure
-		// second user is listed after first user.
-		// Round to microsecond since that is the precision of the database.
-		if secondUser.CreatedAt.Round(time.Microsecond).Equal(firstUserData.CreatedAt.Round(time.Microsecond)) {
-			err = rootClient.DeleteUser(ctx, secondUser.ID)
-			require.NoError(t, err)
-			continue
-		}
-		break
-	}
-
 	version := coderdtest.CreateTemplateVersion(t, rootClient, firstUser.OrganizationID, nil)
 	version = coderdtest.AwaitTemplateVersionJob(t, rootClient, version.ID)
 	template := coderdtest.CreateTemplate(t, rootClient, firstUser.OrganizationID, version.ID, func(req *codersdk.CreateTemplateRequest) {
diff --git a/coderd/database/dbfake/databasefake.go b/coderd/database/dbfake/databasefake.go
@@ -2922,6 +2922,21 @@ func (q *fakeQuerier) InsertUser(_ context.Context, arg database.InsertUserParam
 		return database.User{}, err
 	}
 
+	// There is a common bug when using dbfake that 2 inserted users have the
+	// same created_at time. This causes user order to not be deterministic,
+	// which breaks some unit tests.
+	// To fix this, we make sure that the created_at time is always greater
+	// than the last user's created_at time.
+	allUsers, _ := q.GetUsers(context.Background(), database.GetUsersParams{})
+	if len(allUsers) > 0 {
+		lastUser := allUsers[len(allUsers)-1]
+		if arg.CreatedAt.Before(lastUser.CreatedAt) ||
+			arg.CreatedAt.Equal(lastUser.CreatedAt) {
+			// 1 ms is a good enough buffer.
+			arg.CreatedAt = lastUser.CreatedAt.Add(time.Millisecond)
+		}
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
diff --git a/coderd/database/dbfake/databasefake_test.go b/coderd/database/dbfake/databasefake_test.go
@@ -8,6 +8,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/coder/coderd/database/dbgen"
+
 	"github.com/stretchr/testify/assert"
 
 	"github.com/coder/coder/coderd/database"
@@ -105,6 +109,27 @@ func TestExactMethods(t *testing.T) {
 	}
 }
 
+// TestUserOrder ensures that the fake database returns users in the order they
+// were created.
+func TestUserOrder(t *testing.T) {
+	db := dbfake.New()
+	now := database.Now()
+	count := 10
+	for i := 0; i < count; i++ {
+		dbgen.User(t, db, database.User{
+			Username:  fmt.Sprintf("user%d", i),
+			CreatedAt: now,
+		})
+	}
+
+	users, err := db.GetUsers(context.Background(), database.GetUsersParams{})
+	require.NoError(t, err)
+	require.Lenf(t, users, count, "expected %d users", count)
+	for i, user := range users {
+		require.Equal(t, fmt.Sprintf("user%d", i), user.Username)
+	}
+}
+
 func methods(rt reflect.Type) map[string]bool {
 	methods := make(map[string]bool)
 	for i := 0; i < rt.NumMethod(); i++ {
