jschaufuss/DiceCloud
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed failing tests

Browse Source
This commit is contained in:
ThaumRystra
2025-01-16 16:24:56 +02:00
parent a2d2f43bed
commit 0bf8fdc6d3
79 changed files with 268 additions and 649 deletions
Download Patch File Download Diff File Expand all files Collapse all files

448
app/imports/api/engine/action/ActionEngine.test.ts
View File

@@ -1,448 +0,0 @@
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 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, Removal, Update } from '/imports/api/engine/action/tasks/TaskResult';
import inputProvider from './functions/userInput/inputProviderForTests.testFn';
import { removeAllCreaturesAndProps } from '/imports/api/engine/action/functions/actionEngineTest.testFn';
const creatureId = Random.id();
const targetId = Random.id();
describe('Interrupt action system', function () {
const dummySubscription = Tracker.autorun(() => undefined)
this.timeout(8000);
before(async function () {
// Remove old data
await removeAllCreaturesAndProps();
// Add creatures
await Promise.all([
Creatures.insertAsync({
_id: creatureId,
name: 'action test creature',
owner: Random.id(),
dirty: true,
type: 'pc',
readers: [],
writers: [],
public: false,
settings: {},
}),
Creatures.insertAsync({
_id: targetId,
name: 'action test creature',
owner: Random.id(),
dirty: true,
type: 'pc',
readers: [],
writers: [],
public: false,
settings: {},
})
]);
// Add test props
await insertActionTestProps();
// Compute before load or we might run tests before the computation changes reflect in the cache
computeCreature(creatureId);
computeCreature(targetId);
loadCreature(creatureId, dummySubscription);
});
after(function () {
dummySubscription.stop();
});
it('writes notes to the log', async function () {
const action = await runActionById(note1Id);
assert.deepEqual(
allLogContent(action),
[{ value: 'Note 1 summary. 1 + 1 = 2' }]
);
});
it('Applies children of folders', async function () {
const action = await runActionById(folderId);
assert.deepEqual(
allLogContent(action),
[{ value: 'child of folder' }]
);
});
it('Applies the children of if branches', async function () {
let action = await runActionById(ifTruthyBranchId);
assert.deepEqual(
allLogContent(action),
[{ value: 'child of if branch' }]
);
action = await runActionById(ifFalsyBranchId);
assert.deepEqual(
allLogContent(action),
[]
);
});
it('Applies the children of index branches', async function () {
const action = await runActionById(indexBranchId);
assert.deepEqual(
allLogContent(action),
[{ value: 'child 2 of index branch' }]
);
});
it('Gets choices from choice branches', async function () {
const action = await runActionById(choiceBranchId);
assert.deepEqual(
allLogContent(action),
[{ value: 'child 1 of choice branch' }]
);
});
it('Applies adjustments', async function () {
let action = await runActionById(adjustmentSetId);
assert.deepEqual(
allUpdates(action),
[{
propId: adjustedStatId,
type: 'attribute',
set: { damage: 5, value: 3 },
}],
'Applying set adjustments should return the correct updates'
);
action = await runActionById(adjustmentIncrementId)
assert.deepEqual(
allUpdates(action),
[{
propId: adjustedStatId,
type: 'attribute',
inc: { damage: 2, value: -2 }, // damage goes up by 2, value down by 2
}],
'Applying increment adjustments should return the correct updates'
);
});
it('Applies rolls', async function () {
const action = await runActionById(rollId);
assert.deepEqual(allLogContent(action), [
{
name: 'New Roll',
value: '7d1 [1, 1, 1, 1, 1, 1, 1] + 9\n**16**',
inline: true,
}, {
value: 'rollVar: 16'
}
]);
});
it('Applies buffs', async function () {
const action = await runActionById(buffId);
const inserts = allInserts(action);
const newIds = inserts.map(p => p._id);
assert.notEqual(buffId, newIds[0]);
assert.deepEqual(inserts, [
{
_id: newIds[0],
left: 43,
parentId: null,
right: 48,
root: {
collection: 'creatures',
id: creatureId,
},
tags: [],
target: 'self',
type: 'buff',
}, {
_id: newIds[1],
attributeType: 'stat',
baseValue: {
calculation: '13 + buffSourceStat + 7',
},
left: 44,
parentId: newIds[0],
right: 45,
root: {
collection: 'creatures',
id: creatureId,
},
tags: [],
type: 'attribute',
variableName: 'buffStat',
}, {
_id: newIds[2],
left: 46,
parentId: newIds[0],
removeAll: true,
right: 47,
root: {
collection: 'creatures',
id: creatureId,
},
tags: [],
target: 'self',
targetParentBuff: true,
type: 'buffRemover',
}
]);
});
it('Removes parent buffs', async function () {
const action = await runActionById(removeParentBuffId);
assert.deepEqual(allRemovals(action), [
{ propId: buffId }
]);
});
it('Removes all buffs by tag', async function () {
const action = await runActionById(removeTaggedBuffsId);
assert.deepEqual(allRemovals(action), [
{ propId: taggedBuffId },
{ propId: secondTaggedBuffId },
]);
});
it('Removes a single buff by tag', async function () {
const action = await runActionById(removeOneTaggedBuffId);
assert.deepEqual(allRemovals(action), [
{ propId: taggedBuffId },
]);
});
});
function createAction(prop, targetIds?) {
const action: EngineAction = {
creatureId: prop.root.id,
results: [],
taskCount: 0,
task: {
prop,
targetIds,
}
};
return EngineActions.insertAsync(action);
}
async function runActionById(propId) {
const prop = await CreatureProperties.findOneAsync(propId);
const actionId = await createAction(prop);
const action = await EngineActions.findOneAsync(actionId);
if (!action) throw 'Action is expected to exist';
await applyAction(action, inputProvider, { simulate: true });
return action;
}
function allUpdates(action: EngineAction) {
const updates: Update[] = [];
action.results.forEach(result => {
result.mutations.forEach(mutation => {
mutation.updates?.forEach(update => {
updates.push(update);
});
});
});
return updates;
}
function allInserts(action: EngineAction) {
const inserts: any[] = [];
action.results.forEach(result => {
result.mutations.forEach(mutation => {
mutation.inserts?.forEach(update => {
inserts.push(update);
});
});
});
return inserts;
}
function allRemovals(action: EngineAction) {
const removals: Removal[] = [];
action.results.forEach(result => {
result.mutations.forEach(mutation => {
mutation.removals?.forEach(update => {
removals.push(update);
});
});
});
return removals
}
function allLogContent(action: EngineAction) {
const contents: LogContent[] = [];
action.results.forEach(result => {
result.mutations.forEach(mutation => {
mutation.contents?.forEach(logContent => {
contents.push(logContent);
});
});
});
return contents;
}
let note1Id, folderId, ifTruthyBranchId, ifFalsyBranchId, indexBranchId, choiceBranchId,
adjustedStatId, adjustmentIncrementId, adjustmentSetId, rollId, buffId,
removeParentBuffId, removeTaggedBuffsId, removeOneTaggedBuffId, taggedBuffId, secondTaggedBuffId;
const propForest = [
// Apply a simple note
{
_id: note1Id = Random.id(),
type: 'note',
summary: {
text: 'Note 1 summary. 1 + 1 = {1 + 1}'
},
},
// Apply a folder with a note inside
{
_id: folderId = Random.id(),
type: 'folder',
children: [{ type: 'note', summary: { text: 'child of folder' } }],
},
// Apply an if branch with a truthy condition
{
_id: ifTruthyBranchId = Random.id(),
type: 'branch',
branchType: 'if',
condition: { calculation: '1 + 1' },
children: [{ type: 'note', summary: { text: 'child of if branch' } }],
},
// Apply an if branch with a falsy condition
{
_id: ifFalsyBranchId = Random.id(),
type: 'branch',
branchType: 'if',
condition: { calculation: '1 - 1' },
children: [{ type: 'note', summary: { text: 'child of if branch' } }],
},
// Apply an index branch
{
_id: indexBranchId = Random.id(),
type: 'branch',
branchType: 'index',
condition: { calculation: '1 + 1' },
children: [
{ type: 'note', summary: { text: 'child 1 of index branch' } },
{ type: 'note', summary: { text: 'child 2 of index branch' } },
{ type: 'note', summary: { text: 'child 3 of index branch' } },
],
},
// Apply a choice branch
{
_id: choiceBranchId = Random.id(),
type: 'branch',
branchType: 'choice',
children: [
{ type: 'note', summary: { text: 'child 1 of choice branch' } },
{ type: 'note', summary: { text: 'child 2 of choice branch' } },
{ type: 'note', summary: { text: 'child 3 of choice branch' } },
],
},
// Apply adjustments
{
_id: adjustedStatId = Random.id(),
type: 'attribute',
attributeType: 'stat',
variableName: 'adjustedStat',
baseValue: { calculation: '8' },
}, {
_id: adjustmentSetId = Random.id(),
type: 'adjustment',
stat: 'adjustedStat',
operation: 'set',
amount: { calculation: '3' },
target: 'self',
children: [
{ type: 'note', summary: { text: 'adjustment set applied' } },
],
}, {
_id: adjustmentIncrementId = Random.id(),
type: 'adjustment',
stat: 'adjustedStat',
operation: 'increment',
amount: { calculation: '2' },
target: 'self',
children: [
{ type: 'note', summary: { text: 'adjustment increment applied' } },
],
},
// Apply buffs
{
_id: Random.id(),
type: 'attribute',
attributeType: 'stat',
variableName: 'buffSourceStat',
baseValue: { calculation: '13' },
}, {
_id: buffId = Random.id(),
type: 'buff',
target: 'self',
children: [
{
_id: Random.id(),
type: 'attribute',
attributeType: 'stat',
variableName: 'buffStat',
baseValue: { calculation: 'buffSourceStat + ~target.buffSourceStat + 7' },
}, {
_id: removeParentBuffId = Random.id(),
type: 'buffRemover',
target: 'self',
targetParentBuff: true,
},
],
},
// Extra buffs with and without tags
{
_id: taggedBuffId = Random.id(),
name: 'Tagged Buff',
type: 'buff',
tags: ['buff tag', 'other tag']
}, {
_id: secondTaggedBuffId = Random.id(),
name: 'Tagged buff 2',
type: 'buff',
tags: ['buff tag', 'yet another tag']
}, {
_id: Random.id(),
name: 'Untagged buff',
type: 'buff',
tags: ['other tag']
},
// Remove buffs by tag
{
_id: removeTaggedBuffsId = Random.id(),
type: 'buffRemover',
target: 'self',
removeAll: true,
targetTags: 'buff tag',
}, {
_id: removeOneTaggedBuffId = Random.id(),
type: 'buffRemover',
target: 'self',
removeAll: false,
targetTags: 'buff tag',
},
// Apply rolls
{
_id: rollId = Random.id(),
type: 'roll',
// Roll d1's because it's a pain to test random numbers
roll: { calculation: '1 + 3 + 7d1 + 5' },
variableName: 'rollVar',
children: [
{ type: 'note', summary: { text: 'rollVar: {rollVar}' } }
]
}
];
const targetPropForest = [
{
type: 'attribute',
attributeType: 'stat',
variableName: 'armor',
baseValue: { calculation: '10' },
}
];
function insertActionTestProps() {
const promises = propsFromForest(propForest, creatureId).map(prop => {
return CreatureProperties.insertAsync(prop);
});
propsFromForest(targetPropForest, targetId).forEach(prop => {
promises.push(CreatureProperties.insertAsync(prop));
});
return Promise.all(promises);
}

