Lots of progress testing and fixing computation engine

app/imports/api/creature/computation/newEngine/buildComputation/tests/computeInactiveStatus.testFn.js

@@ -0,0 +1,144 @@
+import { buildComputationFromProps } from '/imports/api/creature/computation/newEngine/buildCreatureComputation.js';
+import { assert } from 'chai';
+import clean from '../../utility/cleanProp.testFn.js';
+
+export default function(){
+  let computation = buildComputationFromProps(testProperties);
+  const bySelf = (propId, note) => assertDeactivatedBySelf(computation, propId, note);
+  const byAncestor = (propId, note) => assertDeactivatedByAncestor(computation, propId, note);
+  const active = (propId, note) => assertActive(computation, propId, note);
+
+  // Buffs
+  bySelf('buffNotAppliedId');
+  byAncestor('buffNotAppliedChildId');
+  active('buffAppliedId');
+  active('buffAppliedChildId');
+
+  // Items
+  active('itemUnequippedId', 'Unequipped items should be active');
+  byAncestor('itemUnequippedChildId', 'Children of unequipped items should be inactive');
+  active('itemEquippedId');
+  active('itemEquippedChildId');
+
+  // Spells
+  active('spellPreparedId');
+  active('spellPreparedChildId');
+  active('spellAlwaysPreparedId');
+  active('spellAlwaysPreparedChildId');
+  bySelf('spellUnpreparedId');
+  byAncestor('spellUnpreparedChildId');
+
+  // Notes
+  active('NoteId', 'Notes should be active');
+  byAncestor('NoteChildId', 'children of notes should always be inactive');
+}
+
+function assertDeactivatedBySelf(computation, propId, note){
+  const prop = computation.propsById[propId];
+  assert.isTrue(prop.deactivatedBySelf, note);
+  assert.isTrue(prop.inactive, 'The property should be inactive');
+}
+
+function assertDeactivatedByAncestor(computation, propId, note){
+  const prop = computation.propsById[propId];
+  assert.isTrue(prop.deactivatedByAncestor, note);
+  assert.isTrue(prop.inactive, 'The property should be inactive');
+}
+
+function assertActive(computation, propId, note){
+  const prop = computation.propsById[propId];
+  assert.isNotTrue(prop.inactive, note);
+  assert.isNotTrue(prop.deactivatedBySelf);
+  assert.isNotTrue(prop.deactivatedBySelf);
+}
+
+var testProperties = [
+  // Buffs
+  clean({
+    _id: 'buffNotAppliedId',
+    type: 'buff',
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'buffNotAppliedChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'buffNotAppliedId'}],
+  }),
+  clean({
+    _id: 'buffAppliedId',
+    type: 'buff',
+    applied: true,
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'buffAppliedChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'buffAppliedId'}],
+  }),
+  // Items
+  clean({
+    _id: 'itemUnequippedId',
+    type: 'item',
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'itemUnequippedChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'itemUnequippedId'}],
+  }),
+  clean({
+    _id: 'itemEquippedId',
+    type: 'item',
+    equipped: true,
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'itemEquippedChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'itemEquippedId'}],
+  }),
+  // Spells
+  clean({
+    _id: 'spellPreparedId',
+    type: 'spell',
+    ancestors: [{id: 'charId'}],
+    prepared: true,
+  }),
+  clean({
+    _id: 'spellPreparedChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'spellPreparedId'}],
+  }),
+  clean({
+    _id: 'spellAlwaysPreparedId',
+    type: 'spell',
+    ancestors: [{id: 'charId'}],
+    alwaysPrepared: true,
+  }),
+  clean({
+    _id: 'spellAlwaysPreparedChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'spellAlwaysPreparedId'}],
+  }),
+  clean({
+    _id: 'spellUnpreparedId',
+    type: 'spell',
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'spellUnpreparedChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'spellUnpreparedId'}],
+  }),
+  // Notes
+  clean({
+    _id: 'NoteId',
+    type: 'note',
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'NoteChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'NoteId'}],
+  }),
+];

app/imports/api/creature/computation/newEngine/buildComputation/tests/computeSlotQuantityFilled.testFn.js

