feat(tests): add tests for Credential and leetcode.cn

Author: jinzcdev

src/_tests/credential-cn.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { Credential } from "../credential-cn";
+
+describe("Credential", () => {
+    it("should be able to pass session and csrf directly", async () => {
+        const credential = new Credential({
+            session: "test_session",
+            csrf: "test_csrf",
+        });
+        expect(credential.csrf).toBe("test_csrf");
+        expect(credential.session).toBe("test_session");
+    });
+
+    it("should be able to init without session", async () => {
+        const credential = new Credential();
+        await credential.init();
+        expect(credential.csrf).toBeDefined();
+        expect(credential.session).toBeUndefined();
+    });
+
+    it("should be able to init with session", async () => {
+        const credential = new Credential();
+        await credential.init("test_session");
+        expect(credential.csrf).toBeDefined();
+        expect(credential.session).toBe("test_session");
+    });
+});

src/_tests/leetcode-cn.test.ts

@@ -1,8 +1,10 @@
-import { describe, expect, it } from "vitest";
+import dotenv from "dotenv";
+import { beforeAll, describe, expect, it } from "vitest";
 import { Cache } from "../cache";
+import Credential from "../credential-cn";
 import { LeetCodeCN } from "../leetcode-cn";
 
-describe("LeetCode", { timeout: 15_000 }, () => {
+describe("LeetCodeCN", { timeout: 15_000 }, () => {
     describe("General", () => {
         it("should be an instance of LeetCodeCN", () => {
             const lc = new LeetCodeCN();
@@ -16,6 +18,48 @@ describe("LeetCode", { timeout: 15_000 }, () => {
         });
     });
 
+    describe("Authenticated", () => {
+        dotenv.config();
+        const credential = new Credential();
+        let lc: LeetCodeCN;
+
+        beforeAll(async () => {
+            await credential.init(process.env["TEST_CN_LEETCODE_SESSION"]);
+            lc = new LeetCodeCN(credential);
+        });
+
+        it.skipIf(!process.env["TEST_CN_LEETCODE_SESSION"])(
+            "should be able to get own submissions with slug",
+            async () => {
+                const submissions = await lc.problem_submissions({
+                    limit: 30,
+                    offset: 0,
+                    slug: "two-sum",
+                });
+                expect(Array.isArray(submissions)).toBe(true);
+            },
+        );
+
+        it.skipIf(!process.env["TEST_CN_LEETCODE_SESSION"])(
+            "should be able to get user progress questions",
+            async () => {
+                const progress = await lc.user_progress_questions({
+                    skip: 0,
+                    limit: 20,
+                });
+                expect(progress).toBeDefined();
+            },
+        );
+
+        it.skipIf(!process.env["TEST_CN_LEETCODE_SESSION"])(
+            "should be able to get user signed in status",
+            async () => {
+                const user = await lc.userStatus();
+                expect(user.isSignedIn).toBe(true);
+            },
+        );
+    });
+
     describe("Unauthenticated", () => {
         const lc = new LeetCodeCN();
         lc.limiter.limit = 100;
@@ -26,45 +70,43 @@ describe("LeetCode", { timeout: 15_000 }, () => {
 
         it("should be able to get user profile", async () => {
             const user = await lc.user("LeetCode");
-            expect(user.userProfilePublicProfile.username).toBe("LeetCode");
+            expect(user.userProfilePublicProfile.profile.realName).toBe("LeetCode");
         });
 
-        it("should be able to use graphql", async () => {
-            const { data } = await lc.graphql({
-                operationName: "data",
-                variables: { username: "LeetCode" },
-                query: `
-                query data($username: String!) {
-                    progress: userProfileUserQuestionProgress(userSlug: $username) {
-                        ac: numAcceptedQuestions { difficulty count }
-                        wa: numFailedQuestions { difficulty count }
-                        un: numUntouchedQuestions { difficulty count }
-                    }
-                    user: userProfilePublicProfile(userSlug: $username) {
-                        username 
-                        ranking: siteRanking
-                        profile { 
-                            realname: realName 
-                            about: aboutMe 
-                            avatar: userAvatar 
-                            skills: skillTags 
-                            country: countryName
-                        }
-                    }
-                    submissions: recentSubmitted(userSlug: $username) {
-                        id: submissionId
-                        status
-                        lang 
-                        time: submitTime
-                        question { 
-                            title: translatedTitle 
-                            slug: titleSlug 
-                        }
-                    }
-                }
-                `,
-            });
-            expect(data.user.username).toBe("LeetCode");
+        it("should be able to get user's contest info", async () => {
+            const contest = await lc.user_contest_info("LeetCode");
+            expect(contest).toBeDefined();
+        });
+
+        it("should be able to get user's recent submissions", async () => {
+            const submissions = await lc.recent_submissions("LeetCode");
+            expect(Array.isArray(submissions)).toBe(true);
+        });
+
+        it("should be able to get problems list", async () => {
+            const problems = await lc.problems({ limit: 10 });
+            expect(problems.questions.length).toBe(10);
+        });
+
+        it("should be able to get problem by slug", async () => {
+            const problem = await lc.problem("two-sum");
+            expect(problem.titleSlug).toBe("two-sum");
+        });
+
+        it("should be able to get daily challenge", async () => {
+            const daily = await lc.daily();
+            expect(daily.question).toBeDefined();
+        });
+
+        it("should be able to get user status", async () => {
+            const user = await lc.userStatus();
+            expect(user.isSignedIn).toBe(false);
+        });
+
+        it("should throw error when trying to get submissions without slug", async () => {
+            await expect(lc.problem_submissions({ limit: 30, offset: 0 })).rejects.toThrow(
+                "LeetCodeCN requires slug parameter for submissions",
+            );
         });
 
         it("should be able to use graphql noj-go", async () => {