@vuer-ai/vuer-rtc 0.0.1

package/tests/operations/collections.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Tests for collection operations: array, object, color
+ */
+
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createEmptyGraph, applyMessage } from '../../src/index.js';
+import type { SceneGraph, CRDTMessage, Operation } from '../../src/operations/OperationTypes.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface OpFixture {
+  name: string;
+  op: Operation;
+}
+
+function loadOps(filename: string): OpFixture[] {
+  const filepath = join(__dirname, '../fixtures', filename);
+  const content = readFileSync(filepath, 'utf-8');
+  return content
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line));
+}
+
+function createMsg(op: Operation, lamport = 1): CRDTMessage {
+  return {
+    id: `msg-${Math.random().toString(36).slice(2)}`,
+    sessionId: 'test-session',
+    clock: { 'test-session': lamport },
+    lamportTime: lamport,
+    timestamp: Date.now(),
+    ops: [op],
+  };
+}
+
+function createNodeWithProps(
+  graph: SceneGraph,
+  key: string,
+  props: Record<string, unknown>
+): SceneGraph {
+  const nodeOp: Operation = {
+    key: '',
+    otype: 'node.insert',
+    path: 'children',
+    value: {
+      key,
+      id: `uuid-${key}`,
+      tag: 'Mesh',
+      name: key,
+      ...props,
+    },
+  };
+  return applyMessage(graph, createMsg(nodeOp, 0));
+}
+
+describe('Array Operations', () => {
+  let arrayOps: OpFixture[];
+  let graph: SceneGraph;
+
+  beforeEach(() => {
+    arrayOps = loadOps('array-ops.jsonl');
+    graph = createEmptyGraph();
+    graph = createNodeWithProps(graph, 'node-1', {
+      tags: ['initial'],
+      scores: [10, 20],
+    });
+  });
+
+  it('array.set should replace array', () => {
+    const op = arrayOps.find((f) => f.name === 'array_set')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].tags).toEqual(['enemy', 'active']);
+  });
+
+  it('array.set with empty should clear', () => {
+    const op = arrayOps.find((f) => f.name === 'array_set_empty')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].tags).toEqual([]);
+  });
+
+  it('array.push should append element', () => {
+    const op = arrayOps.find((f) => f.name === 'array_push')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].tags).toEqual(['initial', 'new-tag']);
+  });
+
+  it('array.push should work with numbers', () => {
+    const op = arrayOps.find((f) => f.name === 'array_push_number')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].scores).toEqual([10, 20, 100]);
+  });
+
+  it('array.union should add unique elements', () => {
+    const op = arrayOps.find((f) => f.name === 'array_union')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].tags).toContain('initial');
+    expect(result.nodes['node-1'].tags).toContain('tag-a');
+    expect(result.nodes['node-1'].tags).toContain('tag-b');
+  });
+
+  it('array.remove should remove element', () => {
+    graph = createNodeWithProps(createEmptyGraph(), 'node-1', { tags: ['friend', 'enemy', 'active'] });
+    const op = arrayOps.find((f) => f.name === 'array_remove')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].tags).toEqual(['friend', 'active']);
+  });
+
+  it('array.remove on missing element should be no-op', () => {
+    const op = arrayOps.find((f) => f.name === 'array_remove')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].tags).toEqual(['initial']);
+  });
+});
+
+describe('Object Operations', () => {
+  let objectOps: OpFixture[];
+  let graph: SceneGraph;
+
+  beforeEach(() => {
+    objectOps = loadOps('object-ops.jsonl');
+    graph = createEmptyGraph();
+    graph = createNodeWithProps(graph, 'node-1', {
+      metadata: { existing: 'value' },
+      config: { debug: true },
+    });
+  });
+
+  it('object.set should replace object', () => {
+    const op = objectOps.find((f) => f.name === 'object_set')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].metadata).toEqual({ author: 'user-1', version: 1 });
+  });
+
+  it('object.set with empty should clear', () => {
+    const op = objectOps.find((f) => f.name === 'object_set_empty')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].metadata).toEqual({});
+  });
+
+  it('object.merge should merge properties', () => {
+    const op = objectOps.find((f) => f.name === 'object_merge')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].metadata).toEqual({
+      existing: 'value',
+      tags: ['a', 'b'],
+    });
+  });
+
+  it('object.merge with nested should add nested', () => {
+    const op = objectOps.find((f) => f.name === 'object_merge_nested')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].config).toEqual({
+      debug: true,
+      settings: { enabled: true },
+    });
+  });
+});
+
+describe('Color Operations', () => {
+  let colorOps: OpFixture[];
+  let graph: SceneGraph;
+
+  beforeEach(() => {
+    colorOps = loadOps('color-ops.jsonl');
+    graph = createEmptyGraph();
+    graph = createNodeWithProps(graph, 'node-1', {
+      color: '#000000',
+    });
+  });
+
+  it('color.set should replace color', () => {
+    const op = colorOps.find((f) => f.name === 'color_set_red')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].color).toBe('#ff0000');
+  });
+
+  it('color.set with different colors should work', () => {
+    const op = colorOps.find((f) => f.name === 'color_set_rgb')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].color).toBe('#336699');
+  });
+
+  it('color.blend should blend colors', () => {
+    graph = createNodeWithProps(createEmptyGraph(), 'node-1', { color: '#000000' });
+    const op = colorOps.find((f) => f.name === 'color_blend')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    // Color blend result depends on implementation
+    expect(result.nodes['node-1'].color).toBeDefined();
+  });
+});

