Nick SzaunigandClaude Opus 5.5
02eb16924e
- Automation rules propose suggestions instead of creating tasks; notify per rule config; corrected varroa measurements refresh or resolve their suggestion - Inspection values can be taken over into the colony card (occupiedFrames 0-40, strength deprecated); warning counts use the same visibility rule as the notification list - Biotech chains: swarm check after queen cells, queen acceptance check, split schedules (raise own, queen cell, queen) - Season autopilot core with A1 inspection due, A2 varroa measurement, A3 recheck after treatment; colony sync and daily step - Frontend: suggestions page with groups, bulk accept, undo, paging, focus management and permission gating - Frontend: varroa traffic light from seasonal bands, sample size, one range request for the colony chart - Notifications: mark-read answers 404 for rows the user may no longer see Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
531 lines
18 KiB
TypeScript
531 lines
18 KiB
TypeScript
import { INestApplication } from '@nestjs/common';
|
|
import * as bcrypt from 'bcryptjs';
|
|
import request from 'supertest';
|
|
import { App } from 'supertest/types';
|
|
import { PrismaService } from '../src/prisma/prisma.service';
|
|
import { AutomationTriggerType, Prisma } from '../generated/prisma';
|
|
import { createTestApp } from './utils/create-test-app';
|
|
import { login } from './utils/api';
|
|
import { drainDomainEvents } from './utils/domain-events';
|
|
import { DEFAULT_RULES } from '../src/automation/rule-config';
|
|
|
|
interface AutomationRuleBody {
|
|
id: string;
|
|
triggerType: string;
|
|
active: boolean;
|
|
config: Record<string, unknown> | null;
|
|
actionTemplate: string | null;
|
|
}
|
|
|
|
describe('Automation rules (e2e)', () => {
|
|
let app: INestApplication<App>;
|
|
let prisma: PrismaService;
|
|
const adminEmail = `automation-e2e-admin-${Date.now()}@example.com`;
|
|
const staffEmail = `automation-e2e-staff-${Date.now()}@example.com`;
|
|
const password = 'SuperSecret123!';
|
|
let adminId: string;
|
|
let staffId: string;
|
|
let adminToken: string;
|
|
let staffToken: string;
|
|
let apiaryId: string;
|
|
let colonyId: string;
|
|
let varroaRuleId: string;
|
|
let swarmRuleId: string;
|
|
|
|
/**
|
|
* Records an inspection or varroa measurement and runs the handlers of
|
|
* its event - the rules evaluate there, not in the request.
|
|
*/
|
|
async function record(path: string, body: object): Promise<string> {
|
|
const response = await request(app.getHttpServer())
|
|
.post(`/api/v1/${path}`)
|
|
.set(
|
|
'Authorization',
|
|
`Bearer ${path === 'inspections' ? staffToken : adminToken}`,
|
|
)
|
|
.send({ colonyId, date: new Date().toISOString(), ...body })
|
|
.expect(201);
|
|
const id = (response.body as { id: string }).id;
|
|
await drainDomainEvents(app, [id]);
|
|
return id;
|
|
}
|
|
|
|
const suggestionsOf = (ruleKey?: AutomationTriggerType) =>
|
|
prisma.suggestion.findMany({
|
|
where: { colonyId, source: 'RULE', ...(ruleKey ? { ruleKey } : {}) },
|
|
orderBy: { createdAt: 'asc' },
|
|
});
|
|
// Other sources (the season autopilot) propose on the same events.
|
|
const ruleSuggestionCount = () =>
|
|
prisma.suggestion.count({ where: { colonyId, source: 'RULE' } });
|
|
const tasksOfColony = () =>
|
|
prisma.task.count({ where: { relatedId: colonyId } });
|
|
// Settles every open suggestion, so the one-open-thing guard cannot be
|
|
// what keeps a new one from appearing - only the missing evaluation may.
|
|
const dismissOpen = () =>
|
|
prisma.suggestion.updateMany({
|
|
where: { colonyId, status: 'OPEN' },
|
|
data: { status: 'DISMISSED' },
|
|
});
|
|
|
|
beforeAll(async () => {
|
|
app = await createTestApp();
|
|
prisma = app.get(PrismaService);
|
|
|
|
const passwordHash = await bcrypt.hash(password, 12);
|
|
const admin = await prisma.user.create({
|
|
data: {
|
|
email: adminEmail,
|
|
passwordHash,
|
|
name: 'Automation E2E Admin',
|
|
role: { connect: { key: 'ADMIN' } },
|
|
},
|
|
});
|
|
adminId = admin.id;
|
|
const staff = await prisma.user.create({
|
|
data: {
|
|
email: staffEmail,
|
|
passwordHash,
|
|
name: 'Automation E2E Staff',
|
|
role: { connect: { key: 'STAFF' } },
|
|
},
|
|
});
|
|
staffId = staff.id;
|
|
adminToken = (await login(app, adminEmail, password)).accessToken;
|
|
staffToken = (await login(app, staffEmail, password)).accessToken;
|
|
|
|
const apiary = await prisma.apiary.create({
|
|
data: { name: `Automation Stand ${Date.now()}` },
|
|
});
|
|
apiaryId = apiary.id;
|
|
const colony = await prisma.colony.create({
|
|
data: {
|
|
code: `AUTO-${Date.now()}`,
|
|
apiaryId,
|
|
colonyType: 'PRODUCTION_COLONY',
|
|
},
|
|
});
|
|
colonyId = colony.id;
|
|
});
|
|
|
|
afterAll(async () => {
|
|
// Rule suggestions and the rules' own entries are written without a
|
|
// user - they are not covered by the userId cleanup below. Deliveries go
|
|
// with their event (ON DELETE CASCADE).
|
|
const suggestionIds = (
|
|
await prisma.suggestion.findMany({
|
|
where: { colonyId },
|
|
select: { id: true },
|
|
})
|
|
).map((suggestion) => suggestion.id);
|
|
const byColony = { where: { colonyId }, select: { id: true } };
|
|
const recordIds = [
|
|
...(await prisma.inspection.findMany(byColony)),
|
|
...(await prisma.varroaMeasurement.findMany(byColony)),
|
|
].map((record) => record.id);
|
|
await prisma.auditLog.deleteMany({
|
|
where: {
|
|
OR: [
|
|
{ entityType: 'Suggestion', entityId: { in: suggestionIds } },
|
|
{
|
|
entityType: 'AutomationRule',
|
|
afterData: { path: ['relatedId'], equals: colonyId },
|
|
},
|
|
],
|
|
},
|
|
});
|
|
await prisma.domainEvent.deleteMany({
|
|
where: { aggregateId: { in: recordIds } },
|
|
});
|
|
await prisma.calendarSyncOutboxEntry.deleteMany({
|
|
where: { sourceId: { in: recordIds } },
|
|
});
|
|
await prisma.notification.deleteMany({
|
|
where: { relatedType: 'Suggestion', relatedId: { in: suggestionIds } },
|
|
});
|
|
await prisma.suggestion.deleteMany({ where: { colonyId } });
|
|
await prisma.varroaMeasurement.deleteMany({ where: { colonyId } });
|
|
await prisma.swarmControlCheck.deleteMany({ where: { colonyId } });
|
|
await prisma.inspection.deleteMany({ where: { colonyId } });
|
|
await prisma.colony.deleteMany({ where: { id: colonyId } });
|
|
await prisma.apiary.deleteMany({ where: { id: apiaryId } });
|
|
await prisma.refreshToken.deleteMany({
|
|
where: { userId: { in: [adminId, staffId] } },
|
|
});
|
|
await prisma.auditLog.deleteMany({
|
|
where: { userId: { in: [adminId, staffId] } },
|
|
});
|
|
await prisma.user.deleteMany({ where: { id: { in: [adminId, staffId] } } });
|
|
await app.close();
|
|
});
|
|
|
|
it('rejects a non-admin listing automation rules', () => {
|
|
return request(app.getHttpServer())
|
|
.get('/api/v1/automation-rules')
|
|
.set('Authorization', `Bearer ${staffToken}`)
|
|
.expect(403);
|
|
});
|
|
|
|
it('seeds every fixed trigger for an admin', async () => {
|
|
const response = await request(app.getHttpServer())
|
|
.get('/api/v1/automation-rules')
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.expect(200);
|
|
const rules = response.body as AutomationRuleBody[];
|
|
const triggerTypes = rules.map((rule) => rule.triggerType).sort();
|
|
expect(triggerTypes).toEqual(
|
|
[...Object.values(AutomationTriggerType)].sort(),
|
|
);
|
|
const varroaRule = rules.find(
|
|
(rule) => rule.triggerType === 'VARROA_THRESHOLD',
|
|
);
|
|
expect(varroaRule).toBeDefined();
|
|
varroaRuleId = varroaRule!.id;
|
|
swarmRuleId = rules.find(
|
|
(rule) => rule.triggerType === 'SWARM_MOOD_HIGH',
|
|
)!.id;
|
|
});
|
|
|
|
const NEW_TRIGGERS = [
|
|
'INSPECTION_INTERVAL',
|
|
'QUEEN_CELLS_SWARM_CHECK',
|
|
'QUEEN_ACCEPTANCE_CHECK',
|
|
'SPLIT_SCHEDULE',
|
|
'COLONY_ENDED_CLEANUP',
|
|
'WITHDRAWAL_ENDED',
|
|
'HONEY_WATER_CONTENT',
|
|
'SEASON_AUTOPILOT',
|
|
'PHENOLOGY',
|
|
] as const;
|
|
|
|
it('lists the nine new rules with their defaults', async () => {
|
|
const response = await request(app.getHttpServer())
|
|
.get('/api/v1/automation-rules')
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.expect(200);
|
|
const rules = response.body as AutomationRuleBody[];
|
|
|
|
for (const trigger of NEW_TRIGGERS) {
|
|
const rule = rules.find((entry) => entry.triggerType === trigger);
|
|
expect(rule).toBeDefined();
|
|
expect(rule!.active).toBe(DEFAULT_RULES[trigger].active ?? true);
|
|
expect(rule!.config).toEqual(DEFAULT_RULES[trigger].config);
|
|
expect(rule!.actionTemplate).toBe('');
|
|
}
|
|
// Existing rules keep their stored config; a fresh database has the new defaults.
|
|
const varroa = rules.find(
|
|
(rule) => rule.triggerType === 'VARROA_THRESHOLD',
|
|
);
|
|
expect(varroa?.config).toBeTruthy();
|
|
});
|
|
|
|
it('PATCH a rule with an invalid known value answers 400 with the field', async () => {
|
|
const rules = (
|
|
await request(app.getHttpServer())
|
|
.get('/api/v1/automation-rules')
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.expect(200)
|
|
).body as AutomationRuleBody[];
|
|
const autopilot = rules.find(
|
|
(rule) => rule.triggerType === 'SEASON_AUTOPILOT',
|
|
)!;
|
|
|
|
const res = await request(app.getHttpServer())
|
|
.patch(`/api/v1/automation-rules/${autopilot.id}`)
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.send({ config: { queenMaxAgeYears: 0 } })
|
|
.expect(400);
|
|
|
|
const body = res.body as {
|
|
message: string;
|
|
issues: { field: string; message: string }[];
|
|
};
|
|
expect(body.message).toBe('Die Einstellung ist ungültig.');
|
|
expect(body.issues).toEqual([
|
|
expect.objectContaining({ field: 'queenMaxAgeYears' }),
|
|
]);
|
|
// Nothing was written.
|
|
const stored = await prisma.automationRule.findUniqueOrThrow({
|
|
where: { id: autopilot.id },
|
|
});
|
|
expect(stored.config).toEqual(autopilot.config);
|
|
});
|
|
|
|
it('PATCH keeps unknown keys and saves a valid config', async () => {
|
|
const rule = await prisma.automationRule.findUniqueOrThrow({
|
|
where: { triggerType: 'SEASON_AUTOPILOT' },
|
|
});
|
|
try {
|
|
await request(app.getHttpServer())
|
|
.patch(`/api/v1/automation-rules/${rule.id}`)
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.send({ config: { queenMaxAgeYears: 3, futureKey: 'x' } })
|
|
.expect(200);
|
|
|
|
const stored = await prisma.automationRule.findUniqueOrThrow({
|
|
where: { id: rule.id },
|
|
});
|
|
expect(stored.config).toEqual({ queenMaxAgeYears: 3, futureKey: 'x' });
|
|
} finally {
|
|
await prisma.automationRule.update({
|
|
where: { id: rule.id },
|
|
data: { config: rule.config as Prisma.InputJsonValue },
|
|
});
|
|
}
|
|
});
|
|
|
|
it('proposes a queen check and notifies when queen not seen and no eggs present', async () => {
|
|
const inspectionId = await record('inspections', {
|
|
queenSeen: false,
|
|
eggsPresent: false,
|
|
});
|
|
|
|
const suggestions = await suggestionsOf();
|
|
expect(suggestions).toHaveLength(1);
|
|
expect(suggestions[0]).toMatchObject({
|
|
ruleKey: 'QUEENLESS_NO_EGGS',
|
|
source: 'RULE',
|
|
mode: 'PLAN',
|
|
intent: 'QUEEN_CHECK',
|
|
status: 'OPEN',
|
|
priority: 'HIGH',
|
|
reasonCode: 'QUEENLESS_NO_EGGS',
|
|
requiredPermission: 'inspections:read',
|
|
dedupeKey: `QUEENLESS_NO_EGGS:${colonyId}:${inspectionId}`,
|
|
});
|
|
// The rule proposes, it creates no task.
|
|
expect(await tasksOfColony()).toBe(0);
|
|
|
|
const notifications = await prisma.notification.findMany({
|
|
where: { relatedType: 'Suggestion', relatedId: suggestions[0].id },
|
|
});
|
|
// One copy per user who may read tasks and inspections, never a broadcast.
|
|
expect(notifications.length).toBeGreaterThan(0);
|
|
expect(notifications.every((n) => n.category === 'SUGGESTION')).toBe(true);
|
|
expect(new Set(notifications.map((n) => n.userId)).size).toBe(
|
|
notifications.length,
|
|
);
|
|
});
|
|
|
|
it('does not trigger when the queen was seen', async () => {
|
|
await record('inspections', { queenSeen: true, eggsPresent: false });
|
|
|
|
expect(await suggestionsOf()).toHaveLength(1);
|
|
});
|
|
|
|
it('proposes feeding when feed status is kritisch, without a notification', async () => {
|
|
await record('inspections', { feedStatus: 'CRITICAL' });
|
|
|
|
const suggestions = await suggestionsOf('FEED_STATUS_CRITICAL');
|
|
expect(suggestions).toHaveLength(1);
|
|
expect(suggestions[0]).toMatchObject({ intent: 'FEED', status: 'OPEN' });
|
|
// The rule is off for notifications by default (notify: false).
|
|
expect(
|
|
await prisma.notification.count({
|
|
where: { relatedType: 'Suggestion', relatedId: suggestions[0].id },
|
|
}),
|
|
).toBe(0);
|
|
expect(await tasksOfColony()).toBe(0);
|
|
});
|
|
|
|
it('evaluates no rule on a corrected inspection', async () => {
|
|
const id = await record('inspections', { queenSeen: true });
|
|
await dismissOpen();
|
|
const before = await ruleSuggestionCount();
|
|
|
|
await request(app.getHttpServer())
|
|
.patch(`/api/v1/inspections/${id}`)
|
|
.set('Authorization', `Bearer ${staffToken}`)
|
|
.send({ queenSeen: false, eggsPresent: false, feedStatus: 'CRITICAL' })
|
|
.expect(200);
|
|
await drainDomainEvents(app, [id]);
|
|
|
|
expect(await ruleSuggestionCount()).toBe(before);
|
|
});
|
|
|
|
it('proposes a treatment check when the mite fall is red', async () => {
|
|
const id = await record('varroa-measurements', {
|
|
method: 'NATURAL_MITE_FALL',
|
|
miteCount: 20,
|
|
date: '2026-08-10T00:00:00.000Z',
|
|
// One day on the board: 20 mites per day, above the limit of 10.
|
|
durationMinutes: 24 * 60,
|
|
});
|
|
|
|
const suggestions = await suggestionsOf('VARROA_THRESHOLD');
|
|
expect(suggestions).toHaveLength(1);
|
|
expect(suggestions[0]).toMatchObject({
|
|
intent: 'VARROA_TREAT',
|
|
reasonCode: 'VARROA_RED',
|
|
status: 'OPEN',
|
|
requiredPermission: 'varroa:read',
|
|
evidence: {
|
|
colonyId,
|
|
measurementId: id,
|
|
measuredOn: '2026-08-10',
|
|
value: 20,
|
|
redAbove: 10,
|
|
unit: 'MITES_PER_DAY',
|
|
},
|
|
});
|
|
expect(await tasksOfColony()).toBe(0);
|
|
});
|
|
|
|
it('rates a sample-based count with the percentage band', async () => {
|
|
await dismissOpen();
|
|
const before = await ruleSuggestionCount();
|
|
// Summer band: red above 5 %. 5 of 500 bees is 1 %: yellow, no proposal.
|
|
await record('varroa-measurements', {
|
|
method: 'POWDERED_SUGAR',
|
|
miteCount: 5,
|
|
sampleBees: 500,
|
|
date: '2026-07-10T00:00:00.000Z',
|
|
});
|
|
expect(await ruleSuggestionCount()).toBe(before);
|
|
|
|
// 50 of 500 bees is 10 %: red.
|
|
await record('varroa-measurements', {
|
|
method: 'POWDERED_SUGAR',
|
|
miteCount: 50,
|
|
sampleBees: 500,
|
|
date: '2026-07-11T00:00:00.000Z',
|
|
});
|
|
const red = await prisma.suggestion.findMany({
|
|
where: { colonyId, status: 'OPEN', ruleKey: 'VARROA_THRESHOLD' },
|
|
});
|
|
expect(red).toHaveLength(1);
|
|
expect(red[0].evidence).toMatchObject({ unit: 'PERCENT', value: 10 });
|
|
});
|
|
|
|
it('re-evaluates a corrected varroa measurement against the limit', async () => {
|
|
await dismissOpen();
|
|
const before = await ruleSuggestionCount();
|
|
// Five mites per day: yellow in August, no proposal.
|
|
const id = await record('varroa-measurements', {
|
|
method: 'NATURAL_MITE_FALL',
|
|
miteCount: 5,
|
|
date: '2026-08-20T00:00:00.000Z',
|
|
durationMinutes: 24 * 60,
|
|
});
|
|
expect(await ruleSuggestionCount()).toBe(before);
|
|
|
|
// The count was miscounted: 25 mites per day.
|
|
await request(app.getHttpServer())
|
|
.patch(`/api/v1/varroa-measurements/${id}`)
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.send({ miteCount: 25 })
|
|
.expect(200);
|
|
await drainDomainEvents(app, [id]);
|
|
|
|
const open = await prisma.suggestion.findMany({
|
|
where: { colonyId, status: 'OPEN', ruleKey: 'VARROA_THRESHOLD' },
|
|
});
|
|
expect(open).toHaveLength(1);
|
|
expect(open[0].dedupeKey).toBe(`VARROA_THRESHOLD:${colonyId}:${id}`);
|
|
expect(await ruleSuggestionCount()).toBe(before + 1);
|
|
|
|
// Corrected again while still red: the open suggestion follows the value.
|
|
const correct = async (miteCount: number) => {
|
|
await request(app.getHttpServer())
|
|
.patch(`/api/v1/varroa-measurements/${id}`)
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.send({ miteCount })
|
|
.expect(200);
|
|
await drainDomainEvents(app, [id]);
|
|
};
|
|
await correct(30);
|
|
const refreshed = await prisma.suggestion.findUniqueOrThrow({
|
|
where: { id: open[0].id },
|
|
});
|
|
expect(refreshed.status).toBe('OPEN');
|
|
expect(refreshed.evidence).toMatchObject({ value: 30 });
|
|
|
|
// Corrected below the limit: the condition is gone, the suggestion resolves.
|
|
await correct(1);
|
|
const resolved = await prisma.suggestion.findUniqueOrThrow({
|
|
where: { id: open[0].id },
|
|
});
|
|
expect(resolved).toMatchObject({ status: 'RESOLVED', dedupeKey: null });
|
|
});
|
|
|
|
it('lets an admin clear a rule config, which falls back to its defaults', async () => {
|
|
const before = await prisma.automationRule.findUniqueOrThrow({
|
|
where: { id: varroaRuleId },
|
|
});
|
|
try {
|
|
const response = await request(app.getHttpServer())
|
|
.patch(`/api/v1/automation-rules/${varroaRuleId}`)
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.send({ config: null })
|
|
.expect(200);
|
|
expect((response.body as { config: unknown }).config).toBeNull();
|
|
|
|
await request(app.getHttpServer())
|
|
.patch(`/api/v1/automation-rules/${varroaRuleId}`)
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.send({ active: null })
|
|
.expect(400);
|
|
} finally {
|
|
// The rule is shared by every suite - put its config back.
|
|
await prisma.automationRule.update({
|
|
where: { id: varroaRuleId },
|
|
data: {
|
|
config:
|
|
before.config === null
|
|
? Prisma.DbNull
|
|
: (before.config as Prisma.InputJsonValue),
|
|
},
|
|
});
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Deactivates SWARM_MOOD_HIGH, not a rule other e2e files rely on: the
|
|
* rule rows are shared, and switching off VARROA_THRESHOLD here would make
|
|
* a parallel file's varroa test see no task. Only swarm-control.e2e
|
|
* evaluates this rule, with checks that never trigger it (LOW or none).
|
|
*/
|
|
it('lets an admin deactivate a rule, preventing further triggers', async () => {
|
|
const highSwarmMood = () =>
|
|
request(app.getHttpServer())
|
|
.post('/api/v1/swarm-control-checks')
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.send({
|
|
colonyId,
|
|
date: new Date().toISOString(),
|
|
swarmMood: 'HIGH',
|
|
})
|
|
.expect(201);
|
|
const swarmSuggestions = () =>
|
|
prisma.suggestion.count({
|
|
where: { colonyId, ruleKey: 'SWARM_MOOD_HIGH' },
|
|
});
|
|
|
|
// While active, high swarm mood leaves a suggestion - the rule really
|
|
// fires. (Swarm checks stay on the post-commit path: evaluated before
|
|
// the response, no event to drain.)
|
|
await highSwarmMood();
|
|
expect(await swarmSuggestions()).toBe(1);
|
|
// Settle it so the one-open-thing guard cannot be what keeps a new one
|
|
// from appearing - only the deactivation may.
|
|
await dismissOpen();
|
|
|
|
try {
|
|
await request(app.getHttpServer())
|
|
.patch(`/api/v1/automation-rules/${swarmRuleId}`)
|
|
.set('Authorization', `Bearer ${adminToken}`)
|
|
.send({ active: false })
|
|
.expect(200);
|
|
|
|
await highSwarmMood();
|
|
|
|
expect(await swarmSuggestions()).toBe(1);
|
|
} finally {
|
|
await prisma.automationRule.update({
|
|
where: { id: swarmRuleId },
|
|
data: { active: true },
|
|
});
|
|
}
|
|
});
|
|
});
|