strade-stx 1.0.0

package/tests/CoreMarketPlace.fuzz.test.ts

@@ -0,0 +1,435 @@
+import { describe, expect, it } from "vitest";
+import { Cl } from "@stacks/transactions";
+import fc from "fast-check";
+
+const CONTRACT_NAME = 'CoreMarketPlace';
+
+// Helper function to create string arguments
+const utf8 = (str: string) => Cl.stringUtf8(str);
+
+describe("CoreMarketPlace Contract - Fuzz Tests", () => {
+
+  it("should handle random valid listing creations", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 64 }),
+        fc.string({ minLength: 1, maxLength: 256 }),
+        fc.integer({ min: 1, max: 1000000000 }), // price in micro-STX
+        fc.integer({ min: 1, max: 52560 }), // duration
+        (name, description, price, duration) => {
+          const seller = simnet.getAccounts().get('wallet_1')!;
+
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'create-listing',
+            [
+              utf8(name),
+              utf8(description),
+              Cl.uint(price),
+              Cl.uint(duration)
+            ],
+            seller
+          );
+
+          // Should succeed for valid inputs (listing ID should be > 0)
+          expect(result).toBeOk(expect.anything());
+        }
+      )
+    );
+  });
+
+  it("should reject invalid prices during listing creation", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 64 }),
+        fc.string({ minLength: 1, maxLength: 256 }),
+        fc.integer({ min: 0, max: 0 }), // only zero price
+        fc.integer({ min: 1, max: 52560 }),
+        (name, description, price, duration) => {
+          const seller = simnet.getAccounts().get('wallet_1')!;
+
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'create-listing',
+            [
+              utf8(name),
+              utf8(description),
+              Cl.uint(price),
+              Cl.uint(duration)
+            ],
+            seller
+          );
+
+          // Should fail for zero price
+          expect(result).toBeErr(Cl.error(Cl.uint(102))); // ERR_INVALID_PRICE
+        }
+      )
+    );
+  });
+
+  it("should reject invalid durations during listing creation", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 64 }),
+        fc.string({ minLength: 1, maxLength: 256 }),
+        fc.integer({ min: 1, max: 1000000000 }),
+        fc.integer({ min: 0, max: 0 }), // zero duration
+        (name, description, price, duration) => {
+          const seller = simnet.getAccounts().get('wallet_1')!;
+
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'create-listing',
+            [
+              utf8(name),
+              utf8(description),
+              Cl.uint(price),
+              Cl.uint(duration)
+            ],
+            seller
+          );
+
+          // Should fail for zero duration
+          expect(result).toBeErr(Cl.error(Cl.uint(110))); // ERR_INVALID_DURATION
+        }
+      )
+    );
+  });
+
+  it("should reject invalid durations exceeding max during listing creation", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 64 }),
+        fc.string({ minLength: 1, maxLength: 256 }),
+        fc.integer({ min: 1, max: 1000000000 }),
+        fc.integer({ min: 52561, max: 100000 }), // duration > MAX_LISTING_DURATION
+        (name, description, price, duration) => {
+          const seller = simnet.getAccounts().get('wallet_1')!;
+
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'create-listing',
+            [
+              utf8(name),
+              utf8(description),
+              Cl.uint(price),
+              Cl.uint(duration)
+            ],
+            seller
+          );
+
+          // Should fail for duration > MAX_LISTING_DURATION
+          expect(result).toBeErr(Cl.error(Cl.uint(110))); // ERR_INVALID_DURATION
+        }
+      )
+    );
+  });
+
+  it("should reject empty names during listing creation", () => {
+    fc.assert(
+      fc.property(
+        fc.constant(""), // empty name
+        fc.string({ minLength: 1, maxLength: 256 }),
+        fc.integer({ min: 1, max: 1000000000 }),
+        fc.integer({ min: 1, max: 52560 }),
+        (name, description, price, duration) => {
+          const seller = simnet.getAccounts().get('wallet_1')!;
+
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'create-listing',
+            [
+              utf8(name),
+              utf8(description),
+              Cl.uint(price),
+              Cl.uint(duration)
+            ],
+            seller
+          );
+
+          // Should fail for empty name
+          expect(result).toBeErr(Cl.error(Cl.uint(109))); // ERR_INVALID_INPUT
+        }
+      )
+    );
+  });
+
+  it("should reject empty descriptions during listing creation", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 64 }),
+        fc.constant(""), // empty description
+        fc.integer({ min: 1, max: 1000000000 }),
+        fc.integer({ min: 1, max: 52560 }),
+        (name, description, price, duration) => {
+          const seller = simnet.getAccounts().get('wallet_1')!;
+
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'create-listing',
+            [
+              utf8(name),
+              utf8(description),
+              Cl.uint(price),
+              Cl.uint(duration)
+            ],
+            seller
+          );
+
+          // Should fail for empty description
+          expect(result).toBeErr(Cl.error(Cl.uint(109))); // ERR_INVALID_INPUT
+        }
+      )
+    );
+  });
+
+  it("should handle random valid listing updates", () => {
+    // First create a listing
+    const seller = simnet.getAccounts().get('wallet_1')!;
+    simnet.callPublicFn(
+      CONTRACT_NAME,
+      'create-listing',
+      [
+        utf8('Test Item'),
+        utf8('Test Description'),
+        Cl.uint(1000000),
+        Cl.uint(144)
+      ],
+      seller
+    );
+
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 1000000000 }), // new price
+        fc.string({ minLength: 1, maxLength: 256 }), // new description
+        (newPrice, newDescription) => {
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'update-listing',
+            [
+              Cl.uint(1),
+              Cl.uint(newPrice),
+              utf8(newDescription)
+            ],
+            seller
+          );
+
+          // Should succeed for valid updates
+          expect(result).toBeOk(Cl.bool(true));
+        }
+      )
+    );
+  });
+
+  it("should reject invalid price updates", () => {
+    // First create a listing
+    const seller = simnet.getAccounts().get('wallet_1')!;
+    simnet.callPublicFn(
+      CONTRACT_NAME,
+      'create-listing',
+      [
+        utf8('Test Item'),
+        utf8('Test Description'),
+        Cl.uint(1000000),
+        Cl.uint(144)
+      ],
+      seller
+    );
+
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 0, max: 0 }), // zero price
+        fc.string({ minLength: 1, maxLength: 256 }),
+        (newPrice, newDescription) => {
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'update-listing',
+            [
+              Cl.uint(1),
+              Cl.uint(newPrice),
+              utf8(newDescription)
+            ],
+            seller
+          );
+
+          // Should fail for zero price
+          expect(result).toBeErr(Cl.error(Cl.uint(102))); // ERR_INVALID_PRICE
+        }
+      )
+    );
+  });
+
+  it("should reject empty description updates", () => {
+    // First create a listing
+    const seller = simnet.getAccounts().get('wallet_1')!;
+    simnet.callPublicFn(
+      CONTRACT_NAME,
+      'create-listing',
+      [
+        utf8('Test Item'),
+        utf8('Test Description'),
+        Cl.uint(1000000),
+        Cl.uint(144)
+      ],
+      seller
+    );
+
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 1000000000 }),
+        fc.constant(""), // empty description
+        (newPrice, newDescription) => {
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'update-listing',
+            [
+              Cl.uint(1),
+              Cl.uint(newPrice),
+              utf8(newDescription)
+            ],
+            seller
+          );
+
+          // Should fail for empty description
+          expect(result).toBeErr(Cl.error(Cl.uint(109))); // ERR_INVALID_INPUT
+        }
+      )
+    );
+  });
+
+  it("should handle random purchases of active listings", () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 100 }), // random number of listings to create
+        (numListings) => {
+          const seller = simnet.getAccounts().get('wallet_1')!;
+          const buyer = simnet.getAccounts().get('wallet_2')!;
+
+          // Create multiple listings
+          for (let i = 0; i < Math.min(numListings, 10); i++) { // limit to 10 to avoid too many
+            simnet.callPublicFn(
+              CONTRACT_NAME,
+              'create-listing',
+              [
+                utf8(`Test Item ${i}`),
+                utf8(`Test Description ${i}`),
+                Cl.uint(1000000 + i),
+                Cl.uint(144)
+              ],
+              seller
+            );
+          }
+
+          // Try to purchase a random listing ID
+          const listingId = Math.floor(Math.random() * Math.min(numListings, 10)) + 1;
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'purchase-listing',
+            [Cl.uint(listingId)],
+            buyer
+          );
+
+          // Should succeed for active listing (assuming not already purchased)
+          // Note: This might fail if the listing was already purchased in previous runs
+          // but for fuzzing purposes, we're testing the function with random inputs
+          // Allow both success and failure since state persists across property runs
+          expect(result).toBeDefined();
+        }
+      )
+    );
+  });
+
+  it("should reject purchases of non-existent listings", () => {
+    const buyer = simnet.getAccounts().get('wallet_2')!;
+
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 2, max: 1000 }), // non-existent IDs
+        (listingId) => {
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'purchase-listing',
+            [Cl.uint(listingId)],
+            buyer
+          );
+
+          // Should fail for non-existent listing
+          expect(result).toBeErr(Cl.error(Cl.uint(111))); // ERR_INVALID_LISTING_ID
+        }
+      )
+    );
+  });
+
+  it("should handle random cancellations by seller", () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 10 }), // random number of listings to create
+        (numListings) => {
+          const seller = simnet.getAccounts().get('wallet_1')!;
+
+          // Create multiple listings
+          for (let i = 0; i < numListings; i++) {
+            simnet.callPublicFn(
+              CONTRACT_NAME,
+              'create-listing',
+              [
+                utf8(`Test Item ${i}`),
+                utf8(`Test Description ${i}`),
+                Cl.uint(1000000 + i),
+                Cl.uint(144)
+              ],
+              seller
+            );
+          }
+
+          // Try to cancel a random listing ID
+          const listingId = Math.floor(Math.random() * numListings) + 1;
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'cancel-listing',
+            [Cl.uint(listingId)],
+            seller
+          );
+
+          // Should succeed for active listing by seller
+          // Allow both success and failure since state persists across property runs
+          expect(result).toBeDefined();
+        }
+      )
+    );
+  });
+
+  it("should reject cancellations by non-sellers", () => {
+    // Create a listing
+    const seller = simnet.getAccounts().get('wallet_1')!;
+    const nonSeller = simnet.getAccounts().get('wallet_2')!;
+    simnet.callPublicFn(
+      CONTRACT_NAME,
+      'create-listing',
+      [
+        utf8('Test Item'),
+        utf8('Test Description'),
+        Cl.uint(1000000),
+        Cl.uint(144)
+      ],
+      seller
+    );
+
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 1 }), // only listing ID 1
+        (listingId) => {
+          const { result } = simnet.callPublicFn(
+            CONTRACT_NAME,
+            'cancel-listing',
+            [Cl.uint(listingId)],
+            nonSeller
+          );
+
+          // Should fail for non-seller
+          expect(result).toBeErr(Cl.error(Cl.uint(107))); // ERR_NOT_SELLER
+        }
+      )
+    );
+  });
+});