@nyaruka/temba-components 0.129.8 → 0.129.9

package/test/nodes/split_by_random.test.ts

@@ -0,0 +1,177 @@
+import { expect } from '@open-wc/testing';
+import { split_by_random } from '../../src/flow/nodes/split_by_random';
+import { Node } from '../../src/store/flow-definition';
+import { NodeTest } from '../NodeHelper';
+
+/**
+ * Test suite for the split_by_random node configuration.
+ */
+describe('split_by_random node config', () => {
+  const helper = new NodeTest(split_by_random, 'split_by_random');
+
+  describe('basic properties', () => {
+    helper.testBasicProperties();
+
+    it('has correct name', () => {
+      expect(split_by_random.name).to.equal('Split by Random');
+    });
+
+    it('has correct type', () => {
+      expect(split_by_random.type).to.equal('split_by_random');
+    });
+
+    it('has correct color', () => {
+      expect(split_by_random.color).to.exist;
+    });
+
+    it('has router configuration', () => {
+      expect(split_by_random.router).to.exist;
+      expect(split_by_random.router.type).to.equal('random');
+    });
+
+    it('is a simple node config without form or layout', () => {
+      expect(split_by_random.form).to.be.undefined;
+      expect(split_by_random.layout).to.be.undefined;
+      expect(split_by_random.toFormData).to.be.undefined;
+      expect(split_by_random.fromFormData).to.be.undefined;
+    });
+  });
+
+  describe('node scenarios', () => {
+    helper.testNode(
+      {
+        uuid: 'test-random-node-1',
+        actions: [],
+        router: {
+          type: 'random',
+          categories: [
+            {
+              uuid: 'random-cat-1',
+              name: 'Bucket A',
+              exit_uuid: 'random-exit-1'
+            },
+            {
+              uuid: 'random-cat-2',
+              name: 'Bucket B',
+              exit_uuid: 'random-exit-2'
+            }
+          ]
+        },
+        exits: [
+          { uuid: 'random-exit-1', destination_uuid: null },
+          { uuid: 'random-exit-2', destination_uuid: null }
+        ]
+      } as Node,
+      { type: 'split_by_random' },
+      'two-bucket-split'
+    );
+
+    helper.testNode(
+      {
+        uuid: 'test-random-node-2',
+        actions: [],
+        router: {
+          type: 'random',
+          categories: [
+            {
+              uuid: 'random-cat-1',
+              name: 'Group A',
+              exit_uuid: 'random-exit-1'
+            },
+            {
+              uuid: 'random-cat-2',
+              name: 'Group B',
+              exit_uuid: 'random-exit-2'
+            },
+            {
+              uuid: 'random-cat-3',
+              name: 'Group C',
+              exit_uuid: 'random-exit-3'
+            }
+          ]
+        },
+        exits: [
+          { uuid: 'random-exit-1', destination_uuid: null },
+          { uuid: 'random-exit-2', destination_uuid: null },
+          { uuid: 'random-exit-3', destination_uuid: null }
+        ]
+      } as Node,
+      { type: 'split_by_random' },
+      'three-way-split'
+    );
+
+    helper.testNode(
+      {
+        uuid: 'test-random-node-3',
+        actions: [],
+        router: {
+          type: 'random',
+          categories: [
+            {
+              uuid: 'random-cat-1',
+              name: 'Treatment',
+              exit_uuid: 'random-exit-1'
+            },
+            {
+              uuid: 'random-cat-2',
+              name: 'Control',
+              exit_uuid: 'random-exit-2'
+            },
+            {
+              uuid: 'random-cat-3',
+              name: 'Variant A',
+              exit_uuid: 'random-exit-3'
+            },
+            {
+              uuid: 'random-cat-4',
+              name: 'Variant B',
+              exit_uuid: 'random-exit-4'
+            },
+            {
+              uuid: 'random-cat-5',
+              name: 'Holdout',
+              exit_uuid: 'random-exit-5'
+            }
+          ]
+        },
+        exits: [
+          { uuid: 'random-exit-1', destination_uuid: null },
+          { uuid: 'random-exit-2', destination_uuid: null },
+          { uuid: 'random-exit-3', destination_uuid: null },
+          { uuid: 'random-exit-4', destination_uuid: null },
+          { uuid: 'random-exit-5', destination_uuid: null }
+        ]
+      } as Node,
+      { type: 'split_by_random' },
+      'ab-test-multiple-variants'
+    );
+
+    helper.testNode(
+      {
+        uuid: 'test-random-node-4',
+        actions: [],
+        router: {
+          type: 'random',
+          categories: [
+            {
+              uuid: 'random-cat-1',
+              name: 'Sample Group',
+              exit_uuid: 'random-exit-1'
+            },
+            {
+              uuid: 'random-cat-2',
+              name: 'Remaining Population',
+              exit_uuid: 'random-exit-2'
+            }
+          ]
+        },
+        exits: [
+          { uuid: 'random-exit-1', destination_uuid: null },
+          { uuid: 'random-exit-2', destination_uuid: null }
+        ]
+      } as Node,
+      { type: 'split_by_random' },
+      'sampling-split'
+    );
+  });
+});