@@ -0,0 +1,36 @@
+import { buildComputationFromProps } from '/imports/api/creature/computation/newEngine/buildCreatureComputation.js';
+import { assert } from 'chai';
+import clean from '../../utility/cleanProp.testFn.js';
+
+export default function(){
+  const computation = buildComputationFromProps(testProperties);
+  const totalFilled = computation.propsById['slotId'].totalFilled;
+  assert.equal(totalFilled, 4);
+}
+
+var testProperties = [
+  // Slots
+  clean({
+    _id: 'slotId',
+    type: 'propertySlot',
+    ancestors: [{id: 'charId'}],
+  }),
+  // Children
+  clean({
+    _id: 'slotFillerId',
+    type: 'slotFiller',
+    slotQuantityFilled: 3,
+    slotFillerType: 'item',
+    ancestors: [{id: 'charId'}, {id: 'slotId'}],
+  }),
+  clean({
+    _id: 'slotChildId',
+    type: 'item',
+    ancestors: [{id: 'charId'}, {id: 'slotId'}],
+  }),
+  clean({
+    _id: 'slotGrandchildId',
+    type: 'effect',
+    ancestors: [{id: 'charId'}, {id: 'slotId'}, {id: 'slotChildId'}],
+  }),
+];

app/imports/api/creature/computation/newEngine/buildComputation/tests/computeToggleDependencies.testFn.js

@@ -0,0 +1,74 @@
+import { buildComputationFromProps } from '/imports/api/creature/computation/newEngine/buildCreatureComputation.js';
+import { assert } from 'chai';
+import clean from '../../utility/cleanProp.testFn.js';
+
+export default function(){
+  const computation = buildComputationFromProps(testProperties);
+  const hasLink = computation.dependencyGraph.hasLink;
+  assert.include(
+    computation.propsById['conditionToggleChildId']._computationDetails.toggleAncestors,
+    computation.propsById['conditionToggleId'],
+    'Children of toggles should store a reference to their toggle ancestor'
+  )
+  assert.isTrue(
+    !!hasLink('conditionToggleChildId', 'conditionToggleId'),
+    'Children of the condition toggle should depend on it'
+  );
+  assert.isTrue(
+    !!hasLink('conditionToggleGrandChildId', 'conditionToggleId'),
+    'Descendants of the condition toggle should depend on it'
+  );
+  assert.isFalse(
+    !!hasLink('disabledToggleId', 'disabledToggleChildId'),
+    'The dependency should not be reversed'
+  );
+  assert.isFalse(
+    !!hasLink('disabledToggleChildId', 'disabledToggleId'),
+    'Children of disabled toggle should not depend on it'
+  );
+  assert.isFalse(
+    !!hasLink('enabledToggleChildId', 'enabledToggleId'),
+    'Children of enabled toggle should not depend on it'
+  );
+}
+
+var testProperties = [
+  clean({
+    _id: 'enabledToggleId',
+    type: 'toggle',
+    enabled: true,
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'disabledToggleId',
+    type: 'toggle',
+    disabled: true,
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'conditionToggleId',
+    type: 'toggle',
+    ancestors: [{id: 'charId'}],
+  }),
+  // Children
+  clean({
+    _id: 'enabledToggleChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'enabledToggleId'}],
+  }),
+  clean({
+    _id: 'disabledToggleChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'disabledToggleId'}],
+  }),
+  clean({
+    _id: 'conditionToggleChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'conditionToggleId'}],
+  }),
+  clean({
+    _id: 'conditionToggleGrandChildId',
+    type: 'folder',
+    ancestors: [{id: 'charId'}, {id: 'conditionToggleId'}, {id: 'conditionToggleChildId'}],
+  }),
+];

app/imports/api/creature/computation/newEngine/buildComputation/tests/linkCalculationDependencies.testFn.js

@@ -0,0 +1,54 @@
+import { buildComputationFromProps } from '/imports/api/creature/computation/newEngine/buildCreatureComputation.js';
+import { assert } from 'chai';
+import clean from '../../utility/cleanProp.testFn.js';
+
+export default function(){
+  const computation = buildComputationFromProps(testProperties);
+  const hasLink = computation.dependencyGraph.hasLink;
+  assert.isTrue(
+    !!hasLink('childId', 'spellListId'),
+    'Ancestor references of parent in inline calculations should create dependency'
+  );
+  assert.isTrue(
+    !!hasLink('grandchildId', 'spellListId'),
+    'References to higher ancestor should create dependency'
+  );
+  assert.isTrue(
+    !!hasLink('grandchildId', 'strength'),
+    'Variable references create dependencies'
+  );
+  assert.isTrue(
+    !!hasLink('grandchildId', 'wisdom'),
+    'Variable references create dependencies even if the attributes don\'t exist'
+  );
+}
+
+var testProperties = [
+  clean({
+    _id: 'spellListId',
+    type: 'spellList',
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'childId',
+    type: 'spell',
+    description: {
+      text: 'DC {#spellList.dc} save or suck'
+    },
+    ancestors: [{id: 'charId'}, {id: 'spellListId'}],
+  }),
+  clean({
+    _id: 'grandchildId',
+    type: 'savingThrow',
+    dc: {
+      calculation: '#spellList.dc + strength + wisdom.modifier'
+    },
+    ancestors: [{id: 'charId'}, {id: 'spellListId'}, {id: 'childId'}],
+  }),
+  clean({
+    _id: 'strengthId',
+    type: 'attribute',
+    variableName: 'strength',
+    ancestors: [{id: 'charId'}],
+  }),
+];