14
app/imports/api/engine/action/EngineActions.ts
View File

@@ -20,18 +20,18 @@ export interface EngineAction {
const ActionSchema = new SimpleSchema({
creatureId: {
type: String,
regEx: SimpleSchema.RegEx.Id,
max: 32,
// @ts-expect-error index not defined
index: 1,
},
rootPropId: {
type: String,
regEx: SimpleSchema.RegEx.Id,
max: 32,
optional: true,
},
tabletopId: {
type: String,
regEx: SimpleSchema.RegEx.Id,
max: 32,
optional: true,
// @ts-expect-error index not defined
index: 1,
@@ -53,7 +53,7 @@ const ActionSchema = new SimpleSchema({
// Should re-run the action identically from this point
'results.$.propId': {
type: String,
regEx: SimpleSchema.RegEx.Id,
max: 32,
},
'results.$.targetIds': {
type: Array,
@@ -61,7 +61,7 @@ const ActionSchema = new SimpleSchema({
},
'results.$.targetIds.$': {
type: String,
regEx: SimpleSchema.RegEx.Id,
max: 32,
},
// Changes that override the local scope
'results.$.scope': {
@@ -94,7 +94,7 @@ const ActionSchema = new SimpleSchema({
},
'results.$.mutations.$.targetIds.$': {
type: String,
regEx: SimpleSchema.RegEx.Id,
max: 32,
},
'results.$.mutations.$.updates': {
type: Array,
@@ -105,7 +105,7 @@ const ActionSchema = new SimpleSchema({
},
'results.$.mutations.$.updates.$.propId': {
type: String,
regEx: SimpleSchema.RegEx.Id,
max: 32,
},
// Required, because CreatureProperties.update requires a selector of { type }
'results.$.mutations.$.updates.$.type': {

9
app/imports/api/engine/action/applyProperties/applyAdjustmentProperty.test.ts
View File

@@ -4,14 +4,15 @@ import {
createTestCreature,
getRandomIds,
removeAllCreaturesAndProps,
runActionById
runActionById,
TestCreature
} from '/imports/api/engine/action/functions/actionEngineTest.testFn';
const [
creatureId, targetCreatureId, targetCreature2Id, adjustmentToTargetId, adjustmentToSelfId, targetCreatureStrengthId, targetCreature2StrengthId, selfDexterityId
] = getRandomIds(100);
const actionTestCreature = {
const actionTestCreature: TestCreature = {
_id: creatureId,
props: [
{
@@ -41,7 +42,7 @@ const actionTestCreature = {
],
}
const actionTargetCreature = {
const actionTargetCreature: TestCreature = {
_id: targetCreatureId,
props: [
{
@@ -54,7 +55,7 @@ const actionTargetCreature = {
]
}
const actionTargetCreature2 = {
const actionTargetCreature2: TestCreature = {
_id: targetCreature2Id,
props: [
{

15
app/imports/api/engine/action/functions/actionEngineTest.testFn.ts
View File

@@ -1,10 +1,10 @@
import '/imports/api/simpleSchemaConfig.js';
import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
import { propsFromForest } from '/imports/api/properties/tests/propTestBuilder.testFn';
import propsFromForest, { ForestProp } from '/imports/api/engine/computation/utility/propsFromForest.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 { loadCreature, unloadAllCreatures } 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';
@@ -14,6 +14,7 @@ import inputProvider from './userInput/inputProviderForTests.testFn';
*/
export async function removeAllCreaturesAndProps() {
if (Meteor.isServer) {
unloadAllCreatures();
return Promise.all([
CreatureProperties.removeAsync({}),
Creatures.removeAsync({}),
@@ -38,7 +39,7 @@ export async function createTestCreature(creature: TestCreature) {
name: creature.name || 'Test Creature',
owner: Random.id(),
dirty: true,
});
} as any);
const propsInserted = propsFromForest(creature.props, creature._id).map(prop => {
return CreatureProperties.insertAsync(prop);
});
@@ -47,16 +48,16 @@ export async function createTestCreature(creature: TestCreature) {
await computeCreature(creature._id,);
}
type TestCreature = {
export type TestCreature = {
_id: string;
name?: string;
props: any[];
props: ForestProp[];
}
/**
* get a list of random Ids
*/
export const getRandomIds = (count) => new Array(count).fill(undefined).map(() => Random.id());
export const getRandomIds = (count: number) => new Array(count).fill(undefined).map(() => Random.id());
/**
* Creates a new Engine Action and applies the specified creature property
@@ -64,7 +65,7 @@ export const getRandomIds = (count) => new Array(count).fill(undefined).map(() =
* @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?, userInput = inputProvider) {
export async function runActionById(propId: string, targetIds?: string[], userInput = inputProvider) {
const prop = await CreatureProperties.findOneAsync(propId);
const actionId = await createAction(prop, targetIds);
const action = await EngineActions.findOneAsync(actionId);