Started splitting engine tests into individual files and testing action props

app/imports/api/engine/action/functions/actionEngineTest.testFn.ts

@@ -0,0 +1,150 @@
+import { assert } from 'chai';
+import '/imports/api/simpleSchemaConfig.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { propsFromForest } from '/imports/api/properties/tests/propTestBuilder.testFn';
+import Creatures from '/imports/api/creature/creatures/Creatures';
+import CreatureVariables from '/imports/api/creature/creatures/CreatureVariables';
+import computeCreature from '/imports/api/engine/computeCreature';
+import { loadCreature } from '/imports/api/engine/loadCreatures';
+import EngineActions, { EngineAction } from '/imports/api/engine/action/EngineActions';
+import { applyAction } from '/imports/api/engine/action/functions/applyAction';
+import { LogContent, Mutation, Removal, Update } from '/imports/api/engine/action/tasks/TaskResult';
+
+/**
+ * Removes all creatures, properties, and creatureVariable documents from the database
+ */
+export async function removeAllCreaturesAndProps() {
+  return Promise.all([
+    CreatureProperties.removeAsync({}),
+    Creatures.removeAsync({}),
+    CreatureVariables.removeAsync({}),
+  ]);
+}
+
+/**
+ * Creates a test creature with all its props computed and loaded into memory
+ * You may need to set the timeout of a test higher for this function to conclude
+ * as it is inserting and reading potentially many database documents
+ */
+export async function createTestCreature(creature: TestCreature) {
+  const dummySubscription = Tracker.autorun(() => undefined)
+  await Creatures.insertAsync({
+    _id: creature._id,
+    name: creature.name || 'Test Creature',
+    owner: Random.id(),
+    dirty: true,
+  });
+  const propsInserted = propsFromForest(creature.props, creature._id).map(prop => {
+    return CreatureProperties.insertAsync(prop);
+  });
+  await Promise.all(propsInserted);
+  loadCreature(creature._id, dummySubscription);
+  await computeCreature(creature._id,);
+}
+
+type TestCreature = {
+  _id: string;
+  name?: string;
+  props: any[];
+}
+
+/**
+ * A list of 100 random Ids
+ */
+export const randomIds = new Array(100).fill(undefined).map(() => Random.id());
+
+/**
+ * Creates a new Engine Action and applies the specified creature property
+ * @param propId The _id of the property, any property that the engine can apply will work
+ * @param userInputFn A function that simulates user input
+ * @returns The Engine Action with mutations resulting from running the action
+ */
+export async function runActionById(propId, targetIds?, userInputFn = () => 0) {
+  const prop = await CreatureProperties.findOneAsync(propId);
+  const actionId = await createAction(prop, targetIds);
+  const action = await EngineActions.findOneAsync(actionId);
+  if (!action) throw 'Action is expected to exist';
+  await applyAction(action, userInputFn, { simulate: true });
+  return action;
+}
+
+/**
+ * Creates and inserts a new Engine Action into the database
+ * @param prop The property to start applying
+ * @param targetIds A list of target ids
+ * @returns Promise< id of the inserted Engine Action >
+ */
+function createAction(prop: any, targetIds?: string[]) {
+  const action: EngineAction = {
+    creatureId: prop.root.id,
+    rootPropId: prop._id,
+    results: [],
+    taskCount: 0,
+    targetIds,
+  };
+  return EngineActions.insertAsync(action);
+}
+
+/**
+ * Get all the mutations in the results of an engineAction
+ */
+export function allMutations(action: EngineAction) {
+  const mutations: Mutation[] = [];
+  action.results.forEach(result => {
+    result.mutations.forEach(mutation => {
+      mutations.push(mutation);
+    });
+  });
+  return mutations;
+}
+
+/**
+ * Get all the updates in all mutations in the result of an Engine Action
+ */
+export function allUpdates(action: EngineAction) {
+  const updates: Update[] = [];
+  allMutations(action).forEach(mutation => {
+    mutation.updates?.forEach(update => {
+      updates.push(update);
+    });
+  });
+  return updates;
+}
+/**
+ * Get all the inserts in all mutations in the result of an Engine Action
+ */
+export function allInserts(action: EngineAction) {
+  const inserts: any[] = [];
+  allMutations(action).forEach(mutation => {
+    mutation.inserts?.forEach(update => {
+      inserts.push(update);
+    });
+  });
+  return inserts;
+}
+
+/**
+ * Get all the removals in all mutations in the result of an Engine Action
+ */
+export function allRemovals(action: EngineAction) {
+  const removals: Removal[] = [];
+  allMutations(action).forEach(mutation => {
+    mutation.removals?.forEach(update => {
+      removals.push(update);
+    });
+  });
+  return removals
+}
+
+/**
+ * Get all the log content in all mutations in the result of an Engine Action
+ */
+export function allLogContent(action: EngineAction) {
+  const contents: LogContent[] = [];
+  allMutations(action).forEach(mutation => {
+    mutation.contents?.forEach(logContent => {
+      contents.push(logContent);
+    });
+  });
+  return contents;
+}

app/imports/api/engine/action/functions/spendResources.ts

@@ -30,7 +30,7 @@ export default async function spendResources(
   if (prop.resources?.attributesConsumed?.length) {
     for (const att of prop.resources.attributesConsumed) {
       const scope = await getEffectiveActionScope(action);
-      const statToDamage = getFromScope(att.variableName, scope);
+      const statToDamage = await getFromScope(att.variableName, scope);
       await recalculateCalculation(att.quantity, action, 'reduce');
       await applyTask(action, {
         prop,