package/test/nodes/wait_for_digits.test.ts

@@ -0,0 +1,176 @@
+import { expect } from '@open-wc/testing';
+import { wait_for_digits } from '../../src/flow/nodes/wait_for_digits';
+import { Node } from '../../src/store/flow-definition';
+import { NodeTest } from '../NodeHelper';
+
+/**
+ * Test suite for the wait_for_digits node configuration.
+ */
+describe('wait_for_digits node config', () => {
+  const helper = new NodeTest(wait_for_digits, 'wait_for_digits');
+
+  describe('basic properties', () => {
+    helper.testBasicProperties();
+
+    it('has correct name', () => {
+      expect(wait_for_digits.name).to.equal('Wait for Digits');
+    });
+
+    it('has correct type', () => {
+      expect(wait_for_digits.type).to.equal('wait_for_digits');
+    });
+
+    it('has correct color', () => {
+      expect(wait_for_digits.color).to.exist;
+    });
+
+    it('is a simple node config without form or layout', () => {
+      expect(wait_for_digits.form).to.be.undefined;
+      expect(wait_for_digits.layout).to.be.undefined;
+      expect(wait_for_digits.toFormData).to.be.undefined;
+      expect(wait_for_digits.fromFormData).to.be.undefined;
+    });
+  });
+
+  describe('node scenarios', () => {
+    helper.testNode(
+      {
+        uuid: 'test-digits-node-1',
+        actions: [],
+        router: {
+          type: 'switch',
+          wait: {
+            type: 'msg',
+            hint: {
+              type: 'digits',
+              count: 4
+            }
+          },
+          result_name: 'digits',
+          categories: [
+            {
+              uuid: 'digits-cat-1',
+              name: 'Has Number',
+              exit_uuid: 'digits-exit-1'
+            },
+            { uuid: 'digits-cat-2', name: 'Other', exit_uuid: 'digits-exit-2' }
+          ]
+        },
+        exits: [
+          { uuid: 'digits-exit-1', destination_uuid: null },
+          { uuid: 'digits-exit-2', destination_uuid: null }
+        ]
+      } as Node,
+      { type: 'wait_for_digits' },
+      'basic-digits-wait'
+    );
+
+    helper.testNode(
+      {
+        uuid: 'test-digits-node-2',
+        actions: [],
+        router: {
+          type: 'switch',
+          wait: {
+            type: 'msg',
+            hint: {
+              type: 'digits',
+              count: 1
+            },
+            timeout: {
+              category_uuid: 'timeout-cat',
+              seconds: 30
+            }
+          },
+          result_name: 'pin_digit',
+          categories: [
+            {
+              uuid: 'digits-cat-1',
+              name: 'Has Number',
+              exit_uuid: 'digits-exit-1'
+            },
+            {
+              uuid: 'timeout-cat',
+              name: 'No Response',
+              exit_uuid: 'timeout-exit'
+            },
+            { uuid: 'digits-cat-2', name: 'Other', exit_uuid: 'digits-exit-2' }
+          ]
+        },
+        exits: [
+          { uuid: 'digits-exit-1', destination_uuid: null },
+          { uuid: 'timeout-exit', destination_uuid: null },
+          { uuid: 'digits-exit-2', destination_uuid: null }
+        ]
+      } as Node,
+      { type: 'wait_for_digits' },
+      'single-digit-with-timeout'
+    );
+
+    helper.testNode(
+      {
+        uuid: 'test-digits-node-3',
+        actions: [],
+        router: {
+          type: 'switch',
+          wait: {
+            type: 'msg',
+            hint: {
+              type: 'digits',
+              count: 10
+            }
+          },
+          result_name: 'phone_number',
+          categories: [
+            {
+              uuid: 'phone-cat-1',
+              name: 'Valid Phone',
+              exit_uuid: 'phone-exit-1'
+            },
+            { uuid: 'phone-cat-2', name: 'Invalid', exit_uuid: 'phone-exit-2' },
+            { uuid: 'phone-cat-3', name: 'Other', exit_uuid: 'phone-exit-3' }
+          ]
+        },
+        exits: [
+          { uuid: 'phone-exit-1', destination_uuid: null },
+          { uuid: 'phone-exit-2', destination_uuid: null },
+          { uuid: 'phone-exit-3', destination_uuid: null }
+        ]
+      } as Node,
+      { type: 'wait_for_digits' },
+      'phone-number-collection'
+    );
+
+    helper.testNode(
+      {
+        uuid: 'test-digits-node-4',
+        actions: [],
+        router: {
+          type: 'switch',
+          wait: {
+            type: 'msg',
+            hint: {
+              type: 'digits',
+              count: 6
+            }
+          },
+          result_name: 'verification_code',
+          categories: [
+            {
+              uuid: 'code-cat-1',
+              name: 'Valid Code',
+              exit_uuid: 'code-exit-1'
+            },
+            { uuid: 'code-cat-2', name: 'Other', exit_uuid: 'code-exit-2' }
+          ]
+        },
+        exits: [
+          { uuid: 'code-exit-1', destination_uuid: null },
+          { uuid: 'code-exit-2', destination_uuid: null }
+        ]
+      } as Node,
+      { type: 'wait_for_digits' },
+      'verification-code'
+    );
+  });
+});

