Initial commit

Co-Authored-By: Eric Tuvesson <eric.tuvesson@gmail.com>
Co-Authored-By: mikaeltellhed <2311083+mikaeltellhed@users.noreply.github.com>
Co-Authored-By: kotte <14197736+mrtamagotchi@users.noreply.github.com>
Co-Authored-By: Anders Larsson <64838990+anders-topp@users.noreply.github.com>
Co-Authored-By: Johan  <4934465+joolsus@users.noreply.github.com>
Co-Authored-By: Tore Knudsen <18231882+torekndsn@users.noreply.github.com>
Co-Authored-By: victoratndl <99176179+victoratndl@users.noreply.github.com>

packages/noodl-runtime/test/nodes/componentinstance.test.js

@@ -0,0 +1,241 @@
+const ComponentInstance = require('./componentinstance');
+const { ComponentModel } = require('../models/componentmodel');
+const GraphModel = require('../models/graphmodel');
+const NodeContext = require('../nodecontext');
+const ComponentInputs = require('./componentinputs');
+const ComponentOutputs = require('./componentoutputs');
+const NodeDefinition = require('../nodedefinition');
+
+async function setupComponent() {
+  const context = new NodeContext();
+  context.nodeRegister.register(NodeDefinition.defineNode(ComponentInputs.node));
+  context.nodeRegister.register(NodeDefinition.defineNode(ComponentOutputs.node));
+
+  const componentModel = await ComponentModel.createFromExportData({
+    name: 'testComponent',
+    id: 'loltroll2',
+    nodes: [
+      {
+        id: 'loltroll',
+        type: 'Component Inputs',
+        ports: [{ name: 'textInput', plug: 'output', type: 'string' }]
+      },
+      {
+        id: 'componentOutputs',
+        type: 'Component Outputs',
+        ports: [{ name: 'textOutput', plug: 'input', type: 'string' }]
+      }
+    ],
+    ports: [
+      { name: 'textInput', plug: 'input', type: 'string' },
+      { name: 'textOutput', plug: 'output', type: 'string' }
+    ],
+    connections: []
+  });
+
+  const componentInstance = new ComponentInstance(context);
+  await componentInstance.setComponentModel(componentModel);
+  return { componentInstance, componentModel };
+}
+
+function createTestNodeDefinition() {
+  return NodeDefinition.defineNode({
+    name: 'Test Node',
+    category: 'test',
+    initialize() {
+      this.inputHistory = [];
+    },
+    inputs: {
+      input: {
+        type: 'string',
+        set(value) {
+          this.testValue = value;
+          this.flagOutputDirty('output');
+          this.inputHistory.push(value);
+        }
+      }
+    },
+    outputs: {
+      output: {
+        type: 'string',
+        get() {
+          return this.testValue;
+        }
+      }
+    }
+  });
+}
+
+test('Component inputs are registered', async () => {
+  const { componentInstance } = await setupComponent();
+  expect(componentInstance.hasInput('textInput')).toBeTruthy();
+});
+
+test('Internal component inputs are removed when a component input node is removed', async () => {
+  const { componentInstance, componentModel } = await setupComponent();
+
+  expect(componentInstance._internal.componentInputs.length).toBe(1);
+  await componentModel.removeNodeWithId('loltroll');
+  expect(componentInstance._internal.componentInputs.length).toBe(0);
+});
+
+test('Component outputs are registered', async () => {
+  const { componentInstance } = await setupComponent();
+  expect(componentInstance.hasOutput('textOutput')).toBeTruthy();
+});
+
+test('Internal component outputs are removed when a component output node is removed', async () => {
+  const { componentInstance, componentModel } = await setupComponent();
+
+  expect(componentInstance._internal.componentOutputs.length).toBe(1);
+  await componentModel.removeNodeWithId('componentOutputs');
+  expect(componentInstance._internal.componentOutputs.length).toBe(0);
+});
+
+test('Parameters should be overwritten by connections', async () => {
+  const context = new NodeContext();
+
+  context.nodeRegister.register(createTestNodeDefinition());
+
+  const componentModel = await ComponentModel.createFromExportData({
+    name: 'rootComponent',
+    id: 'testid',
+    nodes: [
+      {
+        id: 'testNodeEnd',
+        type: 'Test Node',
+        parameters: { input: 'param-value' }
+      },
+      {
+        id: 'testNodeStart',
+        type: 'Test Node',
+        parameters: { input: 'connection-value' }
+      }
+    ],
+    connections: [{ sourceId: 'testNodeStart', sourcePort: 'output', targetId: 'testNodeEnd', targetPort: 'input' }]
+  });
+
+  const componentInstance = new ComponentInstance(context);
+  await componentInstance.setComponentModel(componentModel);
+
+  const testnodeEnd = componentInstance.nodeScope.getNodeWithId('testNodeEnd');
+  testnodeEnd.update();
+
+  expect(testnodeEnd.inputHistory.length).toBe(1);
+  expect(testnodeEnd.inputHistory[0]).toBe('connection-value');
+});
+
+test('Component inputs should not interfere with internal nodes', async () => {
+  const context = new NodeContext();
+
+  context.nodeRegister.register(NodeDefinition.defineNode(ComponentInputs.node));
+  context.nodeRegister.register(createTestNodeDefinition());
+
+  const componentModel = await ComponentModel.createFromExportData({
+    name: 'rootComponent',
+    id: 'testid',
+    nodes: [
+      {
+        id: 'testnode',
+        type: 'Test Node',
+        parameters: { input: 'param-value' }
+      },
+      {
+        id: 'compinput',
+        type: 'Component Inputs',
+        ports: [{ name: 'output', plug: 'output', type: 'string' }]
+      }
+    ],
+    connections: [{ sourceId: 'compinput', sourcePort: 'output', targetId: 'testnode', targetPort: 'input' }]
+  });
+
+  const componentInstance = new ComponentInstance(context);
+  await componentInstance.setComponentModel(componentModel);
+
+  const testnode = componentInstance.nodeScope.getNodeWithId('testnode');
+  testnode.update();
+
+  expect(testnode.inputHistory.length).toBe(1);
+  expect(testnode.inputHistory[0]).toBe('param-value');
+});
+
+test('No delays in component inputs and outputs', async () => {
+  const context = new NodeContext();
+
+  context.nodeRegister.register(NodeDefinition.defineNode(ComponentInputs.node));
+  context.nodeRegister.register(NodeDefinition.defineNode(ComponentOutputs.node));
+  context.nodeRegister.register(createTestNodeDefinition());
+
+  const graph = new GraphModel();
+
+  graph.on('componentAdded', (component) => context.registerComponentModel(component));
+
+  await graph.importEditorData({
+    components: [
+      {
+        name: 'testComponent',
+        nodes: [
+          {
+            id: 'compinput',
+            type: 'Component Inputs',
+            ports: [{ name: 'textInput', plug: 'output', type: 'string' }]
+          },
+          {
+            id: 'testnode-inner',
+            type: 'Test Node',
+            parameters: { input: 'inner-value' }
+          },
+          {
+            id: 'compoutput',
+            type: 'Component Outputs',
+            ports: [{ name: 'textOutput', plug: 'input', type: 'string' }]
+          }
+        ],
+        connections: [
+          { sourceId: 'compinput', sourcePort: 'textInput', targetId: 'testnode-inner', targetPort: 'input' },
+          { sourceId: 'testnode-inner', sourcePort: 'output', targetId: 'compoutput', targetPort: 'textOutput' }
+        ],
+        ports: [
+          { name: 'textInput', plug: 'input', type: 'string' },
+          { name: 'textOutput', plug: 'output', type: 'string' }
+        ]
+      },
+      {
+        name: 'rootComponent',
+        nodes: [
+          {
+            id: 'testComponent',
+            type: 'testComponent'
+          },
+          {
+            id: 'testnodeEnd',
+            type: 'Test Node'
+          },
+          {
+            id: 'testNodeStart',
+            type: 'Test Node',
+            parameters: { input: 'outer-value' }
+          }
+        ],
+        connections: [
+          { sourceId: 'testComponent', sourcePort: 'textOutput', targetId: 'testnodeEnd', targetPort: 'input' },
+          { sourceId: 'testNodeStart', sourcePort: 'output', targetId: 'testComponent', targetPort: 'textInput' }
+        ]
+      }
+    ]
+  });
+
+  const rootComponent = await context.createComponentInstanceNode('rootComponent');
+  context.setRootComponent(rootComponent);
+
+  const testnodeEnd = rootComponent.nodeScope.getNodeWithId('testnodeEnd');
+  const testnodeInner = rootComponent.nodeScope.getNodesWithIdRecursive('testnode-inner')[0];
+
+  context.update();
+
+  expect(testnodeEnd.inputHistory.length).toBe(1);
+  expect(testnodeEnd.inputHistory[0]).toBe('outer-value');
+
+  expect(testnodeInner.inputHistory.length).toBe(1);
+  expect(testnodeInner.inputHistory[0]).toBe('outer-value');
+});