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-editor/tests/nodegraph/nodelibrary-spec.js

@@ -0,0 +1,318 @@
+const NodeLibrary = require('@noodl-models/nodelibrary').NodeLibrary;
+const BasicNodeType = require('@noodl-models/nodelibrary/BasicNodeType').BasicNodeType;
+const UnknownNodeType = require('@noodl-models/nodelibrary/UnknownNodeType').UnknownNodeType;
+
+const { ComponentModel } = require('@noodl-models/componentmodel');
+const { ProjectModel } = require('@noodl-models/projectmodel');
+
+describe('Node library tests', function () {
+  beforeEach(() => {
+    //reload fresh library for every test
+    window.NodeLibraryData = require('../nodegraph/nodelibrary');
+    for (const module of NodeLibrary.instance.modules) {
+      NodeLibrary.instance.unregisterModule(module);
+    }
+
+    NodeLibrary.instance.loadLibrary();
+  });
+
+  it('can detect compatibale port types', function () {
+    // Equal types
+    expect(NodeLibrary.instance.canCastPortTypes('string', 'string')).toBe(true);
+    expect(
+      NodeLibrary.instance.canCastPortTypes(
+        {
+          name: 'string'
+        },
+        'string'
+      )
+    ).toBe(true);
+    expect(
+      NodeLibrary.instance.canCastPortTypes('string', {
+        name: 'string'
+      })
+    ).toBe(true);
+
+    // Not equal and cannot cast
+    expect(
+      NodeLibrary.instance.canCastPortTypes('string', {
+        name: 'signal'
+      })
+    ).toBe(false);
+
+    // Star types are compatible with everything
+    expect(
+      NodeLibrary.instance.canCastPortTypes('*', {
+        name: 'number'
+      })
+    ).toBe(true);
+
+    // Casting
+    expect(
+      NodeLibrary.instance.canCastPortTypes('number', {
+        name: 'string'
+      })
+    ).toBe(true);
+  });
+
+  it('can find compatible port types', function () {
+    // Single type
+    expect(
+      NodeLibrary.instance.findCompatiblePortType([
+        {
+          direction: 'to',
+          type: 'string'
+        }
+      ])
+    ).toEqual({
+      name: 'string'
+    });
+
+    // Multiple connections, same type, with modifiers
+    expect(
+      NodeLibrary.instance.findCompatiblePortType([
+        {
+          direction: 'to',
+          type: 'string'
+        },
+        {
+          direction: 'from',
+          type: {
+            name: 'string',
+            multiline: true
+          }
+        }
+      ])
+    ).toEqual({
+      name: 'string',
+      multiline: true
+    });
+
+    // Is enums merged
+    expect(
+      NodeLibrary.instance.findCompatiblePortType([
+        {
+          direction: 'to',
+          type: {
+            name: 'enum',
+            enums: ['a', 'b']
+          }
+        },
+        {
+          direction: 'from',
+          type: {
+            name: 'enum',
+            enums: ['b', 'c']
+          }
+        }
+      ])
+    ).toEqual({
+      name: 'enum',
+      enums: ['a', 'b', 'c']
+    });
+
+    // Find compatible type and merge
+    expect(
+      NodeLibrary.instance.findCompatiblePortType([
+        {
+          direction: 'to',
+          type: {
+            name: 'number',
+            allowConnectionsOnly: true
+          }
+        },
+        {
+          direction: 'to',
+          type: 'boolean'
+        }
+      ])
+    ).toEqual({
+      name: 'number',
+      allowConnectionsOnly: true
+    });
+
+    // Find compatible type, mixed direction
+    expect(
+      NodeLibrary.instance.findCompatiblePortType([
+        {
+          direction: 'to',
+          type: {
+            name: 'number',
+            allowEditOnly: true
+          }
+        },
+        {
+          direction: 'to',
+          type: 'boolean'
+        },
+        {
+          direction: 'from',
+          type: 'number'
+        }
+      ])
+    ).toEqual({
+      name: 'number',
+      allowEditOnly: true
+    });
+
+    // Find compatible type, mixed direction
+    expect(
+      NodeLibrary.instance.findCompatiblePortType([
+        {
+          direction: 'to',
+          type: {
+            name: 'number'
+          }
+        },
+        {
+          direction: 'to',
+          type: 'boolean'
+        },
+        {
+          direction: 'from',
+          type: 'number'
+        },
+        {
+          direction: 'to',
+          type: 'color'
+        }
+      ])
+    ).toEqual({
+      name: 'string'
+    });
+
+    // Can't find compatible type
+    expect(
+      NodeLibrary.instance.findCompatiblePortType([
+        {
+          direction: 'to',
+          type: {
+            name: 'number',
+            allowEditOnly: true
+          }
+        },
+        {
+          direction: 'to',
+          type: 'boolean'
+        },
+        {
+          direction: 'from',
+          type: 'number'
+        },
+        {
+          direction: 'to',
+          type: 'referece'
+        }
+      ])
+    ).toBe(undefined);
+  });
+
+  it('can reload library', function () {
+    var p = ProjectModel.fromJSON(getProject());
+    NodeLibrary.instance.registerModule(p);
+
+    var n1 = p.components[0].graph.findNodeWithId('A');
+    var n2 = p.components[0].graph.findNodeWithId('B');
+    var n3 = p.components[0].graph.findNodeWithId('C');
+    var n4 = p.components[0].graph.findNodeWithId('D');
+
+    expect(n1.type instanceof BasicNodeType).toBe(true);
+    expect(n1.type.name).toBe('image');
+    expect(n2.type instanceof UnknownNodeType).toBe(true);
+
+    // Update library
+    NodeLibraryData.nodetypes.push({
+      name: 'newimage',
+      allowAsChild: true,
+      allowAsExclusiveRootOnly: true,
+      category: 'visuals',
+      ports: [
+        {
+          name: 'x',
+          type: {
+            name: 'number'
+          },
+          plug: 'input'
+        }
+      ]
+    });
+    NodeLibrary.instance.reload();
+
+    // Both should be OK now
+    expect(n1.type instanceof BasicNodeType).toBe(true);
+    expect(n1.type.name).toBe('image');
+
+    expect(n2.type instanceof BasicNodeType).toBe(true);
+    expect(n2.type.name).toBe('newimage');
+
+    NodeLibrary.instance.unregisterModule(p);
+  });
+
+  it('can get types by name', () => {
+    expect(NodeLibrary.instance.getNodeTypeWithName('comp1')).toBeUndefined();
+    //get basic type from node library
+    expect(NodeLibrary.instance.getNodeTypeWithName('image')).toBeInstanceOf(BasicNodeType);
+
+    //get component type from a project
+    const p = ProjectModel.fromJSON(getProject());
+    NodeLibrary.instance.registerModule(p);
+    expect(NodeLibrary.instance.getNodeTypeWithName('comp1')).toBeInstanceOf(ComponentModel);
+
+    //add a new component and get the type
+    const newComponent = ComponentModel.fromJSON({
+      name: 'comp2',
+      graph: {
+        roots: [
+          {
+            id: 'B',
+            type: 'image'
+          }
+        ]
+      }
+    });
+    p.addComponent(newComponent);
+    expect(NodeLibrary.instance.getNodeTypeWithName('comp2')).toBe(newComponent);
+
+    //remove the component again
+    p.removeComponent(newComponent);
+    expect(NodeLibrary.instance.getNodeTypeWithName('comp2')).toBeUndefined();
+
+    //unregister project and make sure the components aren't available anymore
+    NodeLibrary.instance.unregisterModule(p);
+    expect(NodeLibrary.instance.getNodeTypeWithName('comp1')).toBeUndefined();
+    expect(NodeLibrary.instance.getNodeTypeWithName('comp2')).toBeUndefined();
+  });
+
+  function getProject() {
+    return {
+      components: [
+        {
+          name: 'comp1',
+          graph: {
+            roots: [
+              {
+                id: 'A',
+                type: 'image'
+              },
+              {
+                id: 'B',
+                type: 'newimage'
+              },
+              {
+                id: 'C',
+                type: 'Event Sender',
+                parameters: {
+                  channel: 'Channel0'
+                }
+              },
+              {
+                id: 'D',
+                type: 'Event Receiver'
+              }
+            ]
+          }
+        }
+      ]
+    };
+  }
+});