[pull] master from monkeytypegame:master

backend/__tests__/__integration__/services/weekly-xp-leaderboard.spec.ts

@@ -48,22 +48,25 @@ describe("Weekly XP Leaderboards", () => {
         const results = await lb.getResults(0, 10, leaderboardsConfig, true);
 
         //THEN
-        expect(results).toEqual([
-          {
-            ...user1,
-            rank: 1,
-            timeTypedSeconds: 10,
-            totalXp: 150,
-            isPremium: false,
-          },
-          {
-            ...user2,
-            rank: 2,
-            timeTypedSeconds: 7,
-            totalXp: 100,
-            isPremium: true,
-          },
-        ]);
+        expect(results).toEqual({
+          count: 2,
+          entries: [
+            {
+              ...user1,
+              rank: 1,
+              timeTypedSeconds: 10,
+              totalXp: 150,
+              isPremium: false,
+            },
+            {
+              ...user2,
+              rank: 2,
+              timeTypedSeconds: 7,
+              totalXp: 100,
+              isPremium: true,
+            },
+          ],
+        });
       });
     });
 
@@ -77,10 +80,13 @@ describe("Weekly XP Leaderboards", () => {
         const results = await lb.getResults(0, 10, leaderboardsConfig, true);
 
         //THEN
-        expect(results).toEqual([
-          { rank: 1, totalXp: 150, ...user1 },
-          { rank: 2, totalXp: 100, ...user2 },
-        ]);
+        expect(results).toEqual({
+          count: 2,
+          entries: [
+            { rank: 1, totalXp: 150, ...user1 },
+            { rank: 2, totalXp: 100, ...user2 },
+          ],
+        });
       });
 
       it("gets results for page", async () => {
@@ -94,10 +100,13 @@ describe("Weekly XP Leaderboards", () => {
         const results = await lb.getResults(1, 2, leaderboardsConfig, true);
 
         //THEN
-        expect(results).toEqual([
-          { rank: 3, totalXp: 50, ...user3 },
-          { rank: 4, totalXp: 25, ...user4 },
-        ]);
+        expect(results).toEqual({
+          count: 4,
+          entries: [
+            { rank: 3, totalXp: 50, ...user3 },
+            { rank: 4, totalXp: 25, ...user4 },
+          ],
+        });
       });
 
       it("gets results without premium", async () => {
@@ -109,10 +118,73 @@ describe("Weekly XP Leaderboards", () => {
         const results = await lb.getResults(0, 10, leaderboardsConfig, false);
 
         //THEN
-        expect(results).toEqual([
-          { rank: 1, totalXp: 150, ...user1, isPremium: undefined },
-          { rank: 2, totalXp: 100, ...user2, isPremium: undefined },
+        expect(results).toEqual({
+          count: 2,
+          entries: [
+            { rank: 1, totalXp: 150, ...user1, isPremium: undefined },
+            { rank: 2, totalXp: 100, ...user2, isPremium: undefined },
+          ],
+        });
+      });
+
+      it("gets results for friends only", async () => {
+        //GIVEN
+        const _user1 = await givenResult(100);
+        const user2 = await givenResult(75);
+        const _user3 = await givenResult(50);
+        const user4 = await givenResult(25);
+
+        //WHEN
+        const results = await lb.getResults(0, 5, leaderboardsConfig, true, [
+          user2.uid,
+          user4.uid,
+          new ObjectId().toHexString(),
+        ]);
+
+        //THEN
+        expect(results).toEqual({
+          count: 2,
+          entries: [
+            { rank: 2, friendsRank: 1, totalXp: 75, ...user2 },
+            { rank: 4, friendsRank: 2, totalXp: 25, ...user4 },
+          ],
+        });
+      });
+
+      it("gets results for friends only with page", async () => {
+        //GIVEN
+        const user1 = await givenResult(100);
+        const user2 = await givenResult(75);
+        const _user3 = await givenResult(50);
+        const user4 = await givenResult(25);
+        const _user5 = await givenResult(5);
+
+        //WHEN
+        const results = await lb.getResults(1, 2, leaderboardsConfig, true, [
+          user1.uid,
+          user2.uid,
+          user4.uid,
+          new ObjectId().toHexString(),
         ]);
+
+        //THEN
+        expect(results).toEqual({
+          count: 3,
+          entries: [{ rank: 4, friendsRank: 3, totalXp: 25, ...user4 }],
+        });
+      });
+
+      it("should return empty list if no friends", async () => {
+        //GIVEN
+
+        //WHEN
+        const results = await lb.getResults(0, 5, leaderboardsConfig, true, []);
+
+        //THEN
+        expect(results).toEqual({
+          count: 0,
+          entries: [],
+        });
       });
     });
 
@@ -127,18 +199,30 @@ describe("Weekly XP Leaderboards", () => {
         //THEN
         expect(rank).toEqual({ rank: 2, totalXp: 100, ...user1 });
       });
-    });
 
-    describe("getCount", () => {
-      it("gets count", async () => {
+      it("should return null for unknown user", async () => {
+        expect(await lb.getRank("decoy", leaderboardsConfig)).toBeNull();
+        expect(
+          await lb.getRank("decoy", leaderboardsConfig, ["unknown", "unknown2"])
+        ).toBeNull();
+      });
+
+      it("gets rank for friends", async () => {
         //GIVEN
-        await givenResult(100);
-        await givenResult(150);
+        const user1 = await givenResult(50);
+        const user2 = await givenResult(60);
+        const _user3 = await givenResult(70);
 
-        //WHEN
-        const count = await lb.getCount();
-        //THEN
-        expect(count).toEqual(2);
+        const friends = [user1.uid, user2.uid, "decoy"];
+
+        //WHEN / THEN
+        expect(
+          await lb.getRank(user2.uid, leaderboardsConfig, friends)
+        ).toEqual({ rank: 2, friendsRank: 1, totalXp: 60, ...user2 });
+
+        expect(
+          await lb.getRank(user1.uid, leaderboardsConfig, friends)
+        ).toEqual({ rank: 3, friendsRank: 2, totalXp: 50, ...user1 });
       });
     });
 
@@ -154,9 +238,10 @@ describe("Weekly XP Leaderboards", () => {
       );
       //THEN
       expect(await lb.getRank(cheater.uid, leaderboardsConfig)).toBeNull();
-      expect(await lb.getResults(0, 50, leaderboardsConfig, true)).toEqual([
-        { rank: 1, totalXp: 1000, ...validUser },
-      ]);
+      expect(await lb.getResults(0, 50, leaderboardsConfig, true)).toEqual({
+        count: 1,
+        entries: [{ rank: 1, totalXp: 1000, ...validUser }],
+      });
     });
 
     async function givenResult(