fix tests

Author: elliotBraem

packages/near-social/src/__tests__/index.test.ts

@@ -1,22 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import NearSocialPlugin from "../index";
-
-// Mock the Social class
-vi.mock("@builddao/near-social-js", () => {
-  return {
-    Social: vi.fn().mockImplementation(() => {
-      return {
-        get: vi.fn().mockResolvedValue({ "test.near": { profile: { name: "Test User" } } }),
-        set: vi.fn().mockResolvedValue({
-          actions: [{ type: "FunctionCall", params: { method_name: "set", args: {} } }]
-        })
-      };
-    }),
-    transformActions: vi.fn().mockReturnValue([
-      { type: "FunctionCall", params: { method_name: "set", args: {} } }
-    ])
-  };
-});
+import * as nearAPI from "near-api-js";
 
 describe("NearSocialPlugin", () => {
   let plugin: NearSocialPlugin;
@@ -26,85 +10,123 @@ describe("NearSocialPlugin", () => {
     // Spy on console methods
     vi.spyOn(console, "log").mockImplementation(() => {});
     vi.spyOn(console, "error").mockImplementation(() => {});
+
+    // Reset mocks
+    vi.clearAllMocks();
   });
 
   it("should initialize with valid config", async () => {
-    await expect(
-      plugin.initialize({
+    // Create a mock implementation for the Near constructor
+    // Mock the methods using spyOn with more complete implementations
+    const fromStringSpy = vi
+      .spyOn(nearAPI.KeyPair, "fromString")
+      .mockReturnValue({
+        sign: vi.fn(),
+        verify: vi.fn(),
+        getPublicKey: vi
+          .fn()
+          .mockReturnValue({ toString: () => "test-public-key" }),
+      } as any);
+
+    try {
+      await plugin.initialize({
         accountId: "test.near",
         privateKey: "ed25519:privatekey",
-        networkId: "testnet"
-      })
-    ).resolves.not.toThrow();
+        networkId: "testnet",
+      });
+
+      // Verify that the plugin was initialized with the correct values
+      expect(plugin["accountId"]).toBe("test.near");
+      expect(plugin["privateKey"]).toBe("ed25519:privatekey");
+      expect(plugin["networkId"]).toBe("testnet");
+    } finally {
+      // Restore the original methods
+      fromStringSpy.mockRestore();
+    }
   });
 
   it("should throw error when initializing without config", async () => {
     await expect(plugin.initialize()).rejects.toThrow(
-      "NEAR Social plugin requires configuration."
+      "NEAR Social plugin requires configuration.",
     );
   });
 
   it("should throw error when initializing without accountId", async () => {
     await expect(
       plugin.initialize({
-        privateKey: "ed25519:privatekey"
-      } as any)
+        privateKey: "ed25519:privatekey",
+      } as any),
     ).rejects.toThrow("NEAR Social plugin requires accountId");
   });
 
   it("should throw error when initializing without privateKey", async () => {
     await expect(
       plugin.initialize({
-        accountId: "test.near"
-      } as any)
+        accountId: "test.near",
+      } as any),
     ).rejects.toThrow("NEAR Social plugin requires privateKey");
   });
 
   it("should distribute content successfully", async () => {
-    // Initialize the plugin
-    await plugin.initialize({
-      accountId: "test.near",
-      privateKey: "ed25519:privatekey",
-      networkId: "testnet"
-    });
-
-    // Mock the signAndSendTransaction method
-    const signAndSendTransactionSpy = vi.spyOn(
-      plugin as any,
-      "signAndSendTransaction"
-    ).mockResolvedValue(undefined);
-
-    // Distribute content
-    await expect(
-      plugin.distribute({
+    // Create a mock implementation for the Near constructor
+    const mockNear = {
+      connection: {},
+    };
+
+    // Mock the methods using spyOn with more complete implementations
+    const fromStringSpy = vi
+      .spyOn(nearAPI.KeyPair, "fromString")
+      .mockReturnValue({
+        sign: vi.fn(),
+        verify: vi.fn(),
+        getPublicKey: vi
+          .fn()
+          .mockReturnValue({ toString: () => "test-public-key" }),
+      } as any);
+
+    const nearSpy = vi
+      .spyOn(nearAPI, "Near")
+      .mockImplementation(() => mockNear as any);
+
+    try {
+      // Initialize the plugin
+      await plugin.initialize({
+        accountId: "test.near",
+        privateKey: "ed25519:privatekey",
+        networkId: "testnet",
+      });
+
+      // Mock the callMethod method
+      const callMethodSpy = vi
+        .spyOn(plugin as any, "callMethod")
+        .mockResolvedValue(undefined);
+
+      // Distribute content
+      await plugin.distribute({
         input: "Hello, NEAR Social!",
         config: {
           accountId: "test.near",
           privateKey: "ed25519:privatekey",
-          networkId: "testnet"
-        }
-      })
-    ).resolves.not.toThrow();
-
-    // Verify signAndSendTransaction was called
-    expect(signAndSendTransactionSpy).toHaveBeenCalled();
-    
-    // Verify console.log was called with success message
-    expect(console.log).toHaveBeenCalledWith("Successfully posted to NEAR Social");
+          networkId: "testnet",
+        },
+      });
+
+      // Verify callMethod was called
+      expect(callMethodSpy).toHaveBeenCalled();
+
+      // Verify console.log was called with success message
+      expect(console.log).toHaveBeenCalledWith(
+        "Successfully posted to NEAR Social",
+      );
+    } finally {
+      // Restore the original methods
+      fromStringSpy.mockRestore();
+      nearSpy.mockRestore();
+    }
   });
 
   it("should throw error when distributing without initialization", async () => {
     await expect(
-      plugin.distribute({
-        input: "Hello, NEAR Social!",
-        config: {
-          accountId: "test.near",
-          privateKey: "ed25519:privatekey"
-        }
-      })
-    ).rejects.toThrow("NEAR Social plugin not initialized");
-  });
-});
       plugin.distribute({
         input: "Hello, NEAR Social!",
         config: {

packages/near-social/src/index.ts

@@ -125,11 +125,6 @@ export default class NearSocialPlugin
     }
   }
 
-  /**
-   * Makes a call to a contract
-   * @param options - the options for the call
-   * @returns - the resulting transaction
-   */
   /**
    * Helper method to get an Account instance
    * @returns Account instance