@eduware/oneroster 1.0.0 → 1.1.0

package/test/classlink.test.ts

@@ -8,17 +8,17 @@
  * each API call to complete before proceeding.
  */
 
-import * as dotenv from "dotenv";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-dotenv.config({ path: path.join(__dirname, ".env") });
+dotenv.config({ path: path.join(__dirname, '.env') });
 
-import { ClassLink } from "../src/clients/index.js";
-import { OneRoster } from "../src/index.js";
+import { ClassLink } from '../src/clients/index.js';
+import { OneRoster } from '../src/index.js';
 
 // Set test timeout to 30 seconds for API calls
 const TEST_TIMEOUT = 30000;
@@ -28,68 +28,56 @@ const TEST_TIMEOUT = 30000;
 // ============================================================================
 
 interface TestResult {
-  endpoint: string;
-  status: "passed" | "failed";
-  error?: string;
+    endpoint: string;
+    status: 'passed' | 'failed';
+    error?: string;
 }
 
 const testResults: Map<string, TestResult[]> = new Map();
 
 function recordResult(
-  category: string,
-  endpoint: string,
-  status: "passed" | "failed",
-  error?: string,
+    category: string,
+    endpoint: string,
+    status: 'passed' | 'failed',
+    error?: string
 ) {
-  if (!testResults.has(category)) {
-    testResults.set(category, []);
-  }
-  testResults.get(category)!.push({ endpoint, status, error });
+    if (!testResults.has(category)) {
+        testResults.set(category, []);
+    }
+    testResults.get(category)!.push({ endpoint, status, error });
 }
 
 function printSummary() {
-  console.log("\n");
-  console.log(
-    "╔══════════════════════════════════════════════════════════════════╗",
-  );
-  console.log(
-    "║                 CLASSLINK TEST RESULTS SUMMARY                   ║",
-  );
-  console.log(
-    "╚══════════════════════════════════════════════════════════════════╝",
-  );
-
-  for (const [category, results] of testResults) {
-    const passed = results.filter((r) => r.status === "passed");
-    const failed = results.filter((r) => r.status === "failed");
-
-    console.log(
-      `\n┌──────────────────────────────────────────────────────────────────┐`,
-    );
-    console.log(
-      `│ ${category} - ${passed.length} passed, ${failed.length} failed`,
-    );
-    console.log(
-      `└──────────────────────────────────────────────────────────────────┘`,
-    );
-
-    if (passed.length > 0) {
-      console.log("\n  ✅ PASSED:");
-      for (const r of passed) {
-        console.log(`     • ${r.endpoint}`);
-      }
-    }
+    console.log('\n');
+    console.log('╔══════════════════════════════════════════════════════════════════╗');
+    console.log('║                 CLASSLINK TEST RESULTS SUMMARY                   ║');
+    console.log('╚══════════════════════════════════════════════════════════════════╝');
+
+    for (const [category, results] of testResults) {
+        const passed = results.filter((r) => r.status === 'passed');
+        const failed = results.filter((r) => r.status === 'failed');
+
+        console.log(`\n┌──────────────────────────────────────────────────────────────────┐`);
+        console.log(`│ ${category} - ${passed.length} passed, ${failed.length} failed`);
+        console.log(`└──────────────────────────────────────────────────────────────────┘`);
 
-    if (failed.length > 0) {
-      console.log("\n  ❌ FAILED:");
-      for (const r of failed) {
-        const reason = r.error ? ` (${r.error})` : "";
-        console.log(`     • ${r.endpoint}${reason}`);
-      }
+        if (passed.length > 0) {
+            console.log('\n  ✅ PASSED:');
+            for (const r of passed) {
+                console.log(`     • ${r.endpoint}`);
+            }
+        }
+
+        if (failed.length > 0) {
+            console.log('\n  ❌ FAILED:');
+            for (const r of failed) {
+                const reason = r.error ? ` (${r.error})` : '';
+                console.log(`     • ${r.endpoint}${reason}`);
+            }
+        }
     }
-  }
 
-  console.log("\n" + "═".repeat(70));
+    console.log('\n' + '═'.repeat(70));
 }
 
 // ============================================================================
@@ -97,79 +85,79 @@ function printSummary() {
 // ============================================================================
 
 interface OAuth1Config {
-  type: "oauth1";
-  serverURL: string;
-  clientID: string;
-  clientSecret: string;
+    type: 'oauth1';
+    serverURL: string;
+    clientID: string;
+    clientSecret: string;
 }
 
 interface OAuth2Config {
-  type: "oauth2";
-  serverURL: string;
-  clientID: string;
-  clientSecret: string;
-  tokenURL?: string;
+    type: 'oauth2';
+    serverURL: string;
+    clientID: string;
+    clientSecret: string;
+    tokenURL?: string;
 }
 
 interface BearerConfig {
-  type: "bearer";
-  serverURL: string;
-  bearerToken: string;
+    type: 'bearer';
+    serverURL: string;
+    bearerToken: string;
 }
 
 type AuthConfig = OAuth1Config | OAuth2Config | BearerConfig;
 
 function getOAuth1Config(): OAuth1Config | null {
-  const serverURL = process.env.CLASSLINK_OAUTH1_SERVER_URL;
-  const clientID = process.env.CLASSLINK_OAUTH1_CLIENT_ID;
-  const clientSecret = process.env.CLASSLINK_OAUTH1_CLIENT_SECRET;
-  if (!serverURL || !clientID || !clientSecret) return null;
-  return { type: "oauth1", serverURL, clientID, clientSecret };
+    const serverURL = process.env.CLASSLINK_OAUTH1_SERVER_URL;
+    const clientID = process.env.CLASSLINK_OAUTH1_CLIENT_ID;
+    const clientSecret = process.env.CLASSLINK_OAUTH1_CLIENT_SECRET;
+    if (!serverURL || !clientID || !clientSecret) return null;
+    return { type: 'oauth1', serverURL, clientID, clientSecret };
 }
 
 function getOAuth2Config(): OAuth2Config | null {
-  const serverURL = process.env.CLASSLINK_OAUTH2_SERVER_URL;
-  const clientID = process.env.CLASSLINK_OAUTH2_CLIENT_ID;
-  const clientSecret = process.env.CLASSLINK_OAUTH2_CLIENT_SECRET;
-  const tokenURL = process.env.CLASSLINK_OAUTH2_TOKEN_URL;
-  if (!serverURL || !clientID || !clientSecret) return null;
-  return { type: "oauth2", serverURL, clientID, clientSecret, tokenURL };
+    const serverURL = process.env.CLASSLINK_OAUTH2_SERVER_URL;
+    const clientID = process.env.CLASSLINK_OAUTH2_CLIENT_ID;
+    const clientSecret = process.env.CLASSLINK_OAUTH2_CLIENT_SECRET;
+    const tokenURL = process.env.CLASSLINK_OAUTH2_TOKEN_URL;
+    if (!serverURL || !clientID || !clientSecret) return null;
+    return { type: 'oauth2', serverURL, clientID, clientSecret, tokenURL };
 }
 
 function getBearerConfig(): BearerConfig | null {
-  const serverURL = process.env.CLASSLINK_BEARER_SERVER_URL;
-  const bearerToken = process.env.CLASSLINK_BEARER_TOKEN;
-  if (!serverURL || !bearerToken) return null;
-  return { type: "bearer", serverURL, bearerToken };
+    const serverURL = process.env.CLASSLINK_BEARER_SERVER_URL;
+    const bearerToken = process.env.CLASSLINK_BEARER_TOKEN;
+    if (!serverURL || !bearerToken) return null;
+    return { type: 'bearer', serverURL, bearerToken };
 }
 
 function createClient(config: AuthConfig): InstanceType<typeof ClassLink> {
-  switch (config.type) {
-    case "oauth1":
-      return new ClassLink({
-        serverURL: config.serverURL,
-        security: {
-          clientID: config.clientID,
-          clientSecret: config.clientSecret,
-          authType: "oauth1",
-        },
-      });
-    case "oauth2":
-      return new ClassLink({
-        serverURL: config.serverURL,
-        security: {
-          clientID: config.clientID,
-          clientSecret: config.clientSecret,
-          tokenURL: config.tokenURL,
-          authType: "oauth2",
-        },
-      });
-    case "bearer":
-      return new ClassLink({
-        serverURL: config.serverURL,
-        security: { bearerToken: config.bearerToken, authType: "bearer" },
-      });
-  }
+    switch (config.type) {
+        case 'oauth1':
+            return new ClassLink({
+                serverURL: config.serverURL,
+                security: {
+                    clientID: config.clientID,
+                    clientSecret: config.clientSecret,
+                    authType: 'oauth1',
+                },
+            });
+        case 'oauth2':
+            return new ClassLink({
+                serverURL: config.serverURL,
+                security: {
+                    clientID: config.clientID,
+                    clientSecret: config.clientSecret,
+                    tokenURL: config.tokenURL,
+                    authType: 'oauth2',
+                },
+            });
+        case 'bearer':
+            return new ClassLink({
+                serverURL: config.serverURL,
+                security: { bearerToken: config.bearerToken, authType: 'bearer' },
+            });
+    }
 }
 
 // ============================================================================
@@ -177,954 +165,783 @@ function createClient(config: AuthConfig): InstanceType<typeof ClassLink> {
 // ============================================================================
 
 function createAPITestSuite(config: AuthConfig) {
-  const authType = `CLASSLINK_${config.type.toUpperCase()}`;
-  let client: InstanceType<typeof ClassLink>;
-  let schoolId: string | undefined;
-  let classId: string | undefined;
-  let userId: string | undefined;
-  let studentId: string | undefined;
-  let teacherId: string | undefined;
-  let termId: string | undefined;
-  let courseId: string | undefined;
-
-  describe(`${authType} API Operations`, () => {
-    beforeAll(() => {
-      client = createClient(config);
-    });
-
-    describe("Core Rostering", () => {
-      it("academicSessions", async () => {
-        try {
-          for await (const page of await client.academicSessionsManagement.getAllAcademicSessions(
-            { limit: 2 },
-          )) {
-            expect(Array.isArray(page.result.academicSessions || [])).toBe(
-              true,
-            );
-            recordResult(authType, "academicSessions", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "academicSessions",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("orgs", async () => {
-        try {
-          for await (const page of await client.organizationsManagement.getAllOrgs(
-            {
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.orgs || [])).toBe(true);
-            recordResult(authType, "orgs", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(authType, "orgs", "failed", "Response validation");
-          throw e;
-        }
-      });
-
-      it("schools", async () => {
-        try {
-          for await (const page of await client.schoolsManagement.getAllSchools(
-            {
-              limit: 2,
-            },
-          )) {
-            const items = page.result.orgs || [];
-            expect(Array.isArray(items)).toBe(true);
-            if (items[0]) schoolId = items[0].sourcedId;
-            recordResult(authType, "schools", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(authType, "schools", "failed", "Response validation");
-          throw e;
-        }
-      });
-
-      it("courses", async () => {
-        try {
-          for await (const page of await client.coursesManagement.getAllCourses(
-            {
-              limit: 2,
-            },
-          )) {
-            const items = page.result.courses || [];
-            expect(Array.isArray(items)).toBe(true);
-            if (items[0]) courseId = items[0].sourcedId;
-            recordResult(authType, "courses", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(authType, "courses", "failed", "Response validation");
-          throw e;
-        }
-      });
-
-      it("classes", async () => {
-        try {
-          for await (const page of await client.classesManagement.getAllClasses(
-            {
-              limit: 2,
-            },
-          )) {
-            const items = page.result.classes || [];
-            expect(Array.isArray(items)).toBe(true);
-            if (items[0]) classId = items[0].sourcedId;
-            recordResult(authType, "classes", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(authType, "classes", "failed", "Response validation");
-          throw e;
-        }
-      });
-
-      it("users", async () => {
-        try {
-          for await (const page of await client.usersManagement.getAllUsers({
-            limit: 2,
-          })) {
-            const items = page.result.users || [];
-            expect(Array.isArray(items)).toBe(true);
-            if (items[0]) userId = items[0].sourcedId;
-            recordResult(authType, "users", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(authType, "users", "failed", "Response validation");
-          throw e;
-        }
-      });
-
-      it("students", async () => {
-        try {
-          for await (const page of await client.studentsManagement.getAllStudents(
-            {
-              limit: 2,
-            },
-          )) {
-            const items = page.result.users || [];
-            expect(Array.isArray(items)).toBe(true);
-            if (items[0]) studentId = items[0].sourcedId;
-            recordResult(authType, "students", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(authType, "students", "failed", "Response validation");
-          throw e;
-        }
-      });
-
-      it("teachers", async () => {
-        try {
-          for await (const page of await client.teachersManagement.getAllTeachers(
-            {
-              limit: 2,
-            },
-          )) {
-            const items = page.result.users || [];
-            expect(Array.isArray(items)).toBe(true);
-            if (items[0]) teacherId = items[0].sourcedId;
-            recordResult(authType, "teachers", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(authType, "teachers", "failed", "Response validation");
-          throw e;
-        }
-      });
-
-      it("enrollments", async () => {
-        try {
-          for await (const page of await client.enrollmentsManagement.getAllEnrollments(
-            {
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.enrollments || [])).toBe(true);
-            recordResult(authType, "enrollments", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "enrollments",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("terms", async () => {
-        try {
-          for await (const page of await client.termsManagement.getAllTerms({
-            limit: 2,
-          })) {
-            const items = page.result.academicSessions || [];
-            expect(Array.isArray(items)).toBe(true);
-            if (items[0]) termId = items[0].sourcedId;
-            recordResult(authType, "terms", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(authType, "terms", "failed", "Response validation");
-          throw e;
-        }
-      });
-
-      it("gradingPeriods", async () => {
-        try {
-          for await (const page of await client.gradingPeriodsManagement.getAllGradingPeriods(
-            { limit: 2 },
-          )) {
-            expect(Array.isArray(page.result.academicSessions || [])).toBe(
-              true,
-            );
-            recordResult(authType, "gradingPeriods", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "gradingPeriods",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-    });
-
-    describe("Nested Queries", () => {
-      it("schools/{id}/classes", async () => {
-        if (!schoolId) {
-          recordResult(
-            authType,
-            "schools/{id}/classes",
-            "failed",
-            "No school ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.classesManagement.getClassesForSchool(
-            {
-              schoolSourcedId: schoolId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.classes || [])).toBe(true);
-            recordResult(authType, "schools/{id}/classes", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "schools/{id}/classes",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("schools/{id}/students", async () => {
-        if (!schoolId) {
-          recordResult(
-            authType,
-            "schools/{id}/students",
-            "failed",
-            "No school ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.schoolsManagement.getStudentsForSchool(
-            {
-              schoolSourcedId: schoolId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.users || [])).toBe(true);
-            recordResult(authType, "schools/{id}/students", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "schools/{id}/students",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("schools/{id}/teachers", async () => {
-        if (!schoolId) {
-          recordResult(
-            authType,
-            "schools/{id}/teachers",
-            "failed",
-            "No school ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.schoolsManagement.getTeachersForSchool(
-            {
-              schoolSourcedId: schoolId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.users || [])).toBe(true);
-            recordResult(authType, "schools/{id}/teachers", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "schools/{id}/teachers",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("schools/{id}/courses", async () => {
-        if (!schoolId) {
-          recordResult(
-            authType,
-            "schools/{id}/courses",
-            "failed",
-            "No school ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.schoolsManagement.getCoursesForSchool(
-            {
-              schoolSourcedId: schoolId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.courses || [])).toBe(true);
-            recordResult(authType, "schools/{id}/courses", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "schools/{id}/courses",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("schools/{id}/terms", async () => {
-        if (!schoolId) {
-          recordResult(
-            authType,
-            "schools/{id}/terms",
-            "failed",
-            "No school ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.schoolsManagement.getTermsForSchool(
-            {
-              schoolSourcedId: schoolId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.academicSessions || [])).toBe(
-              true,
-            );
-            recordResult(authType, "schools/{id}/terms", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "schools/{id}/terms",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("classes/{id}/students", async () => {
-        if (!classId) {
-          recordResult(
-            authType,
-            "classes/{id}/students",
-            "failed",
-            "No class ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.classesManagement.getStudentsForClass(
-            {
-              classSourcedId: classId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.users || [])).toBe(true);
-            recordResult(authType, "classes/{id}/students", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "classes/{id}/students",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("classes/{id}/teachers", async () => {
-        if (!classId) {
-          recordResult(
-            authType,
-            "classes/{id}/teachers",
-            "failed",
-            "No class ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.classesManagement.getTeachersForClass(
-            {
-              classSourcedId: classId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.users || [])).toBe(true);
-            recordResult(authType, "classes/{id}/teachers", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "classes/{id}/teachers",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("users/{id}/classes", async () => {
-        if (!userId) {
-          recordResult(authType, "users/{id}/classes", "failed", "No user ID");
-          return;
-        }
-        try {
-          for await (const page of await client.classesManagement.getClassesForUser(
-            {
-              userSourcedId: userId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.classes || [])).toBe(true);
-            recordResult(authType, "users/{id}/classes", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "users/{id}/classes",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("teachers/{id}/classes", async () => {
-        if (!teacherId) {
-          recordResult(
-            authType,
-            "teachers/{id}/classes",
-            "failed",
-            "No teacher ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.classesManagement.getClassesForTeacher(
-            {
-              teacherSourcedId: teacherId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.classes || [])).toBe(true);
-            recordResult(authType, "teachers/{id}/classes", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "teachers/{id}/classes",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("students/{id}/classes", async () => {
-        if (!studentId) {
-          recordResult(
-            authType,
-            "students/{id}/classes",
-            "failed",
-            "No student ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.classesManagement.getClassesForStudent(
-            {
-              studentSourcedId: studentId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.classes || [])).toBe(true);
-            recordResult(authType, "students/{id}/classes", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "students/{id}/classes",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("terms/{id}/classes", async () => {
-        if (!termId) {
-          recordResult(authType, "terms/{id}/classes", "failed", "No term ID");
-          return;
-        }
-        try {
-          for await (const page of await client.classesManagement.getClassesForTerm(
-            {
-              termSourcedId: termId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.classes || [])).toBe(true);
-            recordResult(authType, "terms/{id}/classes", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "terms/{id}/classes",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("courses/{id}/classes", async () => {
-        if (!courseId) {
-          recordResult(
-            authType,
-            "courses/{id}/classes",
-            "failed",
-            "No course ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.coursesManagement.getClassesForCourse(
-            {
-              courseSourcedId: courseId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.classes || [])).toBe(true);
-            recordResult(authType, "courses/{id}/classes", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "courses/{id}/classes",
-            "failed",
-            "Response validation",
-          );
-          throw e;
-        }
-      });
-
-      it("terms/{id}/gradingPeriods", async () => {
-        if (!termId) {
-          recordResult(
-            authType,
-            "terms/{id}/gradingPeriods",
-            "failed",
-            "No term ID",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.termsManagement.getGradingPeriodsForTerm(
-            {
-              termSourcedId: termId,
-              limit: 2,
-            },
-          )) {
-            expect(Array.isArray(page.result.academicSessions || [])).toBe(
-              true,
-            );
-            recordResult(authType, "terms/{id}/gradingPeriods", "passed");
-            break;
-          }
-        } catch (e) {
-          recordResult(
-            authType,
-            "terms/{id}/gradingPeriods",
-            "failed",
-            "Response validation",
-          );
-        }
-      });
-
-      it("GET /terms/{id}/classes", async () => {
-        if (!termId) {
-          recordResult(
-            authType,
-            "GET /terms/{id}/classes",
-            "failed",
-            "No term ID available",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.classesManagement.getClassesForTerm(
-            { termSourcedId: termId, limit: 2 },
-          )) {
-            expect(Array.isArray(page.result.classes || [])).toBe(true);
-            recordResult(authType, "GET /terms/{id}/classes", "passed");
-            break;
-          }
-        } catch (e: any) {
-          recordResult(
-            authType,
-            "GET /terms/{id}/classes",
-            "failed",
-            e.message || "Unknown error",
-          );
-          throw e;
-        }
-      });
-
-      it("GET /courses/{id}/classes", async () => {
-        if (!courseId) {
-          recordResult(
-            authType,
-            "GET /courses/{id}/classes",
-            "failed",
-            "No course ID available",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.coursesManagement.getClassesForCourse(
-            { courseSourcedId: courseId, limit: 2 },
-          )) {
-            expect(Array.isArray(page.result.classes || [])).toBe(true);
-            recordResult(authType, "GET /courses/{id}/classes", "passed");
-            break;
-          }
-        } catch (e: any) {
-          recordResult(
-            authType,
-            "GET /courses/{id}/classes",
-            "failed",
-            e.message || "Unknown error",
-          );
-          throw e;
-        }
-      });
-
-      it("GET /terms/{id}/gradingPeriods", async () => {
-        if (!termId) {
-          recordResult(
-            authType,
-            "GET /terms/{id}/gradingPeriods",
-            "failed",
-            "No term ID available",
-          );
-          return;
-        }
-        try {
-          for await (const page of await client.termsManagement.getGradingPeriodsForTerm(
-            { termSourcedId: termId, limit: 2 },
-          )) {
-            expect(Array.isArray(page.result.academicSessions || [])).toBe(
-              true,
-            );
-            recordResult(authType, "GET /terms/{id}/gradingPeriods", "passed");
-            break;
-          }
-        } catch (e: any) {
-          recordResult(
-            authType,
-            "GET /terms/{id}/gradingPeriods",
-            "failed",
-            e.message || "Unknown error",
-          );
-          throw e;
-        }
-      });
+    const authType = `CLASSLINK_${config.type.toUpperCase()}`;
+    let client: InstanceType<typeof ClassLink>;
+    let schoolId: string | undefined;
+    let classId: string | undefined;
+    let userId: string | undefined;
+    let studentId: string | undefined;
+    let teacherId: string | undefined;
+    let termId: string | undefined;
+    let courseId: string | undefined;
+
+    describe(`${authType} API Operations`, () => {
+        beforeAll(() => {
+            client = createClient(config);
+        });
+
+        describe('Core Rostering', () => {
+            it('academicSessions', async () => {
+                try {
+                    for await (const page of await client.academicSessionsManagement.getAllAcademicSessions(
+                        { limit: 2 }
+                    )) {
+                        expect(Array.isArray(page.result.academicSessions || [])).toBe(true);
+                        recordResult(authType, 'academicSessions', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'academicSessions', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('orgs', async () => {
+                try {
+                    for await (const page of await client.organizationsManagement.getAllOrgs({
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.orgs || [])).toBe(true);
+                        recordResult(authType, 'orgs', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'orgs', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('schools', async () => {
+                try {
+                    for await (const page of await client.schoolsManagement.getAllSchools({
+                        limit: 2,
+                    })) {
+                        const items = page.result.orgs || [];
+                        expect(Array.isArray(items)).toBe(true);
+                        if (items[0]) schoolId = items[0].sourcedId;
+                        recordResult(authType, 'schools', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'schools', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('courses', async () => {
+                try {
+                    for await (const page of await client.coursesManagement.getAllCourses({
+                        limit: 2,
+                    })) {
+                        const items = page.result.courses || [];
+                        expect(Array.isArray(items)).toBe(true);
+                        if (items[0]) courseId = items[0].sourcedId;
+                        recordResult(authType, 'courses', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'courses', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('classes', async () => {
+                try {
+                    for await (const page of await client.classesManagement.getAllClasses({
+                        limit: 2,
+                    })) {
+                        const items = page.result.classes || [];
+                        expect(Array.isArray(items)).toBe(true);
+                        if (items[0]) classId = items[0].sourcedId;
+                        recordResult(authType, 'classes', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'classes', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('users', async () => {
+                try {
+                    for await (const page of await client.usersManagement.getAllUsers({
+                        limit: 2,
+                    })) {
+                        const items = page.result.users || [];
+                        expect(Array.isArray(items)).toBe(true);
+                        if (items[0]) userId = items[0].sourcedId;
+                        recordResult(authType, 'users', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'users', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('students', async () => {
+                try {
+                    for await (const page of await client.studentsManagement.getAllStudents({
+                        limit: 2,
+                    })) {
+                        const items = page.result.users || [];
+                        expect(Array.isArray(items)).toBe(true);
+                        if (items[0]) studentId = items[0].sourcedId;
+                        recordResult(authType, 'students', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'students', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('teachers', async () => {
+                try {
+                    for await (const page of await client.teachersManagement.getAllTeachers({
+                        limit: 2,
+                    })) {
+                        const items = page.result.users || [];
+                        expect(Array.isArray(items)).toBe(true);
+                        if (items[0]) teacherId = items[0].sourcedId;
+                        recordResult(authType, 'teachers', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'teachers', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('enrollments', async () => {
+                try {
+                    for await (const page of await client.enrollmentsManagement.getAllEnrollments({
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.enrollments || [])).toBe(true);
+                        recordResult(authType, 'enrollments', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'enrollments', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('terms', async () => {
+                try {
+                    for await (const page of await client.termsManagement.getAllTerms({
+                        limit: 2,
+                    })) {
+                        const items = page.result.academicSessions || [];
+                        expect(Array.isArray(items)).toBe(true);
+                        if (items[0]) termId = items[0].sourcedId;
+                        recordResult(authType, 'terms', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'terms', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('gradingPeriods', async () => {
+                try {
+                    for await (const page of await client.gradingPeriodsManagement.getAllGradingPeriods(
+                        { limit: 2 }
+                    )) {
+                        expect(Array.isArray(page.result.academicSessions || [])).toBe(true);
+                        recordResult(authType, 'gradingPeriods', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'gradingPeriods', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+        });
+
+        describe('Nested Queries', () => {
+            it('schools/{id}/classes', async () => {
+                if (!schoolId) {
+                    recordResult(authType, 'schools/{id}/classes', 'failed', 'No school ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.classesManagement.getClassesForSchool({
+                        schoolSourcedId: schoolId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.classes || [])).toBe(true);
+                        recordResult(authType, 'schools/{id}/classes', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'schools/{id}/classes', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('schools/{id}/students', async () => {
+                if (!schoolId) {
+                    recordResult(authType, 'schools/{id}/students', 'failed', 'No school ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.schoolsManagement.getStudentsForSchool({
+                        schoolSourcedId: schoolId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.users || [])).toBe(true);
+                        recordResult(authType, 'schools/{id}/students', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(
+                        authType,
+                        'schools/{id}/students',
+                        'failed',
+                        'Response validation'
+                    );
+                    throw e;
+                }
+            });
+
+            it('schools/{id}/teachers', async () => {
+                if (!schoolId) {
+                    recordResult(authType, 'schools/{id}/teachers', 'failed', 'No school ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.schoolsManagement.getTeachersForSchool({
+                        schoolSourcedId: schoolId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.users || [])).toBe(true);
+                        recordResult(authType, 'schools/{id}/teachers', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(
+                        authType,
+                        'schools/{id}/teachers',
+                        'failed',
+                        'Response validation'
+                    );
+                    throw e;
+                }
+            });
+
+            it('schools/{id}/courses', async () => {
+                if (!schoolId) {
+                    recordResult(authType, 'schools/{id}/courses', 'failed', 'No school ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.schoolsManagement.getCoursesForSchool({
+                        schoolSourcedId: schoolId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.courses || [])).toBe(true);
+                        recordResult(authType, 'schools/{id}/courses', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'schools/{id}/courses', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('schools/{id}/terms', async () => {
+                if (!schoolId) {
+                    recordResult(authType, 'schools/{id}/terms', 'failed', 'No school ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.schoolsManagement.getTermsForSchool({
+                        schoolSourcedId: schoolId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.academicSessions || [])).toBe(true);
+                        recordResult(authType, 'schools/{id}/terms', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'schools/{id}/terms', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('classes/{id}/students', async () => {
+                if (!classId) {
+                    recordResult(authType, 'classes/{id}/students', 'failed', 'No class ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.classesManagement.getStudentsForClass({
+                        classSourcedId: classId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.users || [])).toBe(true);
+                        recordResult(authType, 'classes/{id}/students', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(
+                        authType,
+                        'classes/{id}/students',
+                        'failed',
+                        'Response validation'
+                    );
+                    throw e;
+                }
+            });
+
+            it('classes/{id}/teachers', async () => {
+                if (!classId) {
+                    recordResult(authType, 'classes/{id}/teachers', 'failed', 'No class ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.classesManagement.getTeachersForClass({
+                        classSourcedId: classId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.users || [])).toBe(true);
+                        recordResult(authType, 'classes/{id}/teachers', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(
+                        authType,
+                        'classes/{id}/teachers',
+                        'failed',
+                        'Response validation'
+                    );
+                    throw e;
+                }
+            });
+
+            it('users/{id}/classes', async () => {
+                if (!userId) {
+                    recordResult(authType, 'users/{id}/classes', 'failed', 'No user ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.classesManagement.getClassesForUser({
+                        userSourcedId: userId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.classes || [])).toBe(true);
+                        recordResult(authType, 'users/{id}/classes', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'users/{id}/classes', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('teachers/{id}/classes', async () => {
+                if (!teacherId) {
+                    recordResult(authType, 'teachers/{id}/classes', 'failed', 'No teacher ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.classesManagement.getClassesForTeacher({
+                        teacherSourcedId: teacherId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.classes || [])).toBe(true);
+                        recordResult(authType, 'teachers/{id}/classes', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(
+                        authType,
+                        'teachers/{id}/classes',
+                        'failed',
+                        'Response validation'
+                    );
+                    throw e;
+                }
+            });
+
+            it('students/{id}/classes', async () => {
+                if (!studentId) {
+                    recordResult(authType, 'students/{id}/classes', 'failed', 'No student ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.classesManagement.getClassesForStudent({
+                        studentSourcedId: studentId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.classes || [])).toBe(true);
+                        recordResult(authType, 'students/{id}/classes', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(
+                        authType,
+                        'students/{id}/classes',
+                        'failed',
+                        'Response validation'
+                    );
+                    throw e;
+                }
+            });
+
+            it('terms/{id}/classes', async () => {
+                if (!termId) {
+                    recordResult(authType, 'terms/{id}/classes', 'failed', 'No term ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.classesManagement.getClassesForTerm({
+                        termSourcedId: termId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.classes || [])).toBe(true);
+                        recordResult(authType, 'terms/{id}/classes', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'terms/{id}/classes', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('courses/{id}/classes', async () => {
+                if (!courseId) {
+                    recordResult(authType, 'courses/{id}/classes', 'failed', 'No course ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.coursesManagement.getClassesForCourse({
+                        courseSourcedId: courseId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.classes || [])).toBe(true);
+                        recordResult(authType, 'courses/{id}/classes', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(authType, 'courses/{id}/classes', 'failed', 'Response validation');
+                    throw e;
+                }
+            });
+
+            it('terms/{id}/gradingPeriods', async () => {
+                if (!termId) {
+                    recordResult(authType, 'terms/{id}/gradingPeriods', 'failed', 'No term ID');
+                    return;
+                }
+                try {
+                    for await (const page of await client.termsManagement.getGradingPeriodsForTerm({
+                        termSourcedId: termId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.academicSessions || [])).toBe(true);
+                        recordResult(authType, 'terms/{id}/gradingPeriods', 'passed');
+                        break;
+                    }
+                } catch (e) {
+                    recordResult(
+                        authType,
+                        'terms/{id}/gradingPeriods',
+                        'failed',
+                        'Response validation'
+                    );
+                }
+            });
+
+            it('GET /terms/{id}/classes', async () => {
+                if (!termId) {
+                    recordResult(
+                        authType,
+                        'GET /terms/{id}/classes',
+                        'failed',
+                        'No term ID available'
+                    );
+                    return;
+                }
+                try {
+                    for await (const page of await client.classesManagement.getClassesForTerm({
+                        termSourcedId: termId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.classes || [])).toBe(true);
+                        recordResult(authType, 'GET /terms/{id}/classes', 'passed');
+                        break;
+                    }
+                } catch (e: any) {
+                    recordResult(
+                        authType,
+                        'GET /terms/{id}/classes',
+                        'failed',
+                        e.message || 'Unknown error'
+                    );
+                    throw e;
+                }
+            });
+
+            it('GET /courses/{id}/classes', async () => {
+                if (!courseId) {
+                    recordResult(
+                        authType,
+                        'GET /courses/{id}/classes',
+                        'failed',
+                        'No course ID available'
+                    );
+                    return;
+                }
+                try {
+                    for await (const page of await client.coursesManagement.getClassesForCourse({
+                        courseSourcedId: courseId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.classes || [])).toBe(true);
+                        recordResult(authType, 'GET /courses/{id}/classes', 'passed');
+                        break;
+                    }
+                } catch (e: any) {
+                    recordResult(
+                        authType,
+                        'GET /courses/{id}/classes',
+                        'failed',
+                        e.message || 'Unknown error'
+                    );
+                    throw e;
+                }
+            });
+
+            it('GET /terms/{id}/gradingPeriods', async () => {
+                if (!termId) {
+                    recordResult(
+                        authType,
+                        'GET /terms/{id}/gradingPeriods',
+                        'failed',
+                        'No term ID available'
+                    );
+                    return;
+                }
+                try {
+                    for await (const page of await client.termsManagement.getGradingPeriodsForTerm({
+                        termSourcedId: termId,
+                        limit: 2,
+                    })) {
+                        expect(Array.isArray(page.result.academicSessions || [])).toBe(true);
+                        recordResult(authType, 'GET /terms/{id}/gradingPeriods', 'passed');
+                        break;
+                    }
+                } catch (e: any) {
+                    recordResult(
+                        authType,
+                        'GET /terms/{id}/gradingPeriods',
+                        'failed',
+                        e.message || 'Unknown error'
+                    );
+                    throw e;
+                }
+            });
+        });
+
+        describe('Pagination X-Total-Count', () => {
+            it('should include totalCount from X-Total-Count header', async () => {
+                try {
+                    for await (const page of await client.usersManagement.getAllUsers({
+                        limit: 1,
+                    })) {
+                        // totalCount is on the page object itself (from PaginationMeta), not on page.result
+                        // It may be undefined if the server doesn't return the X-Total-Count header
+                        if (page.totalCount !== undefined) {
+                            expect(typeof page.totalCount).toBe('number');
+                            expect(page.totalCount).toBeGreaterThanOrEqual(0);
+                            console.log(
+                                `Total users from X-Total-Count header: ${page.totalCount}`
+                            );
+                            recordResult(authType, 'X-Total-Count header', 'passed');
+                        } else {
+                            console.log('Server did not return X-Total-Count header');
+                            recordResult(
+                                authType,
+                                'X-Total-Count header',
+                                'passed',
+                                'Header not returned by server'
+                            );
+                        }
+                        break;
+                    }
+                } catch (e: any) {
+                    recordResult(
+                        authType,
+                        'X-Total-Count header',
+                        'failed',
+                        e.message || 'Unknown error'
+                    );
+                    throw e;
+                }
+            });
+        });
     });
-  });
 }
 
 // ============================================================================
 // ClassLink Client Type Checking Tests (no API calls)
 // ============================================================================
 
-describe("ClassLink Client - Type Checking", () => {
-  const mockClient = new ClassLink({
-    serverURL: "https://example.classlink.com",
-    security: {
-      authType: "oauth2",
-      clientID: "test-client-id",
-      clientSecret: "test-client-secret",
-      tokenURL: "https://example.classlink.com/oauth/token",
-    },
-  });
-
-  const anyClient = mockClient as any;
-
-  describe("Instantiation", () => {
-    it("should be instantiable as a class", () => {
-      expect(mockClient).toBeInstanceOf(OneRoster);
-      recordResult("TYPE_CHECK", "instantiation", "passed");
-    });
-  });
-
-  describe("Available Read Methods", () => {
-    it("usersManagement.getAllUsers", () => {
-      expect(typeof mockClient.usersManagement.getAllUsers).toBe("function");
-      recordResult("TYPE_CHECK", "usersManagement.getAllUsers", "passed");
-    });
-
-    it("schoolsManagement.getAllSchools", () => {
-      expect(typeof mockClient.schoolsManagement.getAllSchools).toBe(
-        "function",
-      );
-      recordResult("TYPE_CHECK", "schoolsManagement.getAllSchools", "passed");
-    });
-
-    it("classesManagement.getAllClasses", () => {
-      expect(typeof mockClient.classesManagement.getAllClasses).toBe(
-        "function",
-      );
-      recordResult("TYPE_CHECK", "classesManagement.getAllClasses", "passed");
-    });
-
-    it("enrollmentsManagement.getAllEnrollments", () => {
-      expect(typeof mockClient.enrollmentsManagement.getAllEnrollments).toBe(
-        "function",
-      );
-      recordResult(
-        "TYPE_CHECK",
-        "enrollmentsManagement.getAllEnrollments",
-        "passed",
-      );
-    });
-
-    it("coursesManagement.getAllCourses", () => {
-      expect(typeof mockClient.coursesManagement.getAllCourses).toBe(
-        "function",
-      );
-      recordResult("TYPE_CHECK", "coursesManagement.getAllCourses", "passed");
-    });
-  });
-
-  describe("Restricted Write Methods (exist at runtime, hidden by TypeScript)", () => {
-    it("usersManagement.createUser (restricted)", () => {
-      expect(typeof anyClient.usersManagement.createUser).toBe("function");
-      recordResult(
-        "TYPE_CHECK",
-        "usersManagement.createUser (restricted)",
-        "passed",
-      );
-    });
-
-    it("usersManagement.updateUser (restricted)", () => {
-      expect(typeof anyClient.usersManagement.updateUser).toBe("function");
-      recordResult(
-        "TYPE_CHECK",
-        "usersManagement.updateUser (restricted)",
-        "passed",
-      );
-    });
-
-    it("usersManagement.deleteUser (restricted)", () => {
-      expect(typeof anyClient.usersManagement.deleteUser).toBe("function");
-      recordResult(
-        "TYPE_CHECK",
-        "usersManagement.deleteUser (restricted)",
-        "passed",
-      );
-    });
-
-    it("classesManagement.createClass (restricted)", () => {
-      expect(typeof anyClient.classesManagement.createClass).toBe("function");
-      recordResult(
-        "TYPE_CHECK",
-        "classesManagement.createClass (restricted)",
-        "passed",
-      );
+describe('ClassLink Client - Type Checking', () => {
+    const mockClient = new ClassLink({
+        serverURL: 'https://example.classlink.com',
+        security: {
+            authType: 'oauth2',
+            clientID: 'test-client-id',
+            clientSecret: 'test-client-secret',
+            tokenURL: 'https://example.classlink.com/oauth/token',
+        },
     });
 
-    it("enrollmentsManagement.createEnrollment (restricted)", () => {
-      expect(typeof anyClient.enrollmentsManagement.createEnrollment).toBe(
-        "function",
-      );
-      recordResult(
-        "TYPE_CHECK",
-        "enrollmentsManagement.createEnrollment (restricted)",
-        "passed",
-      );
-    });
+    const anyClient = mockClient as any;
 
-    it("schoolsManagement.createSchool (restricted)", () => {
-      expect(typeof anyClient.schoolsManagement.createSchool).toBe("function");
-      recordResult(
-        "TYPE_CHECK",
-        "schoolsManagement.createSchool (restricted)",
-        "passed",
-      );
+    describe('Instantiation', () => {
+        it('should be instantiable as a class', () => {
+            expect(mockClient).toBeInstanceOf(OneRoster);
+            recordResult('TYPE_CHECK', 'instantiation', 'passed');
+        });
     });
 
-    it("organizationsManagement.createOrg (restricted)", () => {
-      expect(typeof anyClient.organizationsManagement.createOrg).toBe(
-        "function",
-      );
-      recordResult(
-        "TYPE_CHECK",
-        "organizationsManagement.createOrg (restricted)",
-        "passed",
-      );
-    });
-  });
-
-  describe("Unsupported Management Modules (exist at runtime, not in ClassLink profile)", () => {
-    it("demographicsManagement (not in profile)", () => {
-      expect(anyClient.demographicsManagement).toBeDefined();
-      recordResult(
-        "TYPE_CHECK",
-        "demographicsManagement (not in profile)",
-        "passed",
-      );
+    describe('Available Read Methods', () => {
+        it('usersManagement.getAllUsers', () => {
+            expect(typeof mockClient.usersManagement.getAllUsers).toBe('function');
+            recordResult('TYPE_CHECK', 'usersManagement.getAllUsers', 'passed');
+        });
+
+        it('schoolsManagement.getAllSchools', () => {
+            expect(typeof mockClient.schoolsManagement.getAllSchools).toBe('function');
+            recordResult('TYPE_CHECK', 'schoolsManagement.getAllSchools', 'passed');
+        });
+
+        it('classesManagement.getAllClasses', () => {
+            expect(typeof mockClient.classesManagement.getAllClasses).toBe('function');
+            recordResult('TYPE_CHECK', 'classesManagement.getAllClasses', 'passed');
+        });
+
+        it('enrollmentsManagement.getAllEnrollments', () => {
+            expect(typeof mockClient.enrollmentsManagement.getAllEnrollments).toBe('function');
+            recordResult('TYPE_CHECK', 'enrollmentsManagement.getAllEnrollments', 'passed');
+        });
+
+        it('coursesManagement.getAllCourses', () => {
+            expect(typeof mockClient.coursesManagement.getAllCourses).toBe('function');
+            recordResult('TYPE_CHECK', 'coursesManagement.getAllCourses', 'passed');
+        });
     });
 
-    it("lineItemsManagement (not in profile)", () => {
-      expect(anyClient.lineItemsManagement).toBeDefined();
-      recordResult(
-        "TYPE_CHECK",
-        "lineItemsManagement (not in profile)",
-        "passed",
-      );
-    });
+    describe('Restricted Write Methods (exist at runtime, hidden by TypeScript)', () => {
+        it('usersManagement.createUser (restricted)', () => {
+            expect(typeof anyClient.usersManagement.createUser).toBe('function');
+            recordResult('TYPE_CHECK', 'usersManagement.createUser (restricted)', 'passed');
+        });
+
+        it('usersManagement.updateUser (restricted)', () => {
+            expect(typeof anyClient.usersManagement.updateUser).toBe('function');
+            recordResult('TYPE_CHECK', 'usersManagement.updateUser (restricted)', 'passed');
+        });
+
+        it('usersManagement.deleteUser (restricted)', () => {
+            expect(typeof anyClient.usersManagement.deleteUser).toBe('function');
+            recordResult('TYPE_CHECK', 'usersManagement.deleteUser (restricted)', 'passed');
+        });
+
+        it('classesManagement.createClass (restricted)', () => {
+            expect(typeof anyClient.classesManagement.createClass).toBe('function');
+            recordResult('TYPE_CHECK', 'classesManagement.createClass (restricted)', 'passed');
+        });
+
+        it('enrollmentsManagement.createEnrollment (restricted)', () => {
+            expect(typeof anyClient.enrollmentsManagement.createEnrollment).toBe('function');
+            recordResult(
+                'TYPE_CHECK',
+                'enrollmentsManagement.createEnrollment (restricted)',
+                'passed'
+            );
+        });
 
-    it("resultsManagement (not in profile)", () => {
-      expect(anyClient.resultsManagement).toBeDefined();
-      recordResult(
-        "TYPE_CHECK",
-        "resultsManagement (not in profile)",
-        "passed",
-      );
-    });
+        it('schoolsManagement.createSchool (restricted)', () => {
+            expect(typeof anyClient.schoolsManagement.createSchool).toBe('function');
+            recordResult('TYPE_CHECK', 'schoolsManagement.createSchool (restricted)', 'passed');
+        });
 
-    it("categoriesManagement (not in profile)", () => {
-      expect(anyClient.categoriesManagement).toBeDefined();
-      recordResult(
-        "TYPE_CHECK",
-        "categoriesManagement (not in profile)",
-        "passed",
-      );
+        it('organizationsManagement.createOrg (restricted)', () => {
+            expect(typeof anyClient.organizationsManagement.createOrg).toBe('function');
+            recordResult('TYPE_CHECK', 'organizationsManagement.createOrg (restricted)', 'passed');
+        });
     });
 
-    it("resourcesManagement (not in profile)", () => {
-      expect(anyClient.resourcesManagement).toBeDefined();
-      recordResult(
-        "TYPE_CHECK",
-        "resourcesManagement (not in profile)",
-        "passed",
-      );
+    describe('Unsupported Management Modules (exist at runtime, not in ClassLink profile)', () => {
+        it('demographicsManagement (not in profile)', () => {
+            expect(anyClient.demographicsManagement).toBeDefined();
+            recordResult('TYPE_CHECK', 'demographicsManagement (not in profile)', 'passed');
+        });
+
+        it('lineItemsManagement (not in profile)', () => {
+            expect(anyClient.lineItemsManagement).toBeDefined();
+            recordResult('TYPE_CHECK', 'lineItemsManagement (not in profile)', 'passed');
+        });
+
+        it('resultsManagement (not in profile)', () => {
+            expect(anyClient.resultsManagement).toBeDefined();
+            recordResult('TYPE_CHECK', 'resultsManagement (not in profile)', 'passed');
+        });
+
+        it('categoriesManagement (not in profile)', () => {
+            expect(anyClient.categoriesManagement).toBeDefined();
+            recordResult('TYPE_CHECK', 'categoriesManagement (not in profile)', 'passed');
+        });
+
+        it('resourcesManagement (not in profile)', () => {
+            expect(anyClient.resourcesManagement).toBeDefined();
+            recordResult('TYPE_CHECK', 'resourcesManagement (not in profile)', 'passed');
+        });
     });
-  });
 });
 
 // ============================================================================
 // Main Test Suite - API Calls (conditional based on env vars)
 // ============================================================================
 
-describe("ClassLink Client - API Calls", () => {
-  const oauth1Config = getOAuth1Config();
-  const oauth2Config = getOAuth2Config();
-  const bearerConfig = getBearerConfig();
-
-  beforeAll(() => {
-    console.log("\n" + "=".repeat(60));
-    console.log("ClassLink Client Test Suite");
-    console.log("=".repeat(60));
-    if (oauth1Config) console.log(`\n✓ OAuth1: ${oauth1Config.serverURL}`);
-    if (oauth2Config) console.log(`✓ OAuth2: ${oauth2Config.serverURL}`);
-    if (bearerConfig) console.log(`✓ Bearer: ${bearerConfig.serverURL}`);
-  });
-
-  if (oauth1Config) createAPITestSuite(oauth1Config);
-  if (oauth2Config) createAPITestSuite(oauth2Config);
-  if (bearerConfig) createAPITestSuite(bearerConfig);
-
-  if (!oauth1Config && !oauth2Config && !bearerConfig) {
-    it("should have at least one auth configuration", () => {
-      console.log(
-        "\n⚠️ No ClassLink auth configs found. Set env vars in test/.env",
-      );
-      console.log(
-        "  CLASSLINK_OAUTH1_SERVER_URL, CLASSLINK_OAUTH1_CLIENT_ID, CLASSLINK_OAUTH1_CLIENT_SECRET",
-      );
-      console.log(
-        "  CLASSLINK_OAUTH2_SERVER_URL, CLASSLINK_OAUTH2_CLIENT_ID, CLASSLINK_OAUTH2_CLIENT_SECRET",
-      );
-      console.log("  CLASSLINK_BEARER_SERVER_URL, CLASSLINK_BEARER_TOKEN");
-      expect(true).toBe(true);
+describe('ClassLink Client - API Calls', () => {
+    const oauth1Config = getOAuth1Config();
+    const oauth2Config = getOAuth2Config();
+    const bearerConfig = getBearerConfig();
+
+    beforeAll(() => {
+        console.log('\n' + '='.repeat(60));
+        console.log('ClassLink Client Test Suite');
+        console.log('='.repeat(60));
+        if (oauth1Config) console.log(`\n✓ OAuth1: ${oauth1Config.serverURL}`);
+        if (oauth2Config) console.log(`✓ OAuth2: ${oauth2Config.serverURL}`);
+        if (bearerConfig) console.log(`✓ Bearer: ${bearerConfig.serverURL}`);
     });
-  }
+
+    if (oauth1Config) createAPITestSuite(oauth1Config);
+    if (oauth2Config) createAPITestSuite(oauth2Config);
+    if (bearerConfig) createAPITestSuite(bearerConfig);
+
+    if (!oauth1Config && !oauth2Config && !bearerConfig) {
+        it('should have at least one auth configuration', () => {
+            console.log('\n⚠️ No ClassLink auth configs found. Set env vars in test/.env');
+            console.log(
+                '  CLASSLINK_OAUTH1_SERVER_URL, CLASSLINK_OAUTH1_CLIENT_ID, CLASSLINK_OAUTH1_CLIENT_SECRET'
+            );
+            console.log(
+                '  CLASSLINK_OAUTH2_SERVER_URL, CLASSLINK_OAUTH2_CLIENT_ID, CLASSLINK_OAUTH2_CLIENT_SECRET'
+            );
+            console.log('  CLASSLINK_BEARER_SERVER_URL, CLASSLINK_BEARER_TOKEN');
+            expect(true).toBe(true);
+        });
+    }
 });
 
 // ============================================================================
@@ -1132,5 +949,5 @@ describe("ClassLink Client - API Calls", () => {
 // ============================================================================
 
 afterAll(() => {
-  printSummary();
+    printSummary();
 });