@sprucelabs/spruce-test-fixtures 66.0.19 → 66.0.21

package/build/tests/decorators/fake.js

@@ -14,6 +14,7 @@ const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
 const test_utils_1 = require("@sprucelabs/test-utils");
 const test_utils_2 = require("@sprucelabs/test-utils");
 const SpruceError_1 = __importDefault(require("../../errors/SpruceError"));
+const FakerTracker_1 = __importDefault(require("../../FakerTracker"));
 const AbstractSpruceFixtureTest_1 = __importDefault(require("../AbstractSpruceFixtureTest"));
 const eventFaker_1 = __importDefault(require("../eventFaker"));
 const generateRandomName_1 = __importDefault(require("../fixtures/generateRandomName"));
@@ -29,27 +30,12 @@ const strategies = {
     groupManagers: buildSeeder('groupManagers'),
     owners: buildSeeder('owners'),
 };
-function resetFakedRecords(Class) {
+function resetFakedRecords() {
     if (shouldSkipNextReset) {
         shouldSkipNextReset = false;
         return;
     }
-    Class._fakedOrganizations = [];
-    Class._fakedLocations = [];
-    Class.fakedTeammates = [];
-    Class.fakedInstalledSkills = [];
-    Class.fakedPeopleRoles = [];
-    Class.fakedManagers = [];
-    Class.fakedOwners = [];
-    Class.fakedGroupManagers = [];
-    Class.fakedGuests = [];
-    Class.fakedRoles = [];
-    Class.fakedPeople = Class.fakedPeople?.[0] ? [Class.fakedPeople[0]] : [];
-    Class.fakedSkills = [];
-    Class.fakedTokens = Class.fakedTokens?.[0] ? [Class.fakedTokens[0]] : [];
-    Class.fakedProxyTokens = Class.fakedProxyTokens?.[0]
-        ? [Class.fakedProxyTokens[0]]
-        : [];
+    FakerTracker_1.default.resetFakedData();
 }
 function fake(target, total) {
     (0, schema_1.assertOptions)({ target, total }, ['target', 'total']);
@@ -57,10 +43,10 @@ function fake(target, total) {
         const Class = TestClass;
         const bound = descriptor?.value?.bind?.(Class);
         descriptor.value = async (...args) => {
-            test_utils_1.assert.isTruthy(Class.fakedPerson, `You gotta @faker.login(...) before you can create fake '${target}'!`);
+            test_utils_1.assert.isTruthy(FakerTracker_1.default.fakedPerson, `You gotta @faker.login(...) before you can create fake '${target}'!`);
             const strategy = strategies[target];
             test_utils_1.assert.isTruthy(strategy, `Faking ${target} is not ready yet!`);
-            await strategy?.(Class, total);
+            await strategy?.(total);
             await bound?.(...args);
         };
     };
@@ -78,49 +64,42 @@ fake.login = (phone = '555-000-0000') => {
             spruce_skill_utils_1.testLog.warn(`@fake.login() is attached to an incompatible test class (${TestClass.name}). You can safely remove it or have your test class extend AbstractSpruceFixtureTest.`);
             return;
         }
-        const Class = TestClass;
-        const beforeEach = Class.beforeEach?.bind(Class);
-        const beforeAll = Class.beforeAll?.bind(Class);
-        const afterEach = Class.afterEach?.bind(Class);
         if (shouldPassHookCalls) {
             const old = MercuryFixture_1.default.beforeEach.bind(MercuryFixture_1.default);
             MercuryFixture_1.default.beforeEach = async (...args) => {
                 //@ts-ignore
                 await old(...args);
-                await setupFakeListeners(Class);
+                await setupFakeListeners();
             };
         }
-        Class.beforeAll = async () => {
-            await beforeAll?.();
-            resetFakedRecords(Class);
-            await setupFakeListeners(Class);
-            await login(Class, phone);
-            MercuryFixture_1.default.setDefaultClient(Class.fakedClient);
-        };
-        Class.afterEach = async () => {
-            await setupFakeListeners(Class);
-            await afterEach?.();
-        };
-        Class.beforeEach = async () => {
-            resetFakedRecords(Class);
-            await setupFakeListeners(Class);
+        test_utils_1.SpruceTestResolver.onDidCallBeforeAll(async () => {
+            resetFakedRecords();
+            await setupFakeListeners();
+            await login(phone);
+            MercuryFixture_1.default.setDefaultClient(FakerTracker_1.default.fakedClient);
+        });
+        test_utils_1.SpruceTestResolver.onDidCallAfterEach(async () => {
+            await setupFakeListeners();
+        });
+        test_utils_1.SpruceTestResolver.onWillCallBeforeEach(async (TestClass) => {
+            resetFakedRecords();
+            await setupFakeListeners();
             if (!TestClass.cwd) {
                 return;
             }
             ViewFixture_1.default.resetAuth();
             try {
-                if (Class.fakedPerson) {
-                    const auth = Class.permissions.getAuthenticator();
+                if (FakerTracker_1.default.fakedPerson) {
+                    const auth = getFixturesForActiveTest().permissions.getAuthenticator();
                     auth.setSessionToken(
                     //@ts-ignore
-                    Class.fakedClient.auth.token, Class.fakedPerson);
+                    FakerTracker_1.default.fakedClient.auth.token, FakerTracker_1.default.fakedPerson);
                 }
             }
             catch {
                 //hits if not in skill because cant find nameplace
             }
-            shouldPassHookCalls && (await beforeEach?.());
-        };
+        });
     };
 };
 fake.getClient = () => {
@@ -130,32 +109,32 @@ fake.getPerson = () => {
     //@ts-ignore
     return fake.getClient().auth.person;
 };
-async function login(Class, phone) {
-    const { person, client } = await loginUsingViewsFallingBackToPeople(Class, phone);
+async function login(phone) {
+    const { person, client } = await loginUsingViewsFallingBackToPeople(phone);
     if (!person.firstName) {
         givePersonName(person);
     }
     await client.registerProxyToken();
     //@ts-ignore
     client.auth.person = person;
-    Class.fakedClient = client;
-    Class.fakedPerson = person;
+    FakerTracker_1.default.fakedClient = client;
+    FakerTracker_1.default.fakedPerson = person;
 }
-async function loginUsingViewsFallingBackToPeople(Class, phone) {
+async function loginUsingViewsFallingBackToPeople(phone) {
     let person;
     let client;
     try {
-        const { person: p, client: c } = await Class.views.loginAsDemoPerson(phone);
+        const { person: p, client: c } = await getFixturesForActiveTest().views.loginAsDemoPerson(phone);
         person = p;
         client = c;
     }
     catch {
-        const { person: p, client: c } = await Class.people.loginAsDemoPerson(phone);
+        const { person: p, client: c } = await getFixturesForActiveTest().people.loginAsDemoPerson(phone);
         person = p;
         client = c;
     }
     return {
-        person: Class.fakedPeople.find((p) => p.id === person.id),
+        person: FakerTracker_1.default.fakedPeople.find((p) => p.id === person.id),
         client,
     };
 }
@@ -165,39 +144,38 @@ function givePersonName(person) {
     person.firstName = names.firstName;
     person.lastName = names.lastName;
 }
-async function setupFakeListeners(Class) {
+async function setupFakeListeners() {
     await Promise.all([
-        fakeSkillLifecycleEvents(Class),
-        fakeGetPerson(Class),
-        fakeRegisterProxyToken(Class),
-        fakeWhoAmI(Class),
-        fakeInstallEvents(Class),
-        fakeAuthenticationEvents(Class),
-        fakeAddRole(Class),
-        fakeGetRole(Class),
-        fakeRemoveRole(Class),
-        fakeListRoles(Class),
-        fakeListPeople(Class),
-        fakeUpdatePerson(Class),
-        fakeListLocations(Class),
-        fakeGetLocation(Class),
-        fakeUpdateLocation(Class),
-        fakeDeleteOrganization(Class),
-        fakeCreateLocation(Class),
-        fakeCreateOrganization(Class),
-        fakeGetOrganization(Class),
-        fakeUpdateOrganization(Class),
-        fakeListOrganization(Class),
+        fakeSkillLifecycleEvents(),
+        fakeGetPerson(),
+        fakeRegisterProxyToken(),
+        fakeWhoAmI(),
+        fakeInstallEvents(),
+        fakeAuthenticationEvents(),
+        fakeAddRole(),
+        fakeGetRole(),
+        fakeRemoveRole(),
+        fakeListRoles(),
+        fakeListPeople(),
+        fakeUpdatePerson(),
+        fakeListLocations(),
+        fakeGetLocation(),
+        fakeUpdateLocation(),
+        fakeDeleteOrganization(),
+        fakeCreateLocation(),
+        fakeCreateOrganization(),
+        fakeGetOrganization(),
+        fakeUpdateOrganization(),
+        fakeListOrganization(),
         fakeRegisterListeners(),
     ]);
 }
-async function fakeAddRole(Class) {
+async function fakeAddRole() {
     await eventFaker_1.default.on('add-role::v2020_12_25', ({ payload, target }) => {
         const { organizationId, locationId } = target ?? {};
         const { roleId } = payload;
-        const person = getPersonById(Class, payload.personId);
+        const person = getPersonById(payload.personId);
         addPersonAsRoleToLocationOrOrg({
-            Class,
             roleId,
             person,
             organizationId,
@@ -207,32 +185,32 @@ async function fakeAddRole(Class) {
     });
 }
 function addPersonAsRoleToLocationOrOrg(options) {
-    const { Class, roleId, person, organizationId, locationId } = options;
-    const role = getRoleById(Class, roleId);
+    const { roleId, person, organizationId, locationId } = options;
+    const role = getRoleById(roleId);
     const key = roleBaseToLocalFakedProp(role.base);
     //@ts-ignore
-    test_utils_1.assert.isTruthy(Class[key], `Could not find property ${key}`);
-    const idx = Class[key].findIndex((p) => p.id === person.id);
+    test_utils_1.assert.isTruthy(FakerTracker_1.default[key], `Could not find property ${key}`);
+    const idx = FakerTracker_1.default[key].findIndex((p) => p.id === person.id);
     if (idx === -1) {
         //@ts-ignore
-        Class[key].unshift(person);
+        FakerTracker_1.default[key].unshift(person);
     }
-    Class.fakedPeopleRoles.push({
+    FakerTracker_1.default.fakedPeopleRoles.push({
         personId: person.id,
         roleId: role.id,
         organizationId,
         locationId,
     });
 }
-function getRoleById(Class, roleId) {
-    const role = Class.fakedRoles.find((r) => r.id === roleId);
+function getRoleById(roleId) {
+    const role = FakerTracker_1.default.fakedRoles.find((r) => r.id === roleId);
     test_utils_1.assert.isTruthy(role, `Could not load faked role with the id of ${roleId}.`);
     return role;
 }
-async function fakeGetRole(Class) {
+async function fakeGetRole() {
     await eventFaker_1.default.on('get-role::v2020_12_25', ({ target }) => {
         const { roleId } = target;
-        const role = Class.fakedRoles.find((r) => r.id === roleId);
+        const role = FakerTracker_1.default.fakedRoles.find((r) => r.id === roleId);
         if (!role) {
             throw new SpruceError_1.default({
                 code: 'NOT_FOUND',
@@ -244,22 +222,22 @@ async function fakeGetRole(Class) {
         };
     });
 }
-async function fakeRemoveRole(Class) {
+async function fakeRemoveRole() {
     await eventFaker_1.default.on('remove-role::v2020_12_25', ({ payload }) => {
         const { personId, roleId } = payload;
-        const role = getRoleById(Class, roleId);
-        const people = Class[roleBaseToLocalFakedProp(role.base)];
+        const role = getRoleById(roleId);
+        const people = FakerTracker_1.default[roleBaseToLocalFakedProp(role.base)];
         const idx = people?.findIndex((p) => p.id === personId) ?? -1;
         people?.splice(idx, 1);
-        Class.fakedPeopleRoles = Class.fakedPeopleRoles.filter((p) => !(p.personId === personId && p.roleId === roleId));
+        FakerTracker_1.default.fakedPeopleRoles = FakerTracker_1.default.fakedPeopleRoles.filter((p) => !(p.personId === personId && p.roleId === roleId));
         return {};
     });
 }
 function roleBaseToLocalFakedProp(base) {
     return fakeTargetToPropName((base + 's'));
 }
-function getPersonById(Class, personId, shouldThrowWhenNotFound = true) {
-    const person = Class.fakedPeople.find((p) => p.id === personId);
+function getPersonById(personId, shouldThrowWhenNotFound = true) {
+    const person = FakerTracker_1.default.fakedPeople.find((p) => p.id === personId);
     if (!person && shouldThrowWhenNotFound) {
         throw new SpruceError_1.default({
             code: 'INVALID_TARGET',
@@ -268,9 +246,9 @@ function getPersonById(Class, personId, shouldThrowWhenNotFound = true) {
     }
     return person;
 }
-async function fakeUpdatePerson(Class) {
+async function fakeUpdatePerson() {
     await eventFaker_1.default.on('update-person::v2020_12_25', ({ target, source, payload }) => {
-        const person = Class.fakedPeople.find((p) => target?.personId
+        const person = FakerTracker_1.default.fakedPeople.find((p) => target?.personId
             ? p.id === target?.personId
             : p.id === source?.personId);
         if (!person) {
@@ -287,26 +265,26 @@ async function fakeUpdatePerson(Class) {
         };
     });
 }
-async function fakeListRoles(Class) {
+async function fakeListRoles() {
     await eventFaker_1.default.on('list-roles::v2020_12_25', ({ target, payload }) => {
         let { personId, organizationId, locationId } = target ?? {};
         const { shouldIncludeMetaRoles, shouldIncludePrivateRoles } = payload ?? {};
         let roles = [];
         if (personId) {
-            const personRoles = Class.fakedPeopleRoles
+            const personRoles = FakerTracker_1.default.fakedPeopleRoles
                 .filter((p) => p.personId === personId &&
                 ((p.organizationId &&
                     p.organizationId === organizationId) ||
                     (p.locationId && p.locationId === locationId) ||
                     (!locationId && !organizationId)))
-                .map((pr) => getRoleById(Class, pr.roleId));
+                .map((pr) => getRoleById(pr.roleId));
             roles = personRoles;
         }
         else {
             if (locationId) {
-                organizationId = Class._fakedLocations.find((l) => l.id === locationId)?.organizationId;
+                organizationId = FakerTracker_1.default.fakedLocations.find((l) => l.id === locationId)?.organizationId;
             }
-            roles = Class.fakedRoles.filter((r) => r.organizationId === organizationId);
+            roles = FakerTracker_1.default.fakedRoles.filter((r) => r.organizationId === organizationId);
         }
         if (!shouldIncludeMetaRoles) {
             roles = roles.filter((r) => spruce_core_schemas_1.META_BASE_ROLES.findIndex((m) => m.slug === r.base) === -1);
@@ -319,37 +297,37 @@ async function fakeListRoles(Class) {
         };
     });
 }
-async function fakeListPeople(Class) {
+async function fakeListPeople() {
     await eventFaker_1.default.on('list-people::v2020_12_25', ({ payload }) => {
         let people = [];
         test_utils_1.assert.isFalsy(payload?.roleIds, `@fake does not support listing people by roleIds. You will need to use 'eventFaker.on('list-people')' to fake your own response OR consider checking this.fakedPeople on your test class.`);
         test_utils_1.assert.isFalsy(payload?.personIds, `@fake does not support listing people by personIds. You will need to use 'eventFaker.on(...)' to fake your own response OR consider checking this.fakedPeople on your test class`);
         for (const base of payload?.roleBases ?? []) {
-            const faked = getFakedRecordsByRoleBase(Class, base);
+            const faked = getFakedRecordsByRoleBase(base);
             if (faked) {
                 people.push(...faked);
             }
         }
         return {
-            people: payload?.roleBases ? people : Class.fakedPeople,
+            people: payload?.roleBases ? people : FakerTracker_1.default.fakedPeople,
         };
     });
 }
-function getFakedRecordsByRoleBase(Class, base) {
+function getFakedRecordsByRoleBase(base) {
     //@ts-ignore
-    return Class[fakeTargetToPropName(singularToPlural(base))];
+    return FakerTracker_1.default[fakeTargetToPropName(singularToPlural(base))];
 }
-async function fakeListLocations(Class) {
+async function fakeListLocations() {
     await eventFaker_1.default.on('list-locations::v2020_12_25', ({ target, payload }) => {
         return {
-            locations: applyPaging(Class._fakedLocations, payload).filter((l) => !target?.organizationId ||
+            locations: applyPaging(FakerTracker_1.default.fakedLocations, payload).filter((l) => !target?.organizationId ||
                 l.organizationId === target?.organizationId),
         };
     });
 }
-async function fakeGetLocation(Class) {
+async function fakeGetLocation() {
     await eventFaker_1.default.on('get-location::v2020_12_25', ({ target }) => {
-        const match = Class._fakedLocations.find((l) => l.id === target.locationId);
+        const match = FakerTracker_1.default.fakedLocations.find((l) => l.id === target.locationId);
         if (!match) {
             throw new SpruceError_1.default({
                 code: 'INVALID_TARGET',
@@ -361,43 +339,43 @@ async function fakeGetLocation(Class) {
         };
     });
 }
-async function fakeUpdateLocation(Class) {
+async function fakeUpdateLocation() {
     await eventFaker_1.default.on('update-location::v2020_12_25', ({ target, payload }) => {
         const { locationId } = target;
-        let idx = Class._fakedLocations.findIndex((l) => l.id === locationId);
-        if (!Class._fakedLocations[idx]) {
+        let idx = FakerTracker_1.default.fakedLocations.findIndex((l) => l.id === locationId);
+        if (!FakerTracker_1.default.fakedLocations[idx]) {
             throw new SpruceError_1.default({
                 code: 'INVALID_TARGET',
                 friendlyMessage: `I could not find that location to update!`,
             });
         }
-        Class._fakedLocations[idx] = {
-            ...Class._fakedLocations[idx],
+        FakerTracker_1.default.fakedLocations[idx] = {
+            ...FakerTracker_1.default.fakedLocations[idx],
             ...payload,
             dateUpdated: Date.now(),
         };
         return {
-            location: Class._fakedLocations[idx],
+            location: FakerTracker_1.default.fakedLocations[idx],
         };
     });
 }
-async function fakeDeleteOrganization(Class) {
+async function fakeDeleteOrganization() {
     await eventFaker_1.default.on('delete-organization::v2020_12_25', ({ target: { organizationId } }) => {
-        const idx = Class._fakedOrganizations.findIndex((o) => o.id === organizationId);
+        const idx = FakerTracker_1.default.fakedOrganizations.findIndex((o) => o.id === organizationId);
         if (idx === -1) {
             throw new SpruceError_1.default({
                 code: 'INVALID_TARGET',
                 friendlyMessage: `I could not find that organization to delete!`,
             });
         }
-        const match = Class._fakedOrganizations[idx];
-        Class._fakedOrganizations.splice(idx, 1);
+        const match = FakerTracker_1.default.fakedOrganizations[idx];
+        FakerTracker_1.default.fakedOrganizations.splice(idx, 1);
         return {
             organization: match,
         };
     });
 }
-async function fakeCreateLocation(Class) {
+async function fakeCreateLocation() {
     await eventFaker_1.default.on('create-location::v2020_12_25', ({ target, payload, source }) => {
         const { personId } = source ?? {};
         //@ts-ignore - delete when you find this (pushing through upgrades)
@@ -408,13 +386,12 @@ async function fakeCreateLocation(Class) {
             ...payload,
             slug: payload.slug ?? spruce_skill_utils_1.namesUtil.toKebab(payload.name),
         };
-        Class._fakedLocations.unshift(location);
+        FakerTracker_1.default.fakedLocations.unshift(location);
         if (personId) {
-            const role = Class.fakedRoles.find((r) => r.base === 'owner');
+            const role = FakerTracker_1.default.fakedRoles.find((r) => r.base === 'owner');
             addPersonAsRoleToLocationOrOrg({
-                Class,
                 roleId: role.id,
-                person: Class.fakedPerson,
+                person: FakerTracker_1.default.fakedPerson,
                 locationId: location.id,
             });
         }
@@ -423,7 +400,7 @@ async function fakeCreateLocation(Class) {
         };
     });
 }
-async function fakeCreateOrganization(Class) {
+async function fakeCreateOrganization() {
     await eventFaker_1.default.on('create-organization::v2020_12_25', ({ payload }) => {
         const organization = {
             id: (0, test_utils_2.generateId)(),
@@ -432,23 +409,22 @@ async function fakeCreateOrganization(Class) {
             ...payload,
             slug: payload.slug ?? spruce_skill_utils_1.namesUtil.toKebab(payload.name),
         };
-        Class._fakedOrganizations.unshift(organization);
-        const roles = seedRoles(Class, organization.id);
+        FakerTracker_1.default.fakedOrganizations.unshift(organization);
+        const roles = seedRoles(organization.id);
         addPersonAsRoleToLocationOrOrg({
-            Class,
             organizationId: organization.id,
             roleId: roles.find((r) => r.base === 'owner').id,
-            person: Class.fakedPerson,
+            person: FakerTracker_1.default.fakedPerson,
         });
         return {
             organization,
         };
     });
 }
-async function fakeGetPerson(Class) {
+async function fakeGetPerson() {
     await eventFaker_1.default.on('get-person::v2020_12_25', ({ target }) => {
         test_utils_1.assert.isTruthy(target?.personId, `@fake only supports 'get-person::v2020_12_25' when passing an id. To fake more, use 'eventFaker.on(...)'.`);
-        const person = getPersonById(Class, target.personId);
+        const person = getPersonById(target.personId);
         if (!person) {
             throw new SpruceError_1.default({
                 code: 'INVALID_TARGET',
@@ -460,19 +436,19 @@ async function fakeGetPerson(Class) {
         };
     });
 }
-async function fakeSkillLifecycleEvents(Class) {
+async function fakeSkillLifecycleEvents() {
     process.env.SKILL_ID = process.env.SKILL_ID || (0, test_utils_2.generateId)();
     process.env.SKILL_API_KEY = process.env.SKILL_API_KEY || (0, test_utils_2.generateId)();
     await eventFaker_1.default.on('register-skill::v2020_12_25', ({ payload }) => {
         const skill = {
             apiKey: (0, test_utils_2.generateId)(),
-            creators: [{ personId: Class.fakedPerson.id }],
+            creators: [{ personId: FakerTracker_1.default.fakedPerson.id }],
             dateCreated: new Date().getTime(),
             id: (0, test_utils_2.generateId)(),
             ...payload,
             slug: payload.slug ?? (0, test_utils_2.generateId)(),
         };
-        Class.fakedSkills.unshift(skill);
+        FakerTracker_1.default.fakedSkills.unshift(skill);
         return {
             skill,
         };
@@ -488,17 +464,17 @@ async function fakeSkillLifecycleEvents(Class) {
 function buildCasualName(names) {
     return `${names.firstName ?? 'friend'} ${names.lastName ? names.lastName[0] + '.' : ''}`.trim();
 }
-async function fakeGetOrganization(Class) {
+async function fakeGetOrganization() {
     await eventFaker_1.default.on('get-organization::v2020_12_25', ({ target }) => {
-        const match = findOrgFromTarget(Class, target);
+        const match = findOrgFromTarget(target);
         return {
             organization: match,
         };
     });
 }
-async function fakeUpdateOrganization(Class) {
+async function fakeUpdateOrganization() {
     await eventFaker_1.default.on('update-organization::v2020_12_25', ({ target, payload }) => {
-        const match = findOrgFromTarget(Class, target);
+        const match = findOrgFromTarget(target);
         if (payload?.name) {
             match.name = payload.name;
         }
@@ -516,11 +492,11 @@ async function fakeUpdateOrganization(Class) {
         };
     });
 }
-async function fakeListOrganization(Class) {
+async function fakeListOrganization() {
     await eventFaker_1.default.on('list-organizations::v2020_12_25', (targetAndPayload) => {
         const { payload } = targetAndPayload ?? {};
         return {
-            organizations: applyPaging(Class._fakedOrganizations, payload),
+            organizations: applyPaging(FakerTracker_1.default.fakedOrganizations, payload),
         };
     });
 }
@@ -531,12 +507,12 @@ function applyPaging(records, payload) {
     }
     return copy;
 }
-async function seedOrganizations(Class, total) {
-    await Class.seeder.seedOrganizations({
+async function seedOrganizations(total) {
+    await getFixturesForActiveTest().seeder.seedOrganizations({
         totalOrganizations: total,
     });
 }
-function seedRoles(Class, orgId) {
+function seedRoles(orgId) {
     const roles = spruce_core_schemas_1.BASE_ROLES_WITH_META.map((r) => ({
         id: (0, test_utils_2.generateId)(),
         name: `Faked ${r.name}`,
@@ -545,34 +521,34 @@ function seedRoles(Class, orgId) {
         organizationId: orgId,
         isPublic: r.slug === 'guest',
     }));
-    Class.fakedRoles.push(...roles);
+    FakerTracker_1.default.fakedRoles.push(...roles);
     return roles;
 }
-async function seedLocations(Class, total) {
-    await Class.seeder.seedAccount({
+async function seedLocations(total) {
+    await getFixturesForActiveTest().seeder.seedAccount({
         totalLocations: total,
     });
 }
 function buildSeeder(target) {
-    return async function seed(Class, total) {
-        if (Class._fakedLocations.length === 0) {
+    return async function seed(total) {
+        if (FakerTracker_1.default.fakedLocations.length === 0) {
             test_utils_1.assert.fail(`You gotta @seed('locations', 1) before seeding teammates!`);
         }
         //@ts-ignore
-        await Class.seeder[`seed${upperCaseFirst(target)}`]({
+        await getFixturesForActiveTest().seeder[`seed${upperCaseFirst(target)}`]({
             [`total${upperCaseFirst(target)}`]: total,
         });
     };
 }
-async function fakeWhoAmI(Class) {
+async function fakeWhoAmI() {
     await eventFaker_1.default.on('whoami::v2020_12_25', (targetAndPayload) => {
         const { source } = targetAndPayload ?? {};
         let { personId, proxyToken } = source ?? {};
         if (proxyToken) {
-            personId = Class.fakedProxyTokens.find((t) => t.token === proxyToken)?.personId;
+            personId = FakerTracker_1.default.fakedProxyTokens.find((t) => t.token === proxyToken)?.personId;
         }
-        const person = getPersonById(Class, personId, false);
-        const skill = Class.fakedSkills.find((s) => s.id === source?.skillId);
+        const person = getPersonById(personId, false);
+        const skill = FakerTracker_1.default.fakedSkills.find((s) => s.id === source?.skillId);
         return {
             auth: {
                 skill,
@@ -584,12 +560,12 @@ async function fakeWhoAmI(Class) {
         };
     });
 }
-async function fakeRegisterProxyToken(Class) {
+async function fakeRegisterProxyToken() {
     await eventFaker_1.default.on('register-proxy-token::v2020_12_25', (targeAndPayload) => {
         const { source } = targeAndPayload ?? {};
         const token = (0, test_utils_2.generateId)();
         if (source?.personId) {
-            Class.fakedProxyTokens.push({
+            FakerTracker_1.default.fakedProxyTokens.push({
                 personId: source.personId,
                 token,
             });
@@ -599,29 +575,29 @@ async function fakeRegisterProxyToken(Class) {
         };
     });
 }
-async function fakeAuthenticationEvents(Class) {
+async function fakeAuthenticationEvents() {
     await eventFaker_1.default.on('request-pin::v2020_12_25', ({ payload }) => {
         const formattedPhone = (0, schema_1.formatPhoneNumber)(payload.phone);
-        let person = Class.fakedPeople.find((p) => p.phone === formattedPhone);
+        let person = FakerTracker_1.default.fakedPeople.find((p) => p.phone === formattedPhone);
         if (!person) {
             person =
-                Class.fakedPerson?.phone === formattedPhone
-                    ? Class.fakedPerson
+                FakerTracker_1.default.fakedPerson?.phone === formattedPhone
+                    ? FakerTracker_1.default.fakedPerson
                     : {
                         id: (0, test_utils_2.generateId)(),
                         casualName: 'friend',
                         dateCreated: new Date().getTime(),
                         phone: (0, schema_1.formatPhoneNumber)(formattedPhone),
                     };
-            Class.fakedPeople.push(person);
+            FakerTracker_1.default.fakedPeople.push(person);
         }
         return {
             challenge: person.phone,
         };
     });
     await eventFaker_1.default.on('confirm-pin::v2020_12_25', ({ payload }) => {
-        const idx = Class.fakedPeople.findIndex((p) => p.phone === payload.challenge);
-        const person = Class.fakedPeople[idx];
+        const idx = FakerTracker_1.default.fakedPeople.findIndex((p) => p.phone === payload.challenge);
+        const person = FakerTracker_1.default.fakedPeople[idx];
         if (!person) {
             throw new SpruceError_1.default({
                 code: 'INVALID_PIN',
@@ -630,7 +606,7 @@ async function fakeAuthenticationEvents(Class) {
         //@ts-ignore
         delete person._challenge;
         const token = (0, test_utils_2.generateId)();
-        Class.fakedTokens.push({
+        FakerTracker_1.default.fakedTokens.push({
             personId: person.id,
             token,
         });
@@ -643,7 +619,7 @@ async function fakeAuthenticationEvents(Class) {
     });
     await eventFaker_1.default.on('authenticate::v2020_12_25', ({ payload }) => {
         const { token, apiKey, skillId } = payload ?? {};
-        let skill = Class.fakedSkills.find((s) => s.apiKey === apiKey && s.id === skillId);
+        let skill = FakerTracker_1.default.fakedSkills.find((s) => s.apiKey === apiKey && s.id === skillId);
         if (!skill &&
             apiKey &&
             skillId &&
@@ -666,12 +642,12 @@ async function fakeAuthenticationEvents(Class) {
                 },
             };
         }
-        const match = Class.fakedTokens.find((f) => f.token === token);
+        const match = FakerTracker_1.default.fakedTokens.find((f) => f.token === token);
         if (!match) {
             //@ts-ignore
             throw new SpruceError_1.default({ code: 'INVALID_AUTH_TOKEN' });
         }
-        const person = getPersonById(Class, match.personId);
+        const person = getPersonById(match.personId);
         return {
             type: 'authenticated',
             auth: {
@@ -680,14 +656,14 @@ async function fakeAuthenticationEvents(Class) {
         };
     });
 }
-async function fakeInstallEvents(Class) {
+async function fakeInstallEvents() {
     await eventFaker_1.default.on('is-skill-installed::v2020_12_25', ({ payload }) => {
         return {
-            isInstalled: !!Class.fakedInstalledSkills.find((i) => i.skillId === payload?.skillId),
+            isInstalled: !!FakerTracker_1.default.fakedInstalledSkills.find((i) => i.skillId === payload?.skillId),
         };
     });
     await eventFaker_1.default.on('install-skill::v2020_12_25', ({ target, payload }) => {
-        Class.fakedInstalledSkills.push({
+        FakerTracker_1.default.fakedInstalledSkills.push({
             orgId: target.organizationId,
             skillId: payload.skillId,
         });
@@ -695,7 +671,7 @@ async function fakeInstallEvents(Class) {
     });
     await eventFaker_1.default.on('list-skills::v2020_12_25', ({ payload }) => {
         const namespaces = payload?.namespaces;
-        const matches = Class.fakedSkills.filter((s) => (namespaces?.indexOf(s.slug) ?? 0) > -1);
+        const matches = FakerTracker_1.default.fakedSkills.filter((s) => (namespaces?.indexOf(s.slug) ?? 0) > -1);
         if (matches.length === 0) {
             throw new SpruceError_1.default({
                 //@ts-ignore
@@ -729,8 +705,8 @@ function singularToPlural(target) {
     return target + 's';
 }
 let shouldSkipNextReset = false;
-function findOrgFromTarget(Class, target) {
-    const match = Class._fakedOrganizations.find((o) => o.id === target.organizationId);
+function findOrgFromTarget(target) {
+    const match = FakerTracker_1.default.fakedOrganizations.find((o) => o.id === target.organizationId);
     if (!match) {
         throw new SpruceError_1.default({
             code: 'INVALID_TARGET',
@@ -742,3 +718,7 @@ function findOrgFromTarget(Class, target) {
 async function fakeRegisterListeners() {
     await eventFaker_1.default.on('register-listeners::v2020_12_25', async () => { });
 }
+function getFixturesForActiveTest() {
+    const Test = test_utils_1.SpruceTestResolver.getActiveTest();
+    return FakerTracker_1.default.getFixtures(Test.cwd);
+}