SMQ-3125 - Add ordering tests (#3297)

Signed-off-by: Felix Gateru <felix.gateru@gmail.com>

channels/postgres/channels_test.go

@@ -54,7 +54,8 @@ var (
 	directGroupAccess = "direct_group"
 	domainAccess      = "domain"
 	defOrder          = "created_at"
-	defDir            = "asc"
+	ascDir            = "asc"
+	descDir           = "desc"
 	availableActions  = []string{
 		"delete",
 		"membership",
@@ -603,6 +604,7 @@ func TestRetrieveAll(t *testing.T) {
 
 	var items []channels.Channel
 	parentID := ""
+	baseTime := time.Now().UTC().Truncate(time.Microsecond)
 	for i := 0; i < num; i++ {
 		name := namegen.Generate()
 		channel := channels.Channel{
@@ -612,7 +614,8 @@ func TestRetrieveAll(t *testing.T) {
 			Name:            name,
 			Route:           testsutil.GenerateUUID(t),
 			Metadata:        map[string]any{"name": name},
-			CreatedAt:       time.Now().UTC().Truncate(time.Microsecond),
+			CreatedAt:       baseTime.Add(time.Duration(i) * time.Millisecond),
+			UpdatedAt:       baseTime.Add(time.Duration(i) * time.Millisecond),
 			Status:          channels.EnabledStatus,
 			ConnectionTypes: []connections.ConnType{},
 		}
@@ -624,6 +627,11 @@ func TestRetrieveAll(t *testing.T) {
 		}
 	}
 
+	reversedChannels := []channels.Channel{}
+	for i := len(items) - 1; i >= 0; i-- {
+		reversedChannels = append(reversedChannels, items[i])
+	}
+
 	cases := []struct {
 		desc     string
 		page     channels.ChannelsPage
@@ -637,7 +645,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 0,
 					Limit:  10,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: channels.ChannelsPage{
@@ -657,7 +665,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 10,
 					Limit:  10,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: channels.ChannelsPage{
@@ -677,7 +685,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 0,
 					Limit:  50,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: channels.ChannelsPage{
@@ -697,7 +705,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 50,
 					Limit:  50,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: channels.ChannelsPage{
@@ -717,7 +725,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 1000,
 					Limit:  50,
 					Order:  "created_at",
-					Dir:    "desc",
+					Dir:    descDir,
 				},
 			},
 			response: channels.ChannelsPage{
@@ -737,7 +745,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 170,
 					Limit:  50,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: channels.ChannelsPage{
@@ -987,6 +995,122 @@ func TestRetrieveAll(t *testing.T) {
 			response: channels.ChannelsPage{},
 			err:      repoerr.ErrViewEntity,
 		},
+		{
+			desc: "retrieve channels with order by name ascending",
+			page: channels.ChannelsPage{
+				Page: channels.Page{
+					Offset: 0,
+					Limit:  10,
+					Order:  "name",
+					Dir:    ascDir,
+				},
+			},
+			response: channels.ChannelsPage{
+				Page: channels.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve channels with order by name descending",
+			page: channels.ChannelsPage{
+				Page: channels.Page{
+					Offset: 0,
+					Limit:  10,
+					Order:  "name",
+					Dir:    descDir,
+				},
+			},
+			response: channels.ChannelsPage{
+				Page: channels.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve channels with order by created_at ascending",
+			page: channels.ChannelsPage{
+				Page: channels.Page{
+					Offset: 0,
+					Limit:  10,
+					Order:  "created_at",
+					Dir:    ascDir,
+				},
+			},
+			response: channels.ChannelsPage{
+				Page: channels.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Channels: items[:10],
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve channels with order by created_at descending",
+			page: channels.ChannelsPage{
+				Page: channels.Page{
+					Offset: 0,
+					Limit:  10,
+					Order:  "created_at",
+					Dir:    descDir,
+				},
+			},
+			response: channels.ChannelsPage{
+				Page: channels.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Channels: reversedChannels[:10],
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve channels with order by updated_at ascending",
+			page: channels.ChannelsPage{
+				Page: channels.Page{
+					Offset: 0,
+					Limit:  10,
+					Order:  "updated_at",
+					Dir:    ascDir,
+				},
+			},
+			response: channels.ChannelsPage{
+				Page: channels.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve channels with order by updated_at descending",
+			page: channels.ChannelsPage{
+				Page: channels.Page{
+					Offset: 0,
+					Limit:  10,
+					Order:  "updated_at",
+					Dir:    descDir,
+				},
+			},
+			response: channels.ChannelsPage{
+				Page: channels.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
 	}
 
 	for _, tc := range cases {
@@ -997,9 +1121,12 @@ func TestRetrieveAll(t *testing.T) {
 				assert.Equal(t, tc.response.Total, channels.Total, fmt.Sprintf("%s: expected %d got %d\n", tc.desc, tc.response.Total, channels.Total))
 				assert.Equal(t, tc.response.Limit, channels.Limit, fmt.Sprintf("%s: expected %d got %d\n", tc.desc, tc.response.Limit, channels.Limit))
 				assert.Equal(t, tc.response.Offset, channels.Offset, fmt.Sprintf("%s: expected %d got %d\n", tc.desc, tc.response.Offset, channels.Offset))
-				got := updateTimestamp(channels.Channels)
-				resp := updateTimestamp(tc.response.Channels)
-				assert.ElementsMatch(t, resp, got, fmt.Sprintf("%s: expected %+v got %+v\n", tc.desc, resp, got))
+				if len(tc.response.Channels) > 0 {
+					got := updateTimestamp(channels.Channels)
+					resp := updateTimestamp(tc.response.Channels)
+					assert.ElementsMatch(t, resp, got, fmt.Sprintf("%s: expected %+v got %+v\n", tc.desc, resp, got))
+				}
+				verifyChannelsOrdering(t, channels.Channels, tc.page.Page.Order, tc.page.Page.Dir)
 			default:
 				assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
 			}
@@ -2050,7 +2177,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Limit:  10,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2070,7 +2197,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Limit:  10,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2090,7 +2217,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Limit:  10,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2111,7 +2238,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Client: clientID,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2131,7 +2258,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Limit:  50,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2152,7 +2279,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Metadata: directChannels[0].Metadata,
 				Status:   channels.AllStatus,
 				Order:    defOrder,
-				Dir:      defDir,
+				Dir:      ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2175,7 +2302,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				},
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2198,7 +2325,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				},
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2220,7 +2347,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Name:   directChannels[0].Name,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2241,7 +2368,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Name:   namegen.Generate(),
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2262,7 +2389,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Tag:    directChannels[0].Tags[0],
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2283,7 +2410,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Tag:    namegen.Generate(),
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2325,7 +2452,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				ID:     directChannels[0].ID,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2346,7 +2473,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				ID:     testsutil.GenerateUUID(t),
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2366,7 +2493,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Limit:  nChannels,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2386,7 +2513,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Limit:  nChannels,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2410,7 +2537,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				},
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2435,7 +2562,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				},
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2456,7 +2583,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				AccessType: domainAccess,
 				Status:     channels.AllStatus,
 				Order:      defOrder,
-				Dir:        defDir,
+				Dir:        ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2477,7 +2604,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				AccessType: domainAccess,
 				Status:     channels.AllStatus,
 				Order:      defOrder,
-				Dir:        defDir,
+				Dir:        ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2498,7 +2625,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				RoleID: directChannels[0].RoleID,
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2519,7 +2646,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				RoleID: testsutil.GenerateUUID(t),
 				Status: channels.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2540,7 +2667,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				RoleName: directChannels[0].RoleName,
 				Status:   channels.AllStatus,
 				Order:    defOrder,
-				Dir:      defDir,
+				Dir:      ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2561,7 +2688,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				RoleName: namegen.Generate(),
 				Status:   channels.AllStatus,
 				Order:    defOrder,
-				Dir:      defDir,
+				Dir:      ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2582,7 +2709,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Actions: availableActions,
 				Status:  channels.AllStatus,
 				Order:   defOrder,
-				Dir:     defDir,
+				Dir:     ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2603,7 +2730,7 @@ func TestRetrieveUserChannels(t *testing.T) {
 				Actions: []string{"non_existent_action"},
 				Status:  channels.AllStatus,
 				Order:   defOrder,
-				Dir:     defDir,
+				Dir:     ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2708,7 +2835,7 @@ func TestSearchChannels(t *testing.T) {
 			page: channels.Page{
 				Limit: 10,
 				Order: "name",
-				Dir:   "asc",
+				Dir:   ascDir,
 			},
 			response: channels.ChannelsPage{
 				Channels: expectedChannels[0:10],
@@ -2741,7 +2868,7 @@ func TestSearchChannels(t *testing.T) {
 				Offset: 10,
 				Limit:  10,
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Channels: expectedChannels[10:20],
@@ -2774,7 +2901,7 @@ func TestSearchChannels(t *testing.T) {
 				Offset: 190,
 				Limit:  50,
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Page: channels.Page{
@@ -2792,7 +2919,7 @@ func TestSearchChannels(t *testing.T) {
 				Offset: 0,
 				Limit:  10,
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: channels.ChannelsPage{
 				Channels: findChannels(expectedChannels, expectedChannels[0].Name[:4], 0, 10),
@@ -2876,7 +3003,7 @@ func TestSearchChannels(t *testing.T) {
 			desc: "with name in asc order",
 			page: channels.Page{
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 				Name:   expectedChannels[0].Name[:1],
 				Offset: 0,
 				Limit:  10,
@@ -2888,7 +3015,7 @@ func TestSearchChannels(t *testing.T) {
 			desc: "with name in desc order",
 			page: channels.Page{
 				Order:  "name",
-				Dir:    "desc",
+				Dir:    descDir,
 				Name:   expectedChannels[0].Name[:1],
 				Offset: 0,
 				Limit:  10,
@@ -3037,3 +3164,36 @@ func findChannels(chs []channels.Channel, query string, offset, limit uint64) []
 
 	return rchannels[offset:limit]
 }
+
+func verifyChannelsOrdering(t *testing.T, chs []channels.Channel, order, dir string) {
+	if order == "" || len(chs) <= 1 {
+		return
+	}
+
+	switch order {
+	case "name":
+		for i := 1; i < len(chs); i++ {
+			if dir == ascDir {
+				assert.LessOrEqual(t, chs[i-1].Name, chs[i].Name)
+				continue
+			}
+			assert.GreaterOrEqual(t, chs[i-1].Name, chs[i].Name)
+		}
+	case "created_at":
+		for i := 1; i < len(chs); i++ {
+			if dir == ascDir {
+				assert.True(t, !chs[i-1].CreatedAt.After(chs[i].CreatedAt))
+				continue
+			}
+			assert.True(t, !chs[i-1].CreatedAt.Before(chs[i].CreatedAt))
+		}
+	case "updated_at":
+		for i := 1; i < len(chs); i++ {
+			if dir == ascDir {
+				assert.True(t, !chs[i-1].UpdatedAt.After(chs[i].UpdatedAt))
+				continue
+			}
+			assert.True(t, !chs[i-1].UpdatedAt.Before(chs[i].UpdatedAt))
+		}
+	}
+}

clients/postgres/clients_test.go

@@ -32,7 +32,8 @@ const (
 	maxNameSize = 1024
 	emailSuffix = "@example.com"
 	defOrder    = "created_at"
-	defDir      = "asc"
+	ascDir      = "asc"
+	descDir     = "desc"
 )
 
 var (
@@ -1046,6 +1047,7 @@ func TestRetrieveAll(t *testing.T) {
 	channelID := testsutil.GenerateUUID(t)
 	expectedClients := []clients.Client{}
 	disabledClients := []clients.Client{}
+	reversedClients := []clients.Client{}
 	baseTime := time.Now().UTC().Truncate(time.Microsecond)
 	for i := uint64(0); i < nClients; i++ {
 		client := clients.Client{
@@ -1062,6 +1064,7 @@ func TestRetrieveAll(t *testing.T) {
 			},
 			Status:    clients.EnabledStatus,
 			CreatedAt: baseTime.Add(time.Duration(i) * time.Microsecond),
+			UpdatedAt: baseTime.Add(time.Duration(i) * time.Microsecond),
 		}
 		if i%50 == 0 {
 			client.Status = clients.DisabledStatus
@@ -1086,6 +1089,10 @@ func TestRetrieveAll(t *testing.T) {
 		}
 	}
 
+	for i := len(expectedClients) - 1; i >= 0; i-- {
+		reversedClients = append(reversedClients, expectedClients[i])
+	}
+
 	cases := []struct {
 		desc     string
 		pm       clients.Page
@@ -1526,6 +1533,144 @@ func TestRetrieveAll(t *testing.T) {
 				Clients: []clients.Client{connectedClient},
 			},
 		},
+		{
+			desc: "with order by name ascending",
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  10,
+				Order:  "name",
+				Dir:    ascDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+		},
+		{
+			desc: "with order by name descending",
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  10,
+				Order:  "name",
+				Dir:    descDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+		},
+		{
+			desc: "with order by identity ascending",
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  10,
+				Order:  "identity",
+				Dir:    ascDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+		},
+		{
+			desc: "with order by identity descending",
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  10,
+				Order:  "identity",
+				Dir:    descDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+		},
+		{
+			desc: "with order by created_at ascending",
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  10,
+				Order:  "created_at",
+				Dir:    ascDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  10,
+				},
+				Clients: expectedClients[:10],
+			},
+		},
+		{
+			desc: "with order by created_at descending",
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  10,
+				Order:  "created_at",
+				Dir:    descDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  10,
+				},
+				Clients: reversedClients[:10],
+			},
+		},
+		{
+			desc: "with order by updated_at ascending",
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  10,
+				Order:  "updated_at",
+				Dir:    ascDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+		},
+		{
+			desc: "with order by updated_at descending",
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  10,
+				Order:  "updated_at",
+				Dir:    descDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+		},
 	}
 	for _, c := range cases {
 		t.Run(c.desc, func(t *testing.T) {
@@ -1535,9 +1680,12 @@ func TestRetrieveAll(t *testing.T) {
 				assert.Equal(t, c.response.Total, page.Total)
 				assert.Equal(t, c.response.Offset, page.Offset)
 				assert.Equal(t, c.response.Limit, page.Limit)
-				expected := stripClientDetails(c.response.Clients)
-				got := stripClientDetails(page.Clients)
-				assert.ElementsMatch(t, expected, got, fmt.Sprintf("expected %v got %v\n", expected, got))
+				if len(c.response.Clients) > 0 {
+					expected := stripClientDetails(c.response.Clients)
+					got := stripClientDetails(page.Clients)
+					assert.ElementsMatch(t, expected, got, fmt.Sprintf("expected %v got %v\n", expected, got))
+				}
+				verifyClientsOrdering(t, page.Clients, c.pm.Order, c.pm.Dir)
 			}
 		})
 	}
@@ -1569,6 +1717,7 @@ func TestRetrieveUserClients(t *testing.T) {
 	connectedClient := clients.Client{}
 	directClients := []clients.Client{}
 	domainClients := []clients.Client{}
+	baseTime := time.Now().UTC().Truncate(time.Microsecond)
 	for i := range nClients {
 		client := clients.Client{
 			ID:     testsutil.GenerateUUID(t),
@@ -1583,7 +1732,8 @@ func TestRetrieveUserClients(t *testing.T) {
 				"department": namegen.Generate(),
 			},
 			Status:    clients.EnabledStatus,
-			CreatedAt: time.Now().UTC().Truncate(time.Microsecond),
+			CreatedAt: baseTime.Add(time.Duration(i) * time.Microsecond),
+			UpdatedAt: baseTime.Add(time.Duration(i) * time.Microsecond),
 		}
 		if i == 1 {
 			client.ParentGroup = group.ID
@@ -1610,6 +1760,9 @@ func TestRetrieveUserClients(t *testing.T) {
 		directClient.RoleName = npr[0].Role.Name
 		directClient.AccessType = directAccess
 		directClient.AccessProviderRoleActions = []string{}
+		if i == 1 {
+			directClient.ParentGroupPath = group.ID
+		}
 		directClients = append(directClients, directClient)
 		if i == 1 {
 			parentGroupClient = directClient
@@ -1647,6 +1800,11 @@ func TestRetrieveUserClients(t *testing.T) {
 		domainClients = append(domainClients, domainClient)
 	}
 
+	reversedDirectClients := []clients.Client{}
+	for i := len(directClients) - 1; i >= 0; i-- {
+		reversedDirectClients = append(reversedDirectClients, directClients[i])
+	}
+
 	cases := []struct {
 		desc     string
 		domainID string
@@ -1678,7 +1836,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Limit:  10,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1698,7 +1856,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Limit:  10,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1718,7 +1876,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Limit:  10,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1739,7 +1897,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Channel: channelID,
 				Status:  clients.AllStatus,
 				Order:   defOrder,
-				Dir:     defDir,
+				Dir:     ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1759,7 +1917,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Limit:  50,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1780,7 +1938,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Metadata: directClients[0].Metadata,
 				Status:   clients.AllStatus,
 				Order:    defOrder,
-				Dir:      defDir,
+				Dir:      ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1803,7 +1961,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				},
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1826,7 +1984,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				},
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1848,7 +2006,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Name:   directClients[0].Name,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1869,7 +2027,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Name:   namegen.Generate(),
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1890,7 +2048,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Identity: directClients[0].Credentials.Identity,
 				Status:   clients.AllStatus,
 				Order:    defOrder,
-				Dir:      defDir,
+				Dir:      ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1911,7 +2069,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Identity: namegen.Generate(),
 				Status:   clients.AllStatus,
 				Order:    defOrder,
-				Dir:      defDir,
+				Dir:      ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1932,7 +2090,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Tag:    directClients[0].Tags[0],
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1953,7 +2111,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Tag:    namegen.Generate(),
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -1996,7 +2154,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				ID:     directClients[0].ID,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2017,7 +2175,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				ID:     testsutil.GenerateUUID(t),
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2037,7 +2195,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Limit:  nClients,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2057,7 +2215,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Limit:  nClients,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2078,7 +2236,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Group:  &group.ID,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2100,7 +2258,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				Group:  &emptyGroupParam,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2121,7 +2279,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				AccessType: domainAccess,
 				Status:     clients.AllStatus,
 				Order:      defOrder,
-				Dir:        defDir,
+				Dir:        ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2142,7 +2300,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				AccessType: domainAccess,
 				Status:     clients.AllStatus,
 				Order:      defOrder,
-				Dir:        defDir,
+				Dir:        ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2163,7 +2321,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				RoleID: directClients[0].RoleID,
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2184,7 +2342,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				RoleID: testsutil.GenerateUUID(t),
 				Status: clients.AllStatus,
 				Order:  defOrder,
-				Dir:    defDir,
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2205,7 +2363,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				RoleName: directClients[0].RoleName,
 				Status:   clients.AllStatus,
 				Order:    defOrder,
-				Dir:      defDir,
+				Dir:      ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2226,7 +2384,7 @@ func TestRetrieveUserClients(t *testing.T) {
 				RoleName: namegen.Generate(),
 				Status:   clients.AllStatus,
 				Order:    defOrder,
-				Dir:      defDir,
+				Dir:      ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2237,6 +2395,160 @@ func TestRetrieveUserClients(t *testing.T) {
 				Clients: []clients.Client(nil),
 			},
 		},
+		{
+			desc:     "retrieve clients with order by name ascending",
+			domainID: domain.ID,
+			userID:   userID,
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  5,
+				Order:  "name",
+				Dir:    ascDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  5,
+				},
+			},
+		},
+		{
+			desc:     "retrieve clients with order by name descending",
+			domainID: domain.ID,
+			userID:   userID,
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  5,
+				Order:  "name",
+				Dir:    descDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  5,
+				},
+			},
+		},
+		{
+			desc:     "retrieve clients with order by identity ascending",
+			domainID: domain.ID,
+			userID:   userID,
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  5,
+				Order:  "identity",
+				Dir:    ascDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  5,
+				},
+			},
+		},
+		{
+			desc:     "retrieve clients with order by identity descending",
+			domainID: domain.ID,
+			userID:   userID,
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  5,
+				Order:  "identity",
+				Dir:    descDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  5,
+				},
+			},
+		},
+		{
+			desc:     "retrieve clients with order by created_at ascending",
+			domainID: domain.ID,
+			userID:   userID,
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  5,
+				Order:  "created_at",
+				Dir:    ascDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  5,
+				},
+				Clients: directClients[:5],
+			},
+		},
+		{
+			desc:     "retrieve clients with order by created_at descending",
+			domainID: domain.ID,
+			userID:   userID,
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  5,
+				Order:  "created_at",
+				Dir:    descDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  5,
+				},
+				Clients: reversedDirectClients[:5],
+			},
+		},
+		{
+			desc:     "retrieve clients with order by updated_at ascending",
+			domainID: domain.ID,
+			userID:   userID,
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  5,
+				Order:  "updated_at",
+				Dir:    ascDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  5,
+				},
+			},
+		},
+		{
+			desc:     "retrieve clients with order by updated_at descending",
+			domainID: domain.ID,
+			userID:   userID,
+			pm: clients.Page{
+				Offset: 0,
+				Limit:  5,
+				Order:  "updated_at",
+				Dir:    descDir,
+				Status: clients.AllStatus,
+			},
+			response: clients.ClientsPage{
+				Page: clients.Page{
+					Total:  nClients,
+					Offset: 0,
+					Limit:  5,
+				},
+			},
+		},
 	}
 
 	for _, tc := range cases {
@@ -2247,9 +2559,12 @@ func TestRetrieveUserClients(t *testing.T) {
 				assert.Equal(t, tc.response.Total, page.Total)
 				assert.Equal(t, tc.response.Offset, page.Offset)
 				assert.Equal(t, tc.response.Limit, page.Limit)
-				expected := stripClientDetails(tc.response.Clients)
-				got := stripClientDetails(page.Clients)
-				assert.ElementsMatch(t, expected, got, fmt.Sprintf("expected %+v got %+v\n", expected, got))
+				if len(tc.response.Clients) > 0 {
+					expected := stripClientDetails(tc.response.Clients)
+					got := stripClientDetails(page.Clients)
+					assert.ElementsMatch(t, expected, got, fmt.Sprintf("expected %+v got %+v\n", expected, got))
+				}
+				verifyClientsOrdering(t, page.Clients, tc.pm.Order, tc.pm.Dir)
 			}
 		})
 	}
@@ -2334,7 +2649,7 @@ func TestSearchClients(t *testing.T) {
 			page: clients.Page{
 				Limit: 10,
 				Order: "name",
-				Dir:   "asc",
+				Dir:   ascDir,
 			},
 			response: clients.ClientsPage{
 				Clients: expectedClients[0:10],
@@ -2367,7 +2682,7 @@ func TestSearchClients(t *testing.T) {
 				Offset: 10,
 				Limit:  10,
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Clients: expectedClients[10:20],
@@ -2400,7 +2715,7 @@ func TestSearchClients(t *testing.T) {
 				Offset: 190,
 				Limit:  50,
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Page: clients.Page{
@@ -2418,7 +2733,7 @@ func TestSearchClients(t *testing.T) {
 				Offset: 0,
 				Limit:  10,
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: clients.ClientsPage{
 				Clients: findClients(expectedClients, expectedClients[0].Name[:4], 0, 10),
@@ -2471,7 +2786,7 @@ func TestSearchClients(t *testing.T) {
 				Offset:   0,
 				Limit:    10,
 				Order:    "name",
-				Dir:      "asc",
+				Dir:      ascDir,
 			},
 			response: clients.ClientsPage{
 				Clients: findClients(expectedClients, expectedClients[0].Name[:4], 0, 10),
@@ -2572,7 +2887,7 @@ func TestSearchClients(t *testing.T) {
 			desc: "with name in asc order",
 			page: clients.Page{
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 				Name:   expectedClients[0].Name[:1],
 				Offset: 0,
 				Limit:  10,
@@ -2584,7 +2899,7 @@ func TestSearchClients(t *testing.T) {
 			desc: "with name in desc order",
 			page: clients.Page{
 				Order:  "name",
-				Dir:    "desc",
+				Dir:    descDir,
 				Name:   expectedClients[0].Name[:1],
 				Offset: 0,
 				Limit:  10,
@@ -2596,7 +2911,7 @@ func TestSearchClients(t *testing.T) {
 			desc: "with identity in asc order",
 			page: clients.Page{
 				Order:    "identity",
-				Dir:      "asc",
+				Dir:      ascDir,
 				Identity: expectedClients[0].Name[:1],
 				Offset:   0,
 				Limit:    10,
@@ -2608,7 +2923,7 @@ func TestSearchClients(t *testing.T) {
 			desc: "with identity in desc order",
 			page: clients.Page{
 				Order:    "identity",
-				Dir:      "desc",
+				Dir:      descDir,
 				Identity: expectedClients[0].Name[:1],
 				Offset:   0,
 				Limit:    10,
@@ -3532,3 +3847,44 @@ func findClients(clis []clients.Client, query string, offset, limit uint64) []cl
 
 	return rclients[offset:limit]
 }
+
+func verifyClientsOrdering(t *testing.T, clients []clients.Client, order, dir string) {
+	if order == "" || len(clients) <= 1 {
+		return
+	}
+
+	switch order {
+	case "name":
+		for i := 1; i < len(clients); i++ {
+			if dir == ascDir {
+				assert.LessOrEqual(t, clients[i-1].Name, clients[i].Name)
+				continue
+			}
+			assert.GreaterOrEqual(t, clients[i-1].Name, clients[i].Name)
+		}
+	case "identity":
+		for i := 1; i < len(clients); i++ {
+			if dir == ascDir {
+				assert.LessOrEqual(t, clients[i-1].Credentials.Identity, clients[i].Credentials.Identity)
+				continue
+			}
+			assert.GreaterOrEqual(t, clients[i-1].Credentials.Identity, clients[i].Credentials.Identity)
+		}
+	case "created_at":
+		for i := 1; i < len(clients); i++ {
+			if dir == ascDir {
+				assert.True(t, !clients[i-1].CreatedAt.After(clients[i].CreatedAt))
+				continue
+			}
+			assert.True(t, !clients[i-1].CreatedAt.Before(clients[i].CreatedAt))
+		}
+	case "updated_at":
+		for i := 1; i < len(clients); i++ {
+			if dir == ascDir {
+				assert.True(t, !clients[i-1].UpdatedAt.After(clients[i].UpdatedAt))
+				continue
+			}
+			assert.True(t, !clients[i-1].UpdatedAt.Before(clients[i].UpdatedAt))
+		}
+	}
+}

domains/postgres/domains_test.go

@@ -18,7 +18,11 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const invalid = "invalid"
+const (
+	invalid = "invalid"
+	ascDir  = "asc"
+	descDir = "desc"
+)
 
 var (
 	domainID        = testsutil.GenerateUUID(&testing.T{})
@@ -314,7 +318,7 @@ func TestRetrieveAllByIDs(t *testing.T) {
 				Limit:  10,
 				IDs:    []string{items[1].ID, items[2].ID},
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: domains.DomainsPage{
 				Total:   2,
@@ -375,7 +379,7 @@ func TestRetrieveAllByIDs(t *testing.T) {
 				IDs:    []string{items[0].ID, items[1].ID},
 				Status: 5,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: domains.DomainsPage{
 				Total:   2,
@@ -410,7 +414,7 @@ func TestRetrieveAllByIDs(t *testing.T) {
 				},
 				Status: domains.EnabledStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: domains.DomainsPage{
 				Total:   2,
@@ -713,6 +717,7 @@ func TestListDomains(t *testing.T) {
 			UpdatedBy: userID,
 			Status:    domains.EnabledStatus,
 			CreatedAt: baseTime.Add(time.Duration(i) * time.Millisecond),
+			UpdatedAt: baseTime.Add(time.Duration(i) * time.Millisecond),
 		}
 		if i%5 == 0 {
 			domain.Status = domains.DisabledStatus
@@ -725,6 +730,12 @@ func TestListDomains(t *testing.T) {
 		require.Nil(t, err, fmt.Sprintf("save domain unexpected error: %s", err))
 		items = append(items, domain)
 	}
+
+	reversedDomains := []domains.Domain{}
+	for i := len(items) - 1; i >= 0; i-- {
+		reversedDomains = append(reversedDomains, items[i])
+	}
+
 	cases := []struct {
 		desc     string
 		pm       domains.Page
@@ -738,7 +749,7 @@ func TestListDomains(t *testing.T) {
 				Limit:  10,
 				Status: domains.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: domains.DomainsPage{
 				Total:   10,
@@ -755,7 +766,7 @@ func TestListDomains(t *testing.T) {
 				Limit:  10,
 				Status: domains.EnabledStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: domains.DomainsPage{
 				Total:   8,
@@ -773,7 +784,7 @@ func TestListDomains(t *testing.T) {
 				Name:   items[0].Name,
 				Status: domains.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: domains.DomainsPage{
 				Total:   1,
@@ -790,7 +801,7 @@ func TestListDomains(t *testing.T) {
 				Limit:  10,
 				Status: domains.DisabledStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: domains.DomainsPage{
 				Total:   2,
@@ -808,7 +819,7 @@ func TestListDomains(t *testing.T) {
 				Tag:    "admin",
 				Status: domains.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: domains.DomainsPage{
 				Total:   2,
@@ -844,7 +855,7 @@ func TestListDomains(t *testing.T) {
 				},
 				Status: domains.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: domains.DomainsPage{
 				Total:   2,
@@ -913,13 +924,148 @@ func TestListDomains(t *testing.T) {
 			},
 			err: nil,
 		},
+		{
+			desc: "list domains with order by name ascending",
+			pm: domains.Page{
+				Offset: 0,
+				Limit:  10,
+				Status: domains.AllStatus,
+				Order:  "name",
+				Dir:    ascDir,
+			},
+			response: domains.DomainsPage{
+				Total:  10,
+				Offset: 0,
+				Limit:  10,
+			},
+			err: nil,
+		},
+		{
+			desc: "list domains with order by name descending",
+			pm: domains.Page{
+				Offset: 0,
+				Limit:  10,
+				Status: domains.AllStatus,
+				Order:  "name",
+				Dir:    descDir,
+			},
+			response: domains.DomainsPage{
+				Total:  10,
+				Offset: 0,
+				Limit:  10,
+			},
+			err: nil,
+		},
+		{
+			desc: "list domains with order by created_at ascending",
+			pm: domains.Page{
+				Offset: 0,
+				Limit:  10,
+				Status: domains.AllStatus,
+				Order:  "created_at",
+				Dir:    ascDir,
+			},
+			response: domains.DomainsPage{
+				Total:   10,
+				Offset:  0,
+				Limit:   10,
+				Domains: items,
+			},
+			err: nil,
+		},
+		{
+			desc: "list domains with order by created_at descending",
+			pm: domains.Page{
+				Offset: 0,
+				Limit:  10,
+				Status: domains.AllStatus,
+				Order:  "created_at",
+				Dir:    descDir,
+			},
+			response: domains.DomainsPage{
+				Total:   10,
+				Offset:  0,
+				Limit:   10,
+				Domains: reversedDomains,
+			},
+			err: nil,
+		},
+		{
+			desc: "list domains with order by updated_at ascending",
+			pm: domains.Page{
+				Offset: 0,
+				Limit:  10,
+				Status: domains.AllStatus,
+				Order:  "updated_at",
+				Dir:    ascDir,
+			},
+			response: domains.DomainsPage{
+				Total:   10,
+				Offset:  0,
+				Limit:   10,
+				Domains: items,
+			},
+			err: nil,
+		},
+		{
+			desc: "list domains with order by updated_at descending",
+			pm: domains.Page{
+				Offset: 0,
+				Limit:  10,
+				Status: domains.AllStatus,
+				Order:  "updated_at",
+				Dir:    descDir,
+			},
+			response: domains.DomainsPage{
+				Total:   10,
+				Offset:  0,
+				Limit:   10,
+				Domains: reversedDomains,
+			},
+			err: nil,
+		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
 			dp, err := repo.ListDomains(context.Background(), tc.pm)
-			assert.Equal(t, tc.response, dp, fmt.Sprintf("%s: expected %v got %v\n", tc.desc, tc.response, dp))
+			assert.Equal(t, tc.response.Total, dp.Total, fmt.Sprintf("%s: expected total %d got %d\n", tc.desc, tc.response.Total, dp.Total))
+			assert.Equal(t, tc.response.Offset, dp.Offset, fmt.Sprintf("%s: expected offset %d got %d\n", tc.desc, tc.response.Offset, dp.Offset))
+			assert.Equal(t, tc.response.Limit, dp.Limit, fmt.Sprintf("%s: expected limit %d got %d\n", tc.desc, tc.response.Limit, dp.Limit))
+			if len(tc.response.Domains) > 0 {
+				assert.ElementsMatch(t, tc.response.Domains, dp.Domains, fmt.Sprintf("%s: expected domains %v got %v\n", tc.desc, tc.response.Domains, dp.Domains))
+			}
+			verifyDomainsOrdering(t, dp.Domains, tc.pm.Order, tc.pm.Dir)
 			assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %v got %v\n", tc.desc, tc.err, err))
 		})
 	}
 }
+
+func verifyDomainsOrdering(t *testing.T, domains []domains.Domain, order, dir string) {
+	if order == "" || len(domains) <= 1 {
+		return
+	}
+
+	for i := 0; i < len(domains)-1; i++ {
+		switch order {
+		case "name":
+			if dir == ascDir {
+				assert.LessOrEqual(t, domains[i].Name, domains[i+1].Name, fmt.Sprintf("Domains not ordered by name ascending at index %d: %s > %s", i, domains[i].Name, domains[i+1].Name))
+				continue
+			}
+			assert.GreaterOrEqual(t, domains[i].Name, domains[i+1].Name, fmt.Sprintf("Domains not ordered by name descending at index %d: %s < %s", i, domains[i].Name, domains[i+1].Name))
+		case "created_at":
+			if dir == ascDir {
+				assert.False(t, domains[i].CreatedAt.After(domains[i+1].CreatedAt), fmt.Sprintf("Domains not ordered by created_at ascending at index %d: %v > %v", i, domains[i].CreatedAt, domains[i+1].CreatedAt))
+				continue
+			}
+			assert.False(t, domains[i].CreatedAt.Before(domains[i+1].CreatedAt), fmt.Sprintf("Domains not ordered by created_at descending at index %d: %v < %v", i, domains[i].CreatedAt, domains[i+1].CreatedAt))
+		case "updated_at":
+			if dir == ascDir {
+				assert.False(t, domains[i].UpdatedAt.After(domains[i+1].UpdatedAt), fmt.Sprintf("Domains not ordered by updated_at ascending at index %d: %v > %v", i, domains[i].UpdatedAt, domains[i+1].UpdatedAt))
+				continue
+			}
+			assert.False(t, domains[i].UpdatedAt.Before(domains[i+1].UpdatedAt), fmt.Sprintf("Domains not ordered by updated_at descending at index %d: %v < %v", i, domains[i].UpdatedAt, domains[i+1].UpdatedAt))
+		}
+	}
+}

groups/postgres/groups_test.go

@@ -42,6 +42,8 @@ var (
 		Status:      groups.EnabledStatus,
 	}
 	directAccess     = "direct"
+	ascDir           = "asc"
+	descDir          = "desc"
 	availableActions = []string{
 		"update",
 		"read",
@@ -673,6 +675,7 @@ func TestRetrieveAll(t *testing.T) {
 
 	repo := postgres.New(database)
 	num := 200
+	baseTime := time.Now().UTC().Truncate(time.Microsecond)
 
 	var items []groups.Group
 	parentID := ""
@@ -685,7 +688,8 @@ func TestRetrieveAll(t *testing.T) {
 			Name:        name,
 			Description: desc,
 			Metadata:    map[string]any{"name": name},
-			CreatedAt:   time.Now().UTC().Truncate(time.Microsecond),
+			CreatedAt:   baseTime.Add(time.Duration(i) * time.Microsecond),
+			UpdatedAt:   baseTime.Add(time.Duration(i) * time.Microsecond),
 			Status:      groups.EnabledStatus,
 		}
 		_, err := repo.Save(context.Background(), group)
@@ -696,6 +700,11 @@ func TestRetrieveAll(t *testing.T) {
 		}
 	}
 
+	reversedGroups := []groups.Group{}
+	for i := len(items) - 1; i >= 0; i-- {
+		reversedGroups = append(reversedGroups, items[i])
+	}
+
 	cases := []struct {
 		desc     string
 		page     groups.Page
@@ -709,7 +718,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 0,
 					Limit:  10,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: groups.Page{
@@ -729,7 +738,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 10,
 					Limit:  10,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: groups.Page{
@@ -750,7 +759,7 @@ func TestRetrieveAll(t *testing.T) {
 					Limit:  50,
 
 					Order: "created_at",
-					Dir:   "asc",
+					Dir:   ascDir,
 				},
 			},
 			response: groups.Page{
@@ -770,7 +779,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 50,
 					Limit:  50,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: groups.Page{
@@ -790,7 +799,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 1000,
 					Limit:  50,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: groups.Page{
@@ -810,7 +819,7 @@ func TestRetrieveAll(t *testing.T) {
 					Offset: 170,
 					Limit:  50,
 					Order:  "created_at",
-					Dir:    "asc",
+					Dir:    ascDir,
 				},
 			},
 			response: groups.Page{
@@ -970,6 +979,124 @@ func TestRetrieveAll(t *testing.T) {
 			},
 			err: nil,
 		},
+		{
+			desc: "retrieve groups with order by name ascending",
+			page: groups.Page{
+				PageMeta: groups.PageMeta{
+					Offset: 0,
+					Limit:  10,
+					Order:  "name",
+					Dir:    ascDir,
+				},
+			},
+			response: groups.Page{
+				PageMeta: groups.PageMeta{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve groups with order by name descending",
+			page: groups.Page{
+				PageMeta: groups.PageMeta{
+					Offset: 0,
+					Limit:  10,
+					Order:  "name",
+					Dir:    descDir,
+				},
+			},
+			response: groups.Page{
+				PageMeta: groups.PageMeta{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve groups with order by created_at ascending",
+			page: groups.Page{
+				PageMeta: groups.PageMeta{
+					Offset: 0,
+					Limit:  10,
+					Order:  "created_at",
+					Dir:    ascDir,
+				},
+			},
+			response: groups.Page{
+				PageMeta: groups.PageMeta{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Groups: items[:10],
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve groups with order by created_at descending",
+			page: groups.Page{
+				PageMeta: groups.PageMeta{
+					Offset: 0,
+					Limit:  10,
+					Order:  "created_at",
+					Dir:    descDir,
+				},
+			},
+			response: groups.Page{
+				PageMeta: groups.PageMeta{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Groups: reversedGroups[:10],
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve groups with order by updated_at ascending",
+			page: groups.Page{
+				PageMeta: groups.PageMeta{
+					Offset: 0,
+					Limit:  10,
+					Order:  "updated_at",
+					Dir:    ascDir,
+				},
+			},
+			response: groups.Page{
+				PageMeta: groups.PageMeta{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Groups: items[:10],
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve groups with order by updated_at descending",
+			page: groups.Page{
+				PageMeta: groups.PageMeta{
+					Offset: 0,
+					Limit:  10,
+					Order:  "updated_at",
+					Dir:    descDir,
+				},
+			},
+			response: groups.Page{
+				PageMeta: groups.PageMeta{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Groups: reversedGroups[:10],
+			},
+			err: nil,
+		},
 	}
 
 	for _, tc := range cases {
@@ -981,8 +1108,11 @@ func TestRetrieveAll(t *testing.T) {
 				assert.Equal(t, tc.response.Limit, groups.Limit, fmt.Sprintf("%s: expected %d got %d\n", tc.desc, tc.response.Limit, groups.Limit))
 				assert.Equal(t, tc.response.Offset, groups.Offset, fmt.Sprintf("%s: expected %d got %d\n", tc.desc, tc.response.Offset, groups.Offset))
 				got := stripGroupDetails(groups.Groups)
-				resp := stripGroupDetails(tc.response.Groups)
-				assert.ElementsMatch(t, resp, got, fmt.Sprintf("%s: expected %+v got %+v\n", tc.desc, resp, got))
+				if len(tc.response.Groups) > 0 {
+					resp := stripGroupDetails(tc.response.Groups)
+					assert.ElementsMatch(t, resp, got, fmt.Sprintf("%s: expected %+v got %+v\n", tc.desc, resp, got))
+				}
+				verifyGroupsOrdering(t, groups.Groups, tc.page.PageMeta.Order, tc.page.PageMeta.Dir)
 			default:
 				assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
 			}
@@ -2122,9 +2252,39 @@ func stripGroupDetails(groups []groups.Group) []groups.Group {
 		groups[i].Level = 0
 		groups[i].Path = ""
 		groups[i].CreatedAt = validTimestamp
+		groups[i].UpdatedAt = validTimestamp
 		groups[i].Actions = nil
 		groups[i].AccessProviderRoleActions = nil
 	}
 
 	return groups
 }
+
+func verifyGroupsOrdering(t *testing.T, groups []groups.Group, order, dir string) {
+	if order == "" || len(groups) <= 1 {
+		return
+	}
+
+	for i := 0; i < len(groups)-1; i++ {
+		switch order {
+		case "name":
+			if dir == ascDir {
+				assert.LessOrEqual(t, groups[i].Name, groups[i+1].Name, fmt.Sprintf("Groups not ordered by name ascending at index %d: %s > %s", i, groups[i].Name, groups[i+1].Name))
+				continue
+			}
+			assert.GreaterOrEqual(t, groups[i].Name, groups[i+1].Name, fmt.Sprintf("Groups not ordered by name descending at index %d: %s < %s", i, groups[i].Name, groups[i+1].Name))
+		case "created_at":
+			if dir == ascDir {
+				assert.False(t, groups[i].CreatedAt.After(groups[i+1].CreatedAt), fmt.Sprintf("Groups not ordered by created_at ascending at index %d: %v > %v", i, groups[i].CreatedAt, groups[i+1].CreatedAt))
+				continue
+			}
+			assert.False(t, groups[i].CreatedAt.Before(groups[i+1].CreatedAt), fmt.Sprintf("Groups not ordered by created_at descending at index %d: %v < %v", i, groups[i].CreatedAt, groups[i+1].CreatedAt))
+		case "updated_at":
+			if dir == ascDir {
+				assert.False(t, groups[i].UpdatedAt.After(groups[i+1].UpdatedAt), fmt.Sprintf("Groups not ordered by updated_at ascending at index %d: %v > %v", i, groups[i].UpdatedAt, groups[i+1].UpdatedAt))
+				continue
+			}
+			assert.False(t, groups[i].UpdatedAt.Before(groups[i+1].UpdatedAt), fmt.Sprintf("Groups not ordered by updated_at descending at index %d: %v < %v", i, groups[i].UpdatedAt, groups[i+1].UpdatedAt))
+		}
+	}
+}

users/postgres/users_test.go

@@ -23,10 +23,13 @@ import (
 const maxNameSize = 254
 
 var (
-	invalidName = strings.Repeat("m", maxNameSize+10)
-	password    = "$tr0ngPassw0rd"
-	namesgen    = namegenerator.NewGenerator()
-	emailSuffix = "@example.com"
+	invalidName    = strings.Repeat("m", maxNameSize+10)
+	password       = "$tr0ngPassw0rd"
+	namesgen       = namegenerator.NewGenerator()
+	emailSuffix    = "@example.com"
+	validTimestamp = time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
+	ascDir         = "asc"
+	descDir        = "desc"
 )
 
 func TestUsersSave(t *testing.T) {
@@ -370,6 +373,7 @@ func TestRetrieveAll(t *testing.T) {
 			Status:    users.EnabledStatus,
 			Tags:      []string{"tag1"},
 			CreatedAt: baseTime.Add(time.Duration(i) * time.Millisecond),
+			UpdatedAt: baseTime.Add(time.Duration(i) * time.Millisecond),
 		}
 		if i%50 == 0 {
 			user.Metadata = map[string]any{
@@ -386,6 +390,11 @@ func TestRetrieveAll(t *testing.T) {
 		}
 	}
 
+	reversedUsers := []users.User{}
+	for i := len(items) - 1; i >= 0; i-- {
+		reversedUsers = append(reversedUsers, items[i])
+	}
+
 	cases := []struct {
 		desc     string
 		pageMeta users.Page
@@ -400,7 +409,7 @@ func TestRetrieveAll(t *testing.T) {
 				Role:   users.AllRole,
 				Status: users.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -420,7 +429,7 @@ func TestRetrieveAll(t *testing.T) {
 				Role:   users.AllRole,
 				Status: users.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -440,7 +449,7 @@ func TestRetrieveAll(t *testing.T) {
 				Role:   users.AllRole,
 				Status: users.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -477,7 +486,7 @@ func TestRetrieveAll(t *testing.T) {
 				Role:   users.AllRole,
 				Status: users.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -511,7 +520,7 @@ func TestRetrieveAll(t *testing.T) {
 				Role:   users.AllRole,
 				Status: users.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -551,7 +560,7 @@ func TestRetrieveAll(t *testing.T) {
 				Role:      users.AllRole,
 				Status:    users.AllStatus,
 				Order:     "created_at",
-				Dir:       "asc",
+				Dir:       ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -572,7 +581,7 @@ func TestRetrieveAll(t *testing.T) {
 				Role:     users.AllRole,
 				Status:   users.AllStatus,
 				Order:    "created_at",
-				Dir:      "asc",
+				Dir:      ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -592,7 +601,7 @@ func TestRetrieveAll(t *testing.T) {
 				Limit:  200,
 				Role:   users.AllRole,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -612,7 +621,7 @@ func TestRetrieveAll(t *testing.T) {
 				Limit:  200,
 				Role:   users.AllRole,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -631,7 +640,7 @@ func TestRetrieveAll(t *testing.T) {
 				Limit:  200,
 				Role:   users.AllRole,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -690,7 +699,7 @@ func TestRetrieveAll(t *testing.T) {
 				Role:   users.AllRole,
 				Status: users.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -731,7 +740,7 @@ func TestRetrieveAll(t *testing.T) {
 				Limit:  200,
 				Status: users.AllStatus,
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			page: users.UsersPage{
 				Page: users.Page{
@@ -761,6 +770,162 @@ func TestRetrieveAll(t *testing.T) {
 			},
 			err: nil,
 		},
+		{
+			desc: "retrieve users with order by first_name ascending",
+			pageMeta: users.Page{
+				Offset: 0,
+				Limit:  10,
+				Role:   users.AllRole,
+				Status: users.AllStatus,
+				Order:  "first_name",
+				Dir:    ascDir,
+			},
+			page: users.UsersPage{
+				Page: users.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve users with order by first_name descending",
+			pageMeta: users.Page{
+				Offset: 0,
+				Limit:  10,
+				Role:   users.AllRole,
+				Status: users.AllStatus,
+				Order:  "first_name",
+				Dir:    descDir,
+			},
+			page: users.UsersPage{
+				Page: users.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve users with order by username ascending",
+			pageMeta: users.Page{
+				Offset: 0,
+				Limit:  10,
+				Role:   users.AllRole,
+				Status: users.AllStatus,
+				Order:  "username",
+				Dir:    ascDir,
+			},
+			page: users.UsersPage{
+				Page: users.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve users with order by username descending",
+			pageMeta: users.Page{
+				Offset: 0,
+				Limit:  10,
+				Role:   users.AllRole,
+				Status: users.AllStatus,
+				Order:  "username",
+				Dir:    descDir,
+			},
+			page: users.UsersPage{
+				Page: users.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve users with order by created_at ascending",
+			pageMeta: users.Page{
+				Offset: 0,
+				Limit:  10,
+				Role:   users.AllRole,
+				Status: users.AllStatus,
+				Order:  "created_at",
+				Dir:    ascDir,
+			},
+			page: users.UsersPage{
+				Page: users.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Users: items[:10],
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve users with order by created_at descending",
+			pageMeta: users.Page{
+				Offset: 0,
+				Limit:  10,
+				Role:   users.AllRole,
+				Status: users.AllStatus,
+				Order:  "created_at",
+				Dir:    descDir,
+			},
+			page: users.UsersPage{
+				Page: users.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Users: reversedUsers[:10],
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve users with order by updated_at ascending",
+			pageMeta: users.Page{
+				Offset: 0,
+				Limit:  10,
+				Role:   users.AllRole,
+				Status: users.AllStatus,
+				Order:  "updated_at",
+				Dir:    ascDir,
+			},
+			page: users.UsersPage{
+				Page: users.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Users: items[:10],
+			},
+			err: nil,
+		},
+		{
+			desc: "retrieve users with order by updated_at descending",
+			pageMeta: users.Page{
+				Offset: 0,
+				Limit:  10,
+				Role:   users.AllRole,
+				Status: users.AllStatus,
+				Order:  "updated_at",
+				Dir:    descDir,
+			},
+			page: users.UsersPage{
+				Page: users.Page{
+					Total:  uint64(num),
+					Offset: 0,
+					Limit:  10,
+				},
+				Users: reversedUsers[:10],
+			},
+			err: nil,
+		},
 	}
 
 	for _, tc := range cases {
@@ -770,7 +935,10 @@ func TestRetrieveAll(t *testing.T) {
 		assert.Equal(t, tc.page.Offset, page.Offset, fmt.Sprintf("%s: expected %d got %d\n", tc.desc, tc.page.Offset, page.Offset))
 		assert.Equal(t, tc.page.Limit, page.Limit, fmt.Sprintf("%s: expected %d got %d\n", tc.desc, tc.page.Limit, page.Limit))
 		assert.Equal(t, tc.page.Page, page.Page, fmt.Sprintf("%s: expected  %v, got %v", tc.desc, tc.page, page))
-		assert.ElementsMatch(t, tc.page.Users, page.Users, fmt.Sprintf("%s: expected %v, got %v", tc.desc, tc.page.Users, page.Users))
+		if len(tc.page.Users) > 0 {
+			assert.ElementsMatch(t, stripUserDetails(tc.page.Users), stripUserDetails(page.Users), fmt.Sprintf("%s: expected %v, got %v", tc.desc, tc.page.Users, page.Users))
+		}
+		verifyUsersOrdering(t, page.Users, tc.pageMeta.Order, tc.pageMeta.Dir)
 		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
 	}
 }
@@ -842,7 +1010,7 @@ func TestSearch(t *testing.T) {
 			page: users.Page{
 				Limit: 10,
 				Order: "name",
-				Dir:   "asc",
+				Dir:   ascDir,
 			},
 			response: users.UsersPage{
 				Users: expectedUsers[0:10],
@@ -875,7 +1043,7 @@ func TestSearch(t *testing.T) {
 				Offset: 10,
 				Limit:  10,
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: users.UsersPage{
 				Users: expectedUsers[10:20],
@@ -908,7 +1076,7 @@ func TestSearch(t *testing.T) {
 				Offset: 190,
 				Limit:  50,
 				Order:  "name",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: users.UsersPage{
 				Page: users.Page{
@@ -926,7 +1094,7 @@ func TestSearch(t *testing.T) {
 				Offset:    0,
 				Limit:     10,
 				Order:     "first_name",
-				Dir:       "asc",
+				Dir:       ascDir,
 			},
 			response: users.UsersPage{
 				Users: findUsers(expectedUsers, expectedUsers[0].FirstName[:4], 0, 10),
@@ -979,7 +1147,7 @@ func TestSearch(t *testing.T) {
 				Offset: 0,
 				Limit:  10,
 				Order:  "first_name",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: users.UsersPage{
 				Users: findUsers(expectedUsers, expectedUsers[0].FirstName[:4], 0, 10),
@@ -1046,7 +1214,7 @@ func TestSearch(t *testing.T) {
 			desc: "with name in asc order",
 			page: users.Page{
 				Order:     "first_name",
-				Dir:       "asc",
+				Dir:       ascDir,
 				FirstName: expectedUsers[0].FirstName[:1],
 				Offset:    0,
 				Limit:     10,
@@ -1058,7 +1226,7 @@ func TestSearch(t *testing.T) {
 			desc: "with name in desc order",
 			page: users.Page{
 				Order:     "first_name",
-				Dir:       "desc",
+				Dir:       descDir,
 				FirstName: expectedUsers[0].FirstName[:1],
 				Offset:    0,
 				Limit:     10,
@@ -1071,7 +1239,7 @@ func TestSearch(t *testing.T) {
 			page: users.Page{
 				LastName: expectedUsers[0].LastName[:1],
 				Order:    "last_name",
-				Dir:      "asc",
+				Dir:      ascDir,
 			},
 			response: users.UsersPage{
 				Users: []users.User{expectedUsers[0]},
@@ -1088,7 +1256,7 @@ func TestSearch(t *testing.T) {
 			page: users.Page{
 				Username: expectedUsers[0].Credentials.Username[:1],
 				Order:    "username",
-				Dir:      "asc",
+				Dir:      ascDir,
 			},
 			response: users.UsersPage{
 				Users: []users.User{expectedUsers[0]},
@@ -1807,7 +1975,7 @@ func TestRetrieveByIDs(t *testing.T) {
 				Limit:  10,
 				IDs:    getIDs(items[0:3]),
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: users.UsersPage{
 				Page: users.Page{
@@ -1841,7 +2009,7 @@ func TestRetrieveByIDs(t *testing.T) {
 				Offset: 10,
 				IDs:    getIDs(items[0:20]),
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: users.UsersPage{
 				Page: users.Page{
@@ -1859,7 +2027,7 @@ func TestRetrieveByIDs(t *testing.T) {
 				Limit: 10,
 				IDs:   getIDs(items[0:20]),
 				Order: "created_at",
-				Dir:   "asc",
+				Dir:   ascDir,
 			},
 			response: users.UsersPage{
 				Page: users.Page{
@@ -1895,7 +2063,7 @@ func TestRetrieveByIDs(t *testing.T) {
 				Limit:  10,
 				IDs:    getIDs(items[0:20]),
 				Order:  "created_at",
-				Dir:    "asc",
+				Dir:    ascDir,
 			},
 			response: users.UsersPage{
 				Page: users.Page{
@@ -1932,7 +2100,7 @@ func TestRetrieveByIDs(t *testing.T) {
 				FirstName: items[0].FirstName,
 				IDs:       getIDs(items[0:20]),
 				Order:     "created_at",
-				Dir:       "asc",
+				Dir:       ascDir,
 			},
 			response: users.UsersPage{
 				Page: users.Page{
@@ -2156,3 +2324,46 @@ func getIDs(usrs []users.User) []string {
 
 	return ids
 }
+
+func stripUserDetails(users []users.User) []users.User {
+	for i := range users {
+		users[i].CreatedAt = validTimestamp
+		users[i].UpdatedAt = validTimestamp
+	}
+	return users
+}
+
+func verifyUsersOrdering(t *testing.T, users []users.User, order, dir string) {
+	if order == "" || len(users) <= 1 {
+		return
+	}
+
+	for i := 0; i < len(users)-1; i++ {
+		switch order {
+		case "first_name":
+			if dir == ascDir {
+				assert.LessOrEqual(t, users[i].FirstName, users[i+1].FirstName, fmt.Sprintf("Users not ordered by first_name ascending at index %d: %s > %s", i, users[i].FirstName, users[i+1].FirstName))
+				continue
+			}
+			assert.GreaterOrEqual(t, users[i].FirstName, users[i+1].FirstName, fmt.Sprintf("Users not ordered by first_name descending at index %d: %s < %s", i, users[i].FirstName, users[i+1].FirstName))
+		case "username":
+			if dir == ascDir {
+				assert.LessOrEqual(t, users[i].Credentials.Username, users[i+1].Credentials.Username, fmt.Sprintf("Users not ordered by username ascending at index %d: %s > %s", i, users[i].Credentials.Username, users[i+1].Credentials.Username))
+				continue
+			}
+			assert.GreaterOrEqual(t, users[i].Credentials.Username, users[i+1].Credentials.Username, fmt.Sprintf("Users not ordered by username descending at index %d: %s < %s", i, users[i].Credentials.Username, users[i+1].Credentials.Username))
+		case "created_at":
+			if dir == ascDir {
+				assert.False(t, users[i].CreatedAt.After(users[i+1].CreatedAt), fmt.Sprintf("Users not ordered by created_at ascending at index %d: %v > %v", i, users[i].CreatedAt, users[i+1].CreatedAt))
+				continue
+			}
+			assert.False(t, users[i].CreatedAt.Before(users[i+1].CreatedAt), fmt.Sprintf("Users not ordered by created_at descending at index %d: %v < %v", i, users[i].CreatedAt, users[i+1].CreatedAt))
+		case "updated_at":
+			if dir == ascDir {
+				assert.False(t, users[i].UpdatedAt.After(users[i+1].UpdatedAt), fmt.Sprintf("Users not ordered by updated_at ascending at index %d: %v > %v", i, users[i].UpdatedAt, users[i+1].UpdatedAt))
+				continue
+			}
+			assert.False(t, users[i].UpdatedAt.Before(users[i+1].UpdatedAt), fmt.Sprintf("Users not ordered by updated_at descending at index %d: %v < %v", i, users[i].UpdatedAt, users[i+1].UpdatedAt))
+		}
+	}
+}