package/tests/operations/nodes.test.ts

@@ -0,0 +1,228 @@
+/**
+ * Tests for node operations: node.insert, node.remove
+ */
+
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createEmptyGraph, applyMessage } from '../../src/index.js';
+import type { SceneGraph, CRDTMessage, Operation } from '../../src/operations/OperationTypes.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface OpFixture {
+  name: string;
+  op: Operation;
+}
+
+function loadOps(filename: string): OpFixture[] {
+  const filepath = join(__dirname, '../fixtures', filename);
+  const content = readFileSync(filepath, 'utf-8');
+  return content
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line));
+}
+
+function createMsg(op: Operation, lamport = 1): CRDTMessage {
+  return {
+    id: `msg-${Math.random().toString(36).slice(2)}`,
+    sessionId: 'test-session',
+    clock: { 'test-session': lamport },
+    lamportTime: lamport,
+    timestamp: Date.now(),
+    ops: [op],
+  };
+}
+
+describe('Node Operations', () => {
+  let nodeOps: OpFixture[];
+  let graph: SceneGraph;
+
+  beforeEach(() => {
+    nodeOps = loadOps('node-ops.jsonl');
+    graph = createEmptyGraph();
+  });
+
+  describe('node.insert', () => {
+    it('should insert root node', () => {
+      const op = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      const result = applyMessage(graph, createMsg(op));
+
+      expect(result.rootKey).toBe('scene');
+      expect(result.nodes['scene']).toBeDefined();
+      expect(result.nodes['scene'].tag).toBe('Scene');
+      expect(result.nodes['scene'].name).toBe('Root Scene');
+    });
+
+    it('should insert child node under parent', () => {
+      // First insert root
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      // Then insert mesh
+      const meshOp = nodeOps.find((f) => f.name === 'node_insert_mesh')!.op;
+      const result = applyMessage(graph, createMsg(meshOp, 2));
+
+      expect(result.nodes['cube-1']).toBeDefined();
+      expect(result.nodes['cube-1'].tag).toBe('Mesh');
+      expect(result.nodes['scene'].children).toContain('cube-1');
+    });
+
+    it('should insert group node', () => {
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      const groupOp = nodeOps.find((f) => f.name === 'node_insert_group')!.op;
+      const result = applyMessage(graph, createMsg(groupOp, 2));
+
+      expect(result.nodes['group-1']).toBeDefined();
+      expect(result.nodes['group-1'].tag).toBe('Group');
+      expect(result.nodes['scene'].children).toContain('group-1');
+    });
+
+    it('should insert nested node under group', () => {
+      // Build hierarchy: scene -> group-1 -> sphere-1
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      const groupOp = nodeOps.find((f) => f.name === 'node_insert_group')!.op;
+      graph = applyMessage(graph, createMsg(groupOp, 2));
+
+      const nestedOp = nodeOps.find((f) => f.name === 'node_insert_nested')!.op;
+      const result = applyMessage(graph, createMsg(nestedOp, 3));
+
+      expect(result.nodes['sphere-1']).toBeDefined();
+      expect(result.nodes['group-1'].children).toContain('sphere-1');
+      expect(result.nodes['scene'].children).not.toContain('sphere-1');
+    });
+
+    it('should preserve initial properties', () => {
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      const meshOp = nodeOps.find((f) => f.name === 'node_insert_mesh')!.op;
+      const result = applyMessage(graph, createMsg(meshOp, 2));
+
+      expect(result.nodes['cube-1'].position).toEqual([0, 0, 0]);
+      expect(result.nodes['cube-1'].scale).toEqual([1, 1, 1]);
+    });
+
+    it('should be idempotent (inserting same key twice is no-op)', () => {
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      const meshOp = nodeOps.find((f) => f.name === 'node_insert_mesh')!.op;
+      graph = applyMessage(graph, createMsg(meshOp, 2));
+
+      // Insert same mesh again with different name
+      const duplicateOp: Operation = {
+        key: 'scene',
+        otype: 'node.insert',
+        path: 'children',
+        value: {
+          key: 'cube-1',
+          id: 'uuid-cube-1-dup',
+          tag: 'Mesh',
+          name: 'Cube Duplicate',
+        },
+      };
+      const result = applyMessage(graph, createMsg(duplicateOp, 3));
+
+      // Should not change
+      expect(result.nodes['cube-1'].name).toBe('Cube');
+    });
+  });
+
+  describe('node.remove', () => {
+    it('should remove node from parent', () => {
+      // Setup: scene -> cube-1
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      const meshOp = nodeOps.find((f) => f.name === 'node_insert_mesh')!.op;
+      graph = applyMessage(graph, createMsg(meshOp, 2));
+
+      expect(graph.nodes['scene'].children).toContain('cube-1');
+
+      // Remove
+      const removeOp = nodeOps.find((f) => f.name === 'node_remove')!.op;
+      const result = applyMessage(graph, createMsg(removeOp, 3));
+
+      expect(result.nodes['scene'].children).not.toContain('cube-1');
+    });
+
+    it('should tombstone node (soft delete)', () => {
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      const meshOp = nodeOps.find((f) => f.name === 'node_insert_mesh')!.op;
+      graph = applyMessage(graph, createMsg(meshOp, 2));
+
+      const removeOp = nodeOps.find((f) => f.name === 'node_remove')!.op;
+      const result = applyMessage(graph, createMsg(removeOp, 3));
+
+      // Node still exists but has deletedAt
+      expect(result.nodes['cube-1']).toBeDefined();
+      expect(result.nodes['cube-1'].deletedAt).toBeDefined();
+    });
+
+    it('should remove nested node from group', () => {
+      // Build: scene -> group-1 -> sphere-1
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      const groupOp = nodeOps.find((f) => f.name === 'node_insert_group')!.op;
+      graph = applyMessage(graph, createMsg(groupOp, 2));
+
+      const nestedOp = nodeOps.find((f) => f.name === 'node_insert_nested')!.op;
+      graph = applyMessage(graph, createMsg(nestedOp, 3));
+
+      // Remove nested
+      const removeNestedOp = nodeOps.find((f) => f.name === 'node_remove_nested')!.op;
+      const result = applyMessage(graph, createMsg(removeNestedOp, 4));
+
+      expect(result.nodes['group-1'].children).not.toContain('sphere-1');
+      expect(result.nodes['sphere-1'].deletedAt).toBeDefined();
+    });
+
+    it('should be no-op if node does not exist', () => {
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      const removeOp: Operation = {
+        key: 'scene',
+        otype: 'node.remove',
+        path: 'children',
+        value: 'non-existent',
+      };
+      const result = applyMessage(graph, createMsg(removeOp, 2));
+
+      // Should not throw, just no-op
+      expect(result.nodes['scene'].children).toEqual([]);
+    });
+  });
+
+  describe('complex hierarchies', () => {
+    it('should build multi-level hierarchy', () => {
+      // scene -> group-1 -> [sphere-1], cube-1
+      const rootOp = nodeOps.find((f) => f.name === 'node_insert_root')!.op;
+      graph = applyMessage(graph, createMsg(rootOp, 1));
+
+      const groupOp = nodeOps.find((f) => f.name === 'node_insert_group')!.op;
+      graph = applyMessage(graph, createMsg(groupOp, 2));
+
+      const meshOp = nodeOps.find((f) => f.name === 'node_insert_mesh')!.op;
+      graph = applyMessage(graph, createMsg(meshOp, 3));
+
+      const nestedOp = nodeOps.find((f) => f.name === 'node_insert_nested')!.op;
+      graph = applyMessage(graph, createMsg(nestedOp, 4));
+
+      expect(graph.nodes['scene'].children).toContain('group-1');
+      expect(graph.nodes['scene'].children).toContain('cube-1');
+      expect(graph.nodes['group-1'].children).toContain('sphere-1');
+      expect(Object.keys(graph.nodes)).toHaveLength(4);
+    });
+  });
+});