app/imports/api/creature/computation/newEngine/buildComputation/tests/linkInventory.testFn.js

@@ -0,0 +1,81 @@
+import { buildComputationFromProps } from '/imports/api/creature/computation/newEngine/buildCreatureComputation.js';
+import { assert } from 'chai';
+import clean from '../../utility/cleanProp.testFn.js';
+
+export default function(){
+  const computation = buildComputationFromProps(testProperties);
+  const hasLink = computation.dependencyGraph.hasLink;
+  
+  assert.isTrue(
+    !!hasLink('weightEquipment', 'equippedAttunedItemId'),
+    'weight of equipment depends on equipped items'
+  );
+  assert.isTrue(
+    !!hasLink('valueEquipment', 'equippedAttunedItemId'),
+    'value of equipment depends on equipped items'
+  );
+  assert.isTrue(
+    !!hasLink('weightTotal', 'equippedAttunedItemId'),
+    'weightTotal depends on equipped items'
+  );
+  assert.isTrue(
+    !!hasLink('valueTotal', 'equippedAttunedItemId'),
+    'valueTotal depends on equipped items'
+  );
+  assert.isTrue(
+    !!hasLink('weightCarried', 'equippedAttunedItemId'),
+    'weightCarried depends on equipped items'
+  );
+  assert.isTrue(
+    !!hasLink('valueCarried', 'equippedAttunedItemId'),
+    'valueCarried depends on equipped items'
+  );
+  assert.isTrue(
+    !!hasLink('weightCarried', 'containerId'),
+    'weightCarried depends on top level containers'
+  );
+  assert.isTrue(
+    !!hasLink('valueCarried', 'containerId'),
+    'valueCarried depends on top level containers'
+  );
+  assert.isFalse(
+    !!hasLink('weightCarried', 'childContainerId'),
+    'weightCarried does not depend on nested containers'
+  );
+  assert.isFalse(
+    !!hasLink('valueCarried', 'childContainerId'),
+    'valueCarried does not depend on nested containers'
+  );
+}
+
+var testProperties = [
+  clean({
+    _id: 'equippedAttunedItemId',
+    type: 'item',
+    equipped: true,
+    attuned: true,
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'containerId',
+    type: 'container',
+    carried: true,
+    ancestors: [{id: 'charId'}],
+  }),
+  clean({
+    _id: 'childContainerId',
+    type: 'container',
+    carried: true,
+    ancestors: [{id: 'charId'}, {id: 'containerId'}],
+  }),
+  clean({
+    _id: 'childItemId',
+    type: 'item',
+    ancestors: [{id: 'charId'}, {id: 'containerId'}],
+  }),
+  clean({
+    _id: 'grandchildItemId',
+    type: 'item',
+    ancestors: [{id: 'charId'}, {id: 'containerId'}, {id: 'childContainerId'}],
+  }),
+];

app/imports/api/creature/computation/newEngine/buildComputation/tests/linkTypeDependencies.testfn.js

@@ -0,0 +1,27 @@
+import { buildComputationFromProps } from '/imports/api/creature/computation/newEngine/buildCreatureComputation.js';
+import { assert } from 'chai';
+import clean from '../../utility/cleanProp.testFn.js';
+
+export default function(){
+  const computation = buildComputationFromProps(testProperties);
+  const getLink = computation.dependencyGraph.hasLink;
+  const getNode = computation.dependencyGraph.getNode;
+
+  assert.equal(
+    getLink('strength', 'strengthId').data, 'definition',
+    'Links variable names to props that define them'
+  );
+  assert.exists(
+    getNode('strength'),
+    'Creates variable name nodes when attributes define them'
+  );
+}
+
+var testProperties = [
+  clean({
+    _id: 'strengthId',
+    type: 'attribute',
+    variableName: 'strength',
+    ancestors: [{id: 'charId'}],
+  }),
+];