@hypercerts-org/sdk-core 0.2.0-beta.0

package/tests/utils/mocks.ts

@@ -0,0 +1,109 @@
+import type { SessionStore, StateStore, CacheInterface, LoggerInterface } from "../../src/core/interfaces.js";
+import type { NodeSavedSession, NodeSavedState } from "@atproto/oauth-client-node";
+
+/**
+ * In-memory session store for testing
+ */
+export class InMemorySessionStore implements SessionStore {
+  private sessions = new Map<string, NodeSavedSession>();
+
+  async get(did: string): Promise<NodeSavedSession | undefined> {
+    return this.sessions.get(did);
+  }
+
+  async set(did: string, session: NodeSavedSession): Promise<void> {
+    this.sessions.set(did, session);
+  }
+
+  async del(did: string): Promise<void> {
+    this.sessions.delete(did);
+  }
+
+  clear(): void {
+    this.sessions.clear();
+  }
+}
+
+/**
+ * In-memory state store for testing
+ */
+export class InMemoryStateStore implements StateStore {
+  private states = new Map<string, NodeSavedState>();
+
+  async get(key: string): Promise<NodeSavedState | undefined> {
+    return this.states.get(key);
+  }
+
+  async set(key: string, state: NodeSavedState): Promise<void> {
+    this.states.set(key, state);
+  }
+
+  async del(key: string): Promise<void> {
+    this.states.delete(key);
+  }
+
+  clear(): void {
+    this.states.clear();
+  }
+}
+
+/**
+ * In-memory cache for testing
+ */
+export class InMemoryCache implements CacheInterface {
+  private cache = new Map<string, { value: unknown; expiresAt?: number }>();
+
+  async get<T>(key: string): Promise<T | undefined> {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return undefined;
+    }
+
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return undefined;
+    }
+
+    return entry.value as T;
+  }
+
+  async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {
+    const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1000 : undefined;
+    this.cache.set(key, { value, expiresAt });
+  }
+
+  async del(key: string): Promise<void> {
+    this.cache.delete(key);
+  }
+
+  async clear(): Promise<void> {
+    this.cache.clear();
+  }
+}
+
+/**
+ * Mock logger for testing
+ */
+export class MockLogger implements LoggerInterface {
+  public logs: Array<{ level: string; message: string; args: unknown[] }> = [];
+
+  debug(message: string, ...args: unknown[]): void {
+    this.logs.push({ level: "debug", message, args });
+  }
+
+  info(message: string, ...args: unknown[]): void {
+    this.logs.push({ level: "info", message, args });
+  }
+
+  warn(message: string, ...args: unknown[]): void {
+    this.logs.push({ level: "warn", message, args });
+  }
+
+  error(message: string, ...args: unknown[]): void {
+    this.logs.push({ level: "error", message, args });
+  }
+
+  clear(): void {
+    this.logs = [];
+  }
+}

package/tests/utils/repository-fixtures.ts

@@ -0,0 +1,78 @@
+import type { LexiconDoc } from "@atproto/lexicon";
+import type { Session } from "../../src/core/types.js";
+
+/**
+ * Create a mock OAuth session for testing
+ */
+export function createMockSession(overrides?: Partial<Session>): Session {
+  const defaultServerMetadata = {
+    issuer: "https://pds.example.com",
+    authorization_endpoint: "https://pds.example.com/oauth/authorize",
+    token_endpoint: "https://pds.example.com/oauth/token",
+    token_endpoint_auth_methods_supported: ["private_key_jwt"],
+    code_challenge_methods_supported: ["S256"],
+    dpop_signing_alg_values_supported: ["ES256"],
+  } as const;
+
+  const defaultFetchHandler = async (_url: string, _options?: RequestInit): Promise<Response> => {
+    // Mock fetch handler - tests will override this
+    return new Response(JSON.stringify({}), { status: 200 });
+  };
+
+  const mockSession: Session = {
+    sub: "did:plc:testdid123456789012345678901234567890",
+    did: "did:plc:testdid123456789012345678901234567890",
+    serverMetadata: defaultServerMetadata,
+    fetchHandler: overrides?.fetchHandler ?? defaultFetchHandler,
+    getTokenInfo: async () => ({
+      expiresAt: new Date(Date.now() + 3600 * 1000),
+      expired: false,
+      scope: "atproto",
+      iss: "https://pds.example.com",
+      aud: "https://example.com/atproto-client-metadata.json",
+      sub: "did:plc:testdid123456789012345678901234567890",
+    }),
+    signOut: async () => {},
+    ...overrides,
+  };
+
+  return mockSession;
+}
+
+/**
+ * Create a mock lexicon document for testing
+ */
+export function createMockLexicon(id: string): LexiconDoc {
+  return {
+    lexicon: 1,
+    id,
+    defs: {
+      record: {
+        type: "record" as const,
+        record: {
+          type: "object" as const,
+          properties: {
+            text: { type: "string" as const },
+          },
+        },
+      },
+    },
+  } as LexiconDoc;
+}
+
+/**
+ * Create a mock blob reference
+ */
+export function createMockBlobRef(): {
+  $type: string;
+  ref: { $link: string };
+  mimeType: string;
+  size: number;
+} {
+  return {
+    $type: "blob",
+    ref: { $link: "bafyrei..." },
+    mimeType: "image/png",
+    size: 1024,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "lib": ["ES2020", "DOM"],
+    "noEmit": false,
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src/**/*", "tests/**/*"],
+  "exclude": ["node_modules", "dist"]
+}