package/tests/operations/primitives.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Tests for primitive operation types: number, string, boolean
+ */
+
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createEmptyGraph, applyMessage } from '../../src/index.js';
+import type { SceneGraph, CRDTMessage, Operation } from '../../src/operations/OperationTypes.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface OpFixture {
+  name: string;
+  op: Operation;
+}
+
+function loadOps(filename: string): OpFixture[] {
+  const filepath = join(__dirname, '../fixtures', filename);
+  const content = readFileSync(filepath, 'utf-8');
+  return content
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line));
+}
+
+function createMsg(op: Operation, lamport = 1): CRDTMessage {
+  return {
+    id: `msg-${Math.random().toString(36).slice(2)}`,
+    sessionId: 'test-session',
+    clock: { 'test-session': lamport },
+    lamportTime: lamport,
+    timestamp: Date.now(),
+    ops: [op],
+  };
+}
+
+function createNodeWithProps(
+  graph: SceneGraph,
+  key: string,
+  props: Record<string, unknown>
+): SceneGraph {
+  const nodeOp: Operation = {
+    key: '',
+    otype: 'node.insert',
+    path: 'children',
+    value: {
+      key,
+      id: `uuid-${key}`,
+      tag: 'Mesh',
+      name: key,
+      ...props,
+    },
+  };
+  return applyMessage(graph, createMsg(nodeOp, 0));
+}
+
+describe('Number Operations', () => {
+  let numberOps: OpFixture[];
+  let graph: SceneGraph;
+
+  beforeEach(() => {
+    numberOps = loadOps('number-ops.jsonl');
+    graph = createEmptyGraph();
+    graph = createNodeWithProps(graph, 'node-1', {
+      opacity: 1,
+      score: 0,
+      scale: 1,
+      health: 100,
+      damage: 10,
+    });
+  });
+
+  it('number.set should replace value', () => {
+    const op = numberOps.find((f) => f.name === 'number_set')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].opacity).toBe(0.5);
+  });
+
+  it('number.add should add to existing value', () => {
+    const op = numberOps.find((f) => f.name === 'number_add')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].score).toBe(10);
+  });
+
+  it('number.add with negative should subtract', () => {
+    graph = createNodeWithProps(createEmptyGraph(), 'node-1', { score: 100 });
+    const op = numberOps.find((f) => f.name === 'number_add_negative')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].score).toBe(95);
+  });
+
+  it('number.multiply should multiply value', () => {
+    const op = numberOps.find((f) => f.name === 'number_multiply')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].scale).toBe(2);
+  });
+
+  it('number.multiply with fraction should scale down', () => {
+    graph = createNodeWithProps(createEmptyGraph(), 'node-1', { scale: 4 });
+    const op = numberOps.find((f) => f.name === 'number_multiply_fraction')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].scale).toBe(2);
+  });
+
+  it('number.min should take minimum', () => {
+    const op = numberOps.find((f) => f.name === 'number_min')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].health).toBe(50);
+  });
+
+  it('number.min should not change if current is lower', () => {
+    graph = createNodeWithProps(createEmptyGraph(), 'node-1', { health: 25 });
+    const op = numberOps.find((f) => f.name === 'number_min')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].health).toBe(25);
+  });
+
+  it('number.max should take maximum', () => {
+    const op = numberOps.find((f) => f.name === 'number_max')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].damage).toBe(25);
+  });
+
+  it('number.max should not change if current is higher', () => {
+    graph = createNodeWithProps(createEmptyGraph(), 'node-1', { damage: 50 });
+    const op = numberOps.find((f) => f.name === 'number_max')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].damage).toBe(50);
+  });
+});
+
+describe('String Operations', () => {
+  let stringOps: OpFixture[];
+  let graph: SceneGraph;
+
+  beforeEach(() => {
+    stringOps = loadOps('string-ops.jsonl');
+    graph = createEmptyGraph();
+    graph = createNodeWithProps(graph, 'node-1', {
+      name: 'default',
+      tags: 'initial',
+    });
+  });
+
+  it('string.set should replace value', () => {
+    const op = stringOps.find((f) => f.name === 'string_set')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].name).toBe('Player');
+  });
+
+  it('string.set with empty string should clear', () => {
+    const op = stringOps.find((f) => f.name === 'string_set_empty')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].name).toBe('');
+  });
+
+  it('string.concat should append', () => {
+    const op = stringOps.find((f) => f.name === 'string_concat')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].tags).toBe('initialactive');
+  });
+
+  it('string.concat with separator should use separator', () => {
+    const op = stringOps.find((f) => f.name === 'string_concat_separator')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].tags).toBe('initial,enemy');
+  });
+});
+
+describe('Boolean Operations', () => {
+  let boolOps: OpFixture[];
+  let graph: SceneGraph;
+
+  beforeEach(() => {
+    boolOps = loadOps('boolean-ops.jsonl');
+    graph = createEmptyGraph();
+    graph = createNodeWithProps(graph, 'node-1', {
+      visible: true,
+      enabled: false,
+      active: true,
+    });
+  });
+
+  it('boolean.set true should set to true', () => {
+    graph = createNodeWithProps(createEmptyGraph(), 'node-1', { visible: false });
+    const op = boolOps.find((f) => f.name === 'boolean_set_true')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].visible).toBe(true);
+  });
+
+  it('boolean.set false should set to false', () => {
+    const op = boolOps.find((f) => f.name === 'boolean_set_false')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].visible).toBe(false);
+  });
+
+  it('boolean.or with true should become true', () => {
+    const op = boolOps.find((f) => f.name === 'boolean_or_true')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].enabled).toBe(true);
+  });
+
+  it('boolean.or with false on false should stay false', () => {
+    const op = boolOps.find((f) => f.name === 'boolean_or_false')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].enabled).toBe(false);
+  });
+
+  it('boolean.and with true on true should stay true', () => {
+    const op = boolOps.find((f) => f.name === 'boolean_and_true')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].active).toBe(true);
+  });
+
+  it('boolean.and with false should become false', () => {
+    const op = boolOps.find((f) => f.name === 'boolean_and_false')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].active).toBe(false);
+  });
+});