@quenty/marketplaceutils 11.24.0 → 11.25.1

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [11.25.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/marketplaceutils@11.25.0...@quenty/marketplaceutils@11.25.1) (2026-07-23)
+
+**Note:** Version bump only for package @quenty/marketplaceutils
+
+# [11.25.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/marketplaceutils@11.24.0...@quenty/marketplaceutils@11.25.0) (2026-07-23)
+
+### Features
+
+- Add baseline player-mock and support across Nevermore for mocked players. ([567d121](https://github.com/Quenty/NevermoreEngine/commit/567d121ffc014b42391554088189a1a6296dda83))
+
 # [11.24.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/marketplaceutils@11.23.0...@quenty/marketplaceutils@11.24.0) (2026-07-20)
 
 ### Features

package/deploy.nevermore.json

@@ -0,0 +1,10 @@
+{
+  "targets": {
+    "test": {
+      "universeId": 9716264427,
+      "placeId": 121084030937626,
+      "project": "test/default.project.json",
+      "scriptTemplate": "test/scripts/Server/ServerMain.server.lua"
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/marketplaceutils",
-  "version": "11.24.0",
+  "version": "11.25.1",
   "description": "Provides utility methods for MarketplaceService",
   "keywords": [
     "Roblox",
@@ -31,11 +31,14 @@
   "dependencies": {
     "@quenty/loader": "10.11.0",
     "@quenty/memoize": "1.10.0",
-    "@quenty/promise": "10.20.0",
-    "@quenty/servicebag": "11.19.0"
+    "@quenty/nevermore-test-runner": "1.5.0",
+    "@quenty/playermock": "1.1.1",
+    "@quenty/promise": "10.21.0",
+    "@quenty/servicebag": "11.20.0",
+    "@quentystudios/jest-lua": "3.10.0-quenty.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2c903e91ae2ea1702ae1ce94af20af83af81e4fe"
+  "gitHead": "5ea0583dedebba6492f9ac6d719d32b45c5543fa"
 }

package/src/Shared/MarketplaceUtils.lua

@@ -8,6 +8,7 @@ local require = require(script.Parent.loader).load(script)
 
 local MarketplaceService = game:GetService("MarketplaceService")
 
+local PlayerMock = require("PlayerMock")
 local Promise = require("Promise")
 
 local MarketplaceUtils = {}
@@ -153,13 +154,18 @@ function MarketplaceUtils.promiseUserSubscriptionStatus(
 	player: Player,
 	subscriptionId: string
 ): Promise.Promise<UserSubscriptonStatus>
-	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(typeof(player) == "Instance" and (player:IsA("Player") or PlayerMock.isMock(player)), "Bad player")
 	assert(type(subscriptionId) == "string", "Bad subscriptionId")
 
 	return Promise.spawn(function(resolve, reject)
 		local subStatus
 		local ok, err = pcall(function()
-			subStatus = MarketplaceService:GetUserSubscriptionStatusAsync(player, subscriptionId)
+			if PlayerMock.isMock(player) then
+				subStatus =
+					PlayerMock.readLookup(player, "MarketplaceService.GetUserSubscriptionStatusAsync", subscriptionId)
+			else
+				subStatus = MarketplaceService:GetUserSubscriptionStatusAsync(player, subscriptionId)
+			end
 		end)
 		if not ok then
 			return reject(err)
@@ -184,7 +190,12 @@ function MarketplaceUtils.promiseUserOwnsGamePass(userId: number, gamePassId: nu
 	return Promise.spawn(function(resolve, reject)
 		local result
 		local ok, err = pcall(function()
-			result = MarketplaceService:UserOwnsGamePassAsync(userId, gamePassId)
+			local mockPlayer = PlayerMock.getMockByUserId(userId)
+			if mockPlayer ~= nil then
+				result = PlayerMock.readLookup(mockPlayer, "MarketplaceService.UserOwnsGamePassAsync", gamePassId)
+			else
+				result = MarketplaceService:UserOwnsGamePassAsync(userId, gamePassId)
+			end
 		end)
 		if not ok then
 			return reject(err)
@@ -209,7 +220,11 @@ function MarketplaceUtils.promisePlayerOwnsAsset(player: Player, assetId: number
 	return Promise.spawn(function(resolve, reject)
 		local result
 		local ok, err = pcall(function()
-			result = MarketplaceService:PlayerOwnsAsset(player, assetId)
+			if PlayerMock.isMock(player) then
+				result = PlayerMock.readLookup(player, "MarketplaceService.PlayerOwnsAsset", assetId)
+			else
+				result = MarketplaceService:PlayerOwnsAsset(player, assetId)
+			end
 		end)
 		if not ok then
 			return reject(err)
@@ -238,7 +253,11 @@ function MarketplaceUtils.promisePlayerOwnsAssetAsync(player: Player, assetId: n
 	return Promise.spawn(function(resolve, reject)
 		local result
 		local ok, err = pcall(function()
-			result = MarketplaceService:PlayerOwnsAssetAsync(player, assetId)
+			if PlayerMock.isMock(player) then
+				result = PlayerMock.readLookup(player, "MarketplaceService.PlayerOwnsAssetAsync", assetId)
+			else
+				result = MarketplaceService:PlayerOwnsAssetAsync(player, assetId)
+			end
 		end)
 		if not ok then
 			return reject(err)
@@ -263,7 +282,11 @@ function MarketplaceUtils.promisePlayerOwnsBundle(player: Player, bundleId: numb
 	return Promise.spawn(function(resolve, reject)
 		local result
 		local ok, err = pcall(function()
-			result = MarketplaceService:PlayerOwnsBundle(player, bundleId)
+			if PlayerMock.isMock(player) then
+				result = PlayerMock.readLookup(player, "MarketplaceService.PlayerOwnsBundle", bundleId)
+			else
+				result = MarketplaceService:PlayerOwnsBundle(player, bundleId)
+			end
 		end)
 		if not ok then
 			return reject(err)

package/src/Shared/MarketplaceUtils.spec.lua

@@ -0,0 +1,215 @@
+--!strict
+--[[
+	@class MarketplaceUtils.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local Workspace = game:GetService("Workspace")
+
+local Jest = require("Jest")
+local MarketplaceServiceCache = require("MarketplaceServiceCache")
+local MarketplaceUtils = require("MarketplaceUtils")
+local PlayerMock = require("PlayerMock")
+local PromiseTestUtils = require("PromiseTestUtils")
+
+local afterEach = Jest.Globals.afterEach
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+local MOCK_USER_ID = 88771001
+local GAME_PASS_ID = 111222333
+local ASSET_ID = 444555666
+local BUNDLE_ID = 777888999
+local SUBSCRIPTION_ID = "EXP-88771001"
+
+local createdMocks: { Player } = {}
+
+local function makeMock(overrides: { [string]: any }?): Player
+	local player = PlayerMock.new(overrides)
+	player.Parent = Workspace
+	table.insert(createdMocks, player)
+	return player
+end
+
+local function awaitBool(promise: any): boolean
+	expect(PromiseTestUtils.awaitSettled(promise, 5)).toBe(true)
+	local ok, value = promise:Yield()
+	expect(ok).toBe(true)
+	return value
+end
+
+afterEach(function()
+	for _, player in createdMocks do
+		player:Destroy()
+	end
+	table.clear(createdMocks)
+end)
+
+describe("MarketplaceUtils.promiseUserOwnsGamePass", function()
+	it("resolves false for a mock's userId with no injected ownership", function()
+		makeMock({ UserId = MOCK_USER_ID })
+
+		expect(awaitBool(MarketplaceUtils.promiseUserOwnsGamePass(MOCK_USER_ID, GAME_PASS_ID))).toBe(false)
+	end)
+
+	it("resolves the ownership injected on the mock", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+		PlayerMock.writeLookup(player, "MarketplaceService.UserOwnsGamePassAsync", GAME_PASS_ID, true)
+
+		expect(awaitBool(MarketplaceUtils.promiseUserOwnsGamePass(MOCK_USER_ID, GAME_PASS_ID))).toBe(true)
+	end)
+
+	it("keys the injected ownership by gamePassId", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+		PlayerMock.writeLookup(player, "MarketplaceService.UserOwnsGamePassAsync", GAME_PASS_ID, true)
+
+		expect(awaitBool(MarketplaceUtils.promiseUserOwnsGamePass(MOCK_USER_ID, GAME_PASS_ID + 1))).toBe(false)
+	end)
+
+	it("clears back to false when the injection is cleared", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+		PlayerMock.writeLookup(player, "MarketplaceService.UserOwnsGamePassAsync", GAME_PASS_ID, true)
+		PlayerMock.writeLookup(player, "MarketplaceService.UserOwnsGamePassAsync", GAME_PASS_ID, nil)
+
+		expect(awaitBool(MarketplaceUtils.promiseUserOwnsGamePass(MOCK_USER_ID, GAME_PASS_ID))).toBe(false)
+	end)
+
+	it("asserts on a non-number userId", function()
+		expect(function()
+			MarketplaceUtils.promiseUserOwnsGamePass("nope" :: any, GAME_PASS_ID)
+		end).toThrow()
+	end)
+end)
+
+describe("MarketplaceUtils.promisePlayerOwnsAsset", function()
+	it("resolves false for a mock with no injected ownership", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+
+		expect(awaitBool(MarketplaceUtils.promisePlayerOwnsAsset(player, ASSET_ID))).toBe(false)
+	end)
+
+	it("resolves the ownership injected on the mock", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+		PlayerMock.writeLookup(player, "MarketplaceService.PlayerOwnsAsset", ASSET_ID, true)
+
+		expect(awaitBool(MarketplaceUtils.promisePlayerOwnsAsset(player, ASSET_ID))).toBe(true)
+	end)
+end)
+
+describe("MarketplaceUtils.promisePlayerOwnsAssetAsync", function()
+	it("resolves false for a mock with no injected ownership", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+
+		expect(awaitBool(MarketplaceUtils.promisePlayerOwnsAssetAsync(player, ASSET_ID))).toBe(false)
+	end)
+
+	it("resolves the ownership injected on the mock", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+		PlayerMock.writeLookup(player, "MarketplaceService.PlayerOwnsAssetAsync", ASSET_ID, true)
+
+		expect(awaitBool(MarketplaceUtils.promisePlayerOwnsAssetAsync(player, ASSET_ID))).toBe(true)
+	end)
+
+	it("reads a distinct domain from promisePlayerOwnsAsset", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+		PlayerMock.writeLookup(player, "MarketplaceService.PlayerOwnsAsset", ASSET_ID, true)
+
+		expect(awaitBool(MarketplaceUtils.promisePlayerOwnsAssetAsync(player, ASSET_ID))).toBe(false)
+	end)
+end)
+
+describe("MarketplaceUtils.promisePlayerOwnsBundle", function()
+	it("resolves false for a mock with no injected ownership", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+
+		expect(awaitBool(MarketplaceUtils.promisePlayerOwnsBundle(player, BUNDLE_ID))).toBe(false)
+	end)
+
+	it("resolves the ownership injected on the mock", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+		PlayerMock.writeLookup(player, "MarketplaceService.PlayerOwnsBundle", BUNDLE_ID, true)
+
+		expect(awaitBool(MarketplaceUtils.promisePlayerOwnsBundle(player, BUNDLE_ID))).toBe(true)
+	end)
+end)
+
+describe("MarketplaceUtils.promiseUserSubscriptionStatus", function()
+	it("resolves an unsubscribed status for a mock with no injected status", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+
+		local outcome, status =
+			PromiseTestUtils.awaitOutcome(MarketplaceUtils.promiseUserSubscriptionStatus(player, SUBSCRIPTION_ID))
+		expect(outcome).toBe("resolved")
+		expect(status.IsSubscribed).toBe(false)
+		expect(status.IsRenewing).toBe(false)
+	end)
+
+	it("resolves the status injected on the mock", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+		PlayerMock.writeLookup(player, "MarketplaceService.GetUserSubscriptionStatusAsync", SUBSCRIPTION_ID, {
+			IsSubscribed = true,
+			IsRenewing = true,
+		})
+
+		local outcome, status =
+			PromiseTestUtils.awaitOutcome(MarketplaceUtils.promiseUserSubscriptionStatus(player, SUBSCRIPTION_ID))
+		expect(outcome).toBe("resolved")
+		expect(status.IsSubscribed).toBe(true)
+		expect(status.IsRenewing).toBe(true)
+	end)
+
+	it("keys the injected status by subscriptionId", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+		PlayerMock.writeLookup(player, "MarketplaceService.GetUserSubscriptionStatusAsync", SUBSCRIPTION_ID, {
+			IsSubscribed = true,
+			IsRenewing = false,
+		})
+
+		local outcome, status =
+			PromiseTestUtils.awaitOutcome(MarketplaceUtils.promiseUserSubscriptionStatus(player, "EXP-other"))
+		expect(outcome).toBe("resolved")
+		expect(status.IsSubscribed).toBe(false)
+	end)
+
+	it("asserts on a non-player value", function()
+		expect(function()
+			MarketplaceUtils.promiseUserSubscriptionStatus(Instance.new("Folder") :: any, SUBSCRIPTION_ID)
+		end).toThrow("Bad player")
+	end)
+
+	it("asserts on a non-string subscriptionId", function()
+		local player = makeMock({ UserId = MOCK_USER_ID })
+
+		expect(function()
+			MarketplaceUtils.promiseUserSubscriptionStatus(player, 123 :: any)
+		end).toThrow("Bad subscriptionId")
+	end)
+end)
+
+describe("MarketplaceUtils.promiseProductInfo", function()
+	it("asserts on a non-number assetId", function()
+		expect(function()
+			MarketplaceUtils.promiseProductInfo("nope" :: any, Enum.InfoType.GamePass)
+		end).toThrow("Bad assetId")
+	end)
+
+	it("asserts on a non-EnumItem infoType", function()
+		expect(function()
+			MarketplaceUtils.promiseProductInfo(ASSET_ID, 5 :: any)
+		end).toThrow("Bad infoType")
+	end)
+end)
+
+describe("MarketplaceServiceCache.PromiseProductInfo", function()
+	it("asserts on a non-number productId", function()
+		expect(function()
+			MarketplaceServiceCache.PromiseProductInfo(
+				MarketplaceServiceCache :: any,
+				"nope" :: any,
+				Enum.InfoType.Asset
+			)
+		end).toThrow("Bad productId")
+	end)
+end)

package/src/jest.config.lua

@@ -0,0 +1,3 @@
+return {
+	testMatch = { "**/*.spec" },
+}

package/test/default.project.json

@@ -0,0 +1,25 @@
+{
+  "name": "MarketplaceUtilsTest",
+  "globIgnorePaths": [
+    "**/.package-lock.json",
+    "**/.pnpm",
+    "**/.pnpm-workspace-state-v1.json",
+    "**/.modules.yaml",
+    "**/.ignored",
+    "**/.ignored_*"
+  ],
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "$properties": {
+        "LoadStringEnabled": true
+      },
+      "marketplaceutils": {
+        "$path": ".."
+      },
+      "Script": {
+        "$path": "scripts/Server"
+      }
+    }
+  }
+}

package/test/scripts/Server/ServerMain.server.lua

@@ -0,0 +1,13 @@
+--[[
+	@class ServerMain
+]]
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local root = ServerScriptService.marketplaceutils
+local loader = root:FindFirstChild("LoaderUtils", true).Parent
+local require = require(loader).bootstrapGame(root)
+
+local NevermoreTestRunnerUtils = require("NevermoreTestRunnerUtils")
+if NevermoreTestRunnerUtils.runTestsIfNeededAsync(root) then
+	return
+end