package/test/nodes/wait_for_response.test.ts

@@ -0,0 +1,206 @@
+import { expect } from '@open-wc/testing';
+import { wait_for_response } from '../../src/flow/nodes/wait_for_response';
+import { Node } from '../../src/store/flow-definition';
+import { NodeTest } from '../NodeHelper';
+
+/**
+ * Test suite for the wait_for_response node configuration.
+ */
+describe('wait_for_response node config', () => {
+  const helper = new NodeTest(wait_for_response, 'wait_for_response');
+
+  describe('basic properties', () => {
+    helper.testBasicProperties();
+
+    it('has correct name', () => {
+      expect(wait_for_response.name).to.equal('Wait for Response');
+    });
+
+    it('has correct type', () => {
+      expect(wait_for_response.type).to.equal('wait_for_response');
+    });
+
+    it('has form configuration', () => {
+      expect(wait_for_response.form).to.exist;
+      expect(wait_for_response.form.result_name).to.exist;
+    });
+
+    it('has layout configuration', () => {
+      expect(wait_for_response.layout).to.exist;
+      expect(wait_for_response.layout).to.deep.equal([
+        'timeout',
+        'result_name'
+      ]);
+    });
+  });
+
+  describe('node scenarios', () => {
+    helper.testNode(
+      {
+        uuid: 'test-wait-node-1',
+        actions: [],
+        router: {
+          type: 'switch',
+          wait: {
+            type: 'msg',
+            timeout: {
+              category_uuid: 'timeout-cat-1',
+              seconds: 300
+            }
+          },
+          result_name: 'response',
+          categories: [
+            {
+              uuid: 'timeout-cat-1',
+              name: 'No Response',
+              exit_uuid: 'timeout-exit-1'
+            }
+          ]
+        },
+        exits: [{ uuid: 'timeout-exit-1', destination_uuid: null }]
+      } as Node,
+      { type: 'wait_for_response' },
+      'basic-wait'
+    );
+
+    helper.testNode(
+      {
+        uuid: 'test-wait-node-2',
+        actions: [],
+        router: {
+          type: 'switch',
+          wait: {
+            type: 'msg',
+            timeout: {
+              category_uuid: 'timeout-cat-2',
+              seconds: 1800
+            }
+          },
+          result_name: 'user_input',
+          categories: [
+            {
+              uuid: 'timeout-cat-2',
+              name: 'No Response',
+              exit_uuid: 'timeout-exit-2'
+            }
+          ]
+        },
+        exits: [{ uuid: 'timeout-exit-2', destination_uuid: null }]
+      } as Node,
+      { type: 'wait_for_response' },
+      'custom-result-name'
+    );
+
+    helper.testNode(
+      {
+        uuid: 'test-wait-node-3',
+        actions: [],
+        router: {
+          type: 'switch',
+          wait: {
+            type: 'msg',
+            timeout: {
+              category_uuid: 'timeout-cat-3',
+              seconds: 60
+            }
+          },
+          result_name: 'quick_response',
+          categories: [
+            {
+              uuid: 'timeout-cat-3',
+              name: 'No Response',
+              exit_uuid: 'timeout-exit-3'
+            }
+          ]
+        },
+        exits: [{ uuid: 'timeout-exit-3', destination_uuid: null }]
+      } as Node,
+      { type: 'wait_for_response' },
+      'short-timeout'
+    );
+
+    helper.testNode(
+      {
+        uuid: 'test-wait-node-4',
+        actions: [],
+        router: {
+          type: 'switch',
+          wait: {
+            type: 'msg'
+            // No timeout specified
+          },
+          result_name: 'response',
+          categories: []
+        },
+        exits: []
+      } as Node,
+      { type: 'wait_for_response' },
+      'no-timeout'
+    );
+  });
+
+  describe('data transformation', () => {
+    it('converts node to form data correctly', () => {
+      const node: Node = {
+        uuid: 'test-node',
+        actions: [],
+        router: {
+          type: 'switch',
+          result_name: 'user_response',
+          categories: []
+        },
+        exits: []
+      };
+
+      const formData = wait_for_response.toFormData!(node);
+
+      expect(formData.uuid).to.equal('test-node');
+      expect(formData.result_name).to.equal('user_response');
+    });
+
+    it('converts form data to node correctly', () => {
+      const formData = {
+        uuid: 'test-node',
+        result_name: 'custom_response'
+      };
+
+      const originalNode: Node = {
+        uuid: 'test-node',
+        actions: [],
+        exits: [],
+        router: {
+          type: 'switch',
+          result_name: 'response',
+          categories: []
+        }
+      };
+
+      const result = wait_for_response.fromFormData!(formData, originalNode);
+
+      expect(result.uuid).to.equal('test-node');
+      expect(result.router?.result_name).to.equal('custom_response');
+    });
+
+    it('handles default result name', () => {
+      const formData = {
+        uuid: 'test-node'
+        // No result_name specified
+      };
+
+      const originalNode: Node = {
+        uuid: 'test-node',
+        actions: [],
+        exits: [],
+        router: {
+          type: 'switch',
+          categories: []
+        }
+      };
+
+      const result = wait_for_response.fromFormData!(formData, originalNode);
+
+      expect(result.uuid).to.equal('test-node');
+      expect(result.router?.result_name).to.equal('response');
+    });
+  });
+});

package/test/temba-add-input-labels.test.ts

@@ -0,0 +1,87 @@
+import { fixture, expect } from '@open-wc/testing';
+import { html } from 'lit';
+import { NodeEditor } from '../src/flow/NodeEditor';
+import { AddInputLabels } from '../src/store/flow-definition';
+
+// Register the component
+customElements.define('temba-node-editor', NodeEditor);
+
+describe('add_input_labels action editor', () => {
+  it('renders form editor for add_input_labels action', async () => {
+    const action: AddInputLabels = {
+      uuid: 'test-action-uuid',
+      type: 'add_input_labels',
+      labels: [
+        { uuid: 'label-1', name: 'Important' },
+        { uuid: 'label-2', name: 'Spam' }
+      ]
+    };
+
+    const el = (await fixture(html`
+      <temba-node-editor .action=${action} .isOpen=${true}></temba-node-editor>
+    `)) as NodeEditor;
+
+    await el.updateComplete;
+    expect(el.shadowRoot).to.not.be.null;
+    expect(el.action).to.equal(action);
+  });
+
+  it('can create new labels through the multi-select', async () => {
+    const action: AddInputLabels = {
+      uuid: 'test-action-uuid',
+      type: 'add_input_labels',
+      labels: []
+    };
+
+    const el = (await fixture(html`
+      <temba-node-editor .action=${action} .isOpen=${true}></temba-node-editor>
+    `)) as NodeEditor;
+
+    await el.updateComplete;
+
+    // Find the select element for labels
+    const selectElement = el.shadowRoot?.querySelector(
+      'temba-select[name="labels"]'
+    );
+    expect(selectElement).to.not.be.null;
+
+    // Verify it has the correct configuration (no longer checking for tags)
+    expect(selectElement?.getAttribute('multi')).to.not.be.null;
+    expect(selectElement?.getAttribute('searchable')).to.not.be.null;
+    expect(selectElement?.getAttribute('endpoint')).to.equal(
+      '/api/v2/labels.json'
+    );
+  });
+
+  it('transforms form data correctly', async () => {
+    const action: AddInputLabels = {
+      uuid: 'test-action-uuid',
+      type: 'add_input_labels',
+      labels: [
+        { uuid: 'label-1', name: 'Important' },
+        { uuid: 'label-2', name: 'Follow Up' }
+      ]
+    };
+
+    const el = (await fixture(html`
+      <temba-node-editor .action=${action} .isOpen=${true}></temba-node-editor>
+    `)) as NodeEditor;
+
+    await el.updateComplete;
+
+    // Test toFormData transformation
+    const expectedFormData = {
+      labels: [
+        { uuid: 'label-1', name: 'Important' },
+        { uuid: 'label-2', name: 'Follow Up' }
+      ],
+      uuid: 'test-action-uuid'
+    };
+
+    // Access the private formData property
+    const formData = (el as any).formData;
+    expect(formData).to.not.be.undefined;
+    expect(formData.labels).to.deep.equal(expectedFormData.labels);
+    expect(formData.uuid).to.equal(expectedFormData.uuid);
+  });
+});