@nyaruka/temba-components 0.139.0 → 0.140.0

package/test/actions/play_audio.test.ts

@@ -0,0 +1,155 @@
+import { expect } from '@open-wc/testing';
+import { play_audio } from '../../src/flow/actions/play_audio';
+import { PlayAudio } from '../../src/store/flow-definition';
+import { ActionTest } from '../ActionHelper';
+
+/**
+ * Test suite for the play_audio action configuration.
+ */
+describe('play_audio action config', () => {
+  const helper = new ActionTest(play_audio, 'play_audio');
+
+  describe('basic properties', () => {
+    helper.testBasicProperties();
+
+    it('has correct name', () => {
+      expect(play_audio.name).to.equal('Play Recording');
+    });
+
+    it('is voice-only', () => {
+      expect(play_audio.flowTypes).to.deep.equal(['voice']);
+    });
+  });
+
+  describe('action scenarios', () => {
+    helper.testAction(
+      {
+        uuid: 'test-play-1',
+        type: 'play_audio',
+        audio_url: '@results.voicemail'
+      } as PlayAudio,
+      'expression-url'
+    );
+
+    helper.testAction(
+      {
+        uuid: 'test-play-2',
+        type: 'play_audio',
+        audio_url: 'https://example.com/greeting.mp3'
+      } as PlayAudio,
+      'static-url'
+    );
+  });
+
+  describe('data transformation', () => {
+    it('converts action to form data', () => {
+      const action: PlayAudio = {
+        uuid: 'test-action',
+        type: 'play_audio',
+        audio_url: '@results.voicemail'
+      };
+
+      const formData = play_audio.toFormData!(action);
+      expect(formData.uuid).to.equal('test-action');
+      expect(formData.audio_url).to.equal('@results.voicemail');
+    });
+
+    it('handles missing audio_url', () => {
+      const action = {
+        uuid: 'test-action',
+        type: 'play_audio'
+      } as PlayAudio;
+
+      const formData = play_audio.toFormData!(action);
+      expect(formData.audio_url).to.equal('');
+    });
+
+    it('converts form data to action', () => {
+      const formData = {
+        uuid: 'test-action',
+        audio_url: '@results.voicemail'
+      };
+
+      const action = play_audio.fromFormData!(formData) as PlayAudio;
+      expect(action.uuid).to.equal('test-action');
+      expect(action.type).to.equal('play_audio');
+      expect(action.audio_url).to.equal('@results.voicemail');
+    });
+
+    it('trims whitespace from audio_url', () => {
+      const formData = {
+        uuid: 'test-action',
+        audio_url: '  @results.voicemail  '
+      };
+
+      const action = play_audio.fromFormData!(formData) as PlayAudio;
+      expect(action.audio_url).to.equal('@results.voicemail');
+    });
+  });
+
+  describe('localization', () => {
+    it('converts localization to form data', () => {
+      const action: PlayAudio = {
+        uuid: 'test-action',
+        type: 'play_audio',
+        audio_url: '@results.voicemail'
+      };
+
+      const localization = {
+        audio_url: ['@results.voicemail_es']
+      };
+
+      const formData = play_audio.toLocalizationFormData!(action, localization);
+      expect(formData.audio_url).to.equal('@results.voicemail_es');
+    });
+
+    it('handles missing localization', () => {
+      const action: PlayAudio = {
+        uuid: 'test-action',
+        type: 'play_audio',
+        audio_url: '@results.voicemail'
+      };
+
+      const formData = play_audio.toLocalizationFormData!(action, {});
+      expect(formData.audio_url).to.equal('');
+    });
+
+    it('converts form data to localization', () => {
+      const action: PlayAudio = {
+        uuid: 'test-action',
+        type: 'play_audio',
+        audio_url: '@results.voicemail'
+      };
+
+      const formData = {
+        uuid: 'test-action',
+        audio_url: '@results.voicemail_es'
+      };
+
+      const localization = play_audio.fromLocalizationFormData!(
+        formData,
+        action
+      );
+      expect(localization.audio_url).to.deep.equal(['@results.voicemail_es']);
+    });
+
+    it('omits unchanged localization', () => {
+      const action: PlayAudio = {
+        uuid: 'test-action',
+        type: 'play_audio',
+        audio_url: '@results.voicemail'
+      };
+
+      const formData = {
+        uuid: 'test-action',
+        audio_url: '@results.voicemail' // same as original
+      };
+
+      const localization = play_audio.fromLocalizationFormData!(
+        formData,
+        action
+      );
+      expect(localization.audio_url).to.be.undefined;
+    });
+  });
+});

package/test/actions/say_msg.test.ts

@@ -0,0 +1,196 @@
+import { expect } from '@open-wc/testing';
+import { say_msg } from '../../src/flow/actions/say_msg';
+import { SayMsg } from '../../src/store/flow-definition';
+import { ActionTest } from '../ActionHelper';
+
+/**
+ * Test suite for the say_msg action configuration.
+ */
+describe('say_msg action config', () => {
+  const helper = new ActionTest(say_msg, 'say_msg');
+
+  describe('basic properties', () => {
+    helper.testBasicProperties();
+
+    it('has correct name', () => {
+      expect(say_msg.name).to.equal('Say Message');
+    });
+
+    it('is voice-only', () => {
+      expect(say_msg.flowTypes).to.deep.equal(['voice']);
+    });
+  });
+
+  describe('action scenarios', () => {
+    helper.testAction(
+      {
+        uuid: 'test-say-1',
+        type: 'say_msg',
+        text: 'Hello, welcome to our service.'
+      } as SayMsg,
+      'simple-text'
+    );
+
+    helper.testAction(
+      {
+        uuid: 'test-say-2',
+        type: 'say_msg',
+        text: 'Press 1 for sales.\nPress 2 for support.\nPress 3 to leave a message.'
+      } as SayMsg,
+      'multiline-text'
+    );
+
+    helper.testAction(
+      {
+        uuid: 'test-say-3',
+        type: 'say_msg',
+        text: 'Please listen to the following recording.',
+        audio_url: 'https://example.com/greeting.mp3'
+      } as SayMsg,
+      'text-with-audio-url'
+    );
+  });
+
+  describe('data transformation', () => {
+    it('converts action to form data', () => {
+      const action: SayMsg = {
+        uuid: 'test-action',
+        type: 'say_msg',
+        text: 'Hello world',
+        audio_url: 'https://example.com/audio.mp3'
+      };
+
+      const formData = say_msg.toFormData!(action);
+      expect(formData.uuid).to.equal('test-action');
+      expect(formData.text).to.equal('Hello world');
+      expect(formData.audio_url).to.equal('https://example.com/audio.mp3');
+    });
+
+    it('handles missing audio_url in toFormData', () => {
+      const action: SayMsg = {
+        uuid: 'test-action',
+        type: 'say_msg',
+        text: 'Hello'
+      } as SayMsg;
+
+      const formData = say_msg.toFormData!(action);
+      expect(formData.audio_url).to.equal('');
+    });
+
+    it('converts form data to action', () => {
+      const formData = {
+        uuid: 'test-action',
+        text: 'Hello world',
+        audio_url: 'https://example.com/audio.mp3'
+      };
+
+      const action = say_msg.fromFormData!(formData) as SayMsg;
+      expect(action.uuid).to.equal('test-action');
+      expect(action.type).to.equal('say_msg');
+      expect(action.text).to.equal('Hello world');
+      expect(action.audio_url).to.equal('https://example.com/audio.mp3');
+    });
+
+    it('omits empty audio_url in fromFormData', () => {
+      const formData = {
+        uuid: 'test-action',
+        text: 'Hello world',
+        audio_url: ''
+      };
+
+      const action = say_msg.fromFormData!(formData) as SayMsg;
+      expect(action.audio_url).to.be.undefined;
+    });
+
+    it('trims whitespace from audio_url', () => {
+      const formData = {
+        uuid: 'test-action',
+        text: 'Hello',
+        audio_url: '  https://example.com/audio.mp3  '
+      };
+
+      const action = say_msg.fromFormData!(formData) as SayMsg;
+      expect(action.audio_url).to.equal('https://example.com/audio.mp3');
+    });
+  });
+
+  describe('sanitize', () => {
+    it('trims text whitespace', () => {
+      const formData = { text: '  Hello world  ' };
+      say_msg.sanitize!(formData);
+      expect(formData.text).to.equal('Hello world');
+    });
+  });
+
+  describe('localization', () => {
+    it('converts localization to form data', () => {
+      const action: SayMsg = {
+        uuid: 'test-action',
+        type: 'say_msg',
+        text: 'Hello',
+        audio_url: 'https://example.com/en.mp3'
+      };
+
+      const localization = {
+        text: ['Hola'],
+        audio_url: ['https://example.com/es.mp3']
+      };
+
+      const formData = say_msg.toLocalizationFormData!(action, localization);
+      expect(formData.text).to.equal('Hola');
+      expect(formData.audio_url).to.equal('https://example.com/es.mp3');
+    });
+
+    it('handles missing localization fields', () => {
+      const action: SayMsg = {
+        uuid: 'test-action',
+        type: 'say_msg',
+        text: 'Hello'
+      } as SayMsg;
+
+      const formData = say_msg.toLocalizationFormData!(action, {});
+      expect(formData.text).to.equal('');
+      expect(formData.audio_url).to.equal('');
+    });
+
+    it('converts form data to localization', () => {
+      const action: SayMsg = {
+        uuid: 'test-action',
+        type: 'say_msg',
+        text: 'Hello',
+        audio_url: 'https://example.com/en.mp3'
+      };
+
+      const formData = {
+        uuid: 'test-action',
+        text: 'Hola',
+        audio_url: 'https://example.com/es.mp3'
+      };
+
+      const localization = say_msg.fromLocalizationFormData!(formData, action);
+      expect(localization.text).to.deep.equal(['Hola']);
+      expect(localization.audio_url).to.deep.equal([
+        'https://example.com/es.mp3'
+      ]);
+    });
+
+    it('omits unchanged localization fields', () => {
+      const action: SayMsg = {
+        uuid: 'test-action',
+        type: 'say_msg',
+        text: 'Hello',
+        audio_url: 'https://example.com/en.mp3'
+      };
+
+      const formData = {
+        uuid: 'test-action',
+        text: 'Hello', // same as original
+        audio_url: 'https://example.com/en.mp3' // same as original
+      };
+
+      const localization = say_msg.fromLocalizationFormData!(formData, action);
+      expect(localization.text).to.be.undefined;
+      expect(localization.audio_url).to.be.undefined;
+    });
+  });
+});

package/test/nodes/wait_for_audio.test.ts

@@ -0,0 +1,182 @@
+import { expect } from '@open-wc/testing';
+import { wait_for_audio } from '../../src/flow/nodes/wait_for_audio';
+import { Node } from '../../src/store/flow-definition';
+import { NodeTest } from '../NodeHelper';
+
+/**
+ * Test suite for the wait_for_audio node configuration.
+ */
+describe('wait_for_audio node config', () => {
+  const helper = new NodeTest(wait_for_audio, 'wait_for_audio');
+
+  describe('basic properties', () => {
+    helper.testBasicProperties();
+
+    it('has correct name', () => {
+      expect(wait_for_audio.name).to.equal('Make Recording');
+    });
+
+    it('has correct type', () => {
+      expect(wait_for_audio.type).to.equal('wait_for_audio');
+    });
+
+    it('is voice-only', () => {
+      expect(wait_for_audio.flowTypes).to.deep.equal(['voice']);
+    });
+
+    it('has form with result_name field', () => {
+      expect(wait_for_audio.form).to.exist;
+      expect(wait_for_audio.form!.result_name).to.exist;
+    });
+
+    it('has layout', () => {
+      expect(wait_for_audio.layout).to.deep.equal(['result_name']);
+    });
+  });
+
+  describe('node scenarios', () => {
+    it('renders basic audio wait', async () => {
+      await helper.testNode(
+        {
+          uuid: 'test-audio-node-1',
+          actions: [],
+          router: {
+            type: 'switch',
+            operand: '@input',
+            wait: {
+              type: 'msg',
+              hint: { type: 'audio' }
+            },
+            result_name: 'recording',
+            default_category_uuid: 'all-cat-1',
+            cases: [],
+            categories: [
+              {
+                uuid: 'all-cat-1',
+                name: 'All Responses',
+                exit_uuid: 'all-exit-1'
+              }
+            ]
+          },
+          exits: [{ uuid: 'all-exit-1', destination_uuid: null }]
+        } as Node,
+        { type: 'wait_for_audio' },
+        'basic-audio-wait'
+      );
+    });
+  });
+
+  describe('data transformation', () => {
+    it('converts node to form data', () => {
+      const node: Node = {
+        uuid: 'test-node',
+        actions: [],
+        router: {
+          type: 'switch',
+          result_name: 'my_recording',
+          categories: []
+        },
+        exits: []
+      };
+
+      const formData = wait_for_audio.toFormData!(node);
+      expect(formData.uuid).to.equal('test-node');
+      expect(formData.result_name).to.equal('my_recording');
+    });
+
+    it('handles missing result_name', () => {
+      const node: Node = {
+        uuid: 'test-node',
+        actions: [],
+        router: {
+          type: 'switch',
+          categories: []
+        },
+        exits: []
+      };
+
+      const formData = wait_for_audio.toFormData!(node);
+      expect(formData.result_name).to.equal('');
+    });
+
+    it('creates node with All Responses category', () => {
+      const formData = {
+        uuid: 'test-node',
+        result_name: 'recording'
+      };
+
+      const originalNode: Node = {
+        uuid: 'test-node',
+        actions: [],
+        exits: [],
+        router: {
+          type: 'switch',
+          categories: []
+        }
+      };
+
+      const result = wait_for_audio.fromFormData!(formData, originalNode);
+
+      expect(result.router?.categories).to.have.length(1);
+      expect(result.router?.categories[0].name).to.equal('All Responses');
+      expect(result.router?.wait?.type).to.equal('msg');
+      expect(result.router?.wait?.hint?.type).to.equal('audio');
+      expect(result.router?.result_name).to.equal('recording');
+      expect(result.exits).to.have.length(1);
+    });
+
+    it('preserves existing All Responses category UUID', () => {
+      const formData = {
+        uuid: 'test-node',
+        result_name: 'recording'
+      };
+
+      const originalNode: Node = {
+        uuid: 'test-node',
+        actions: [],
+        router: {
+          type: 'switch',
+          categories: [
+            {
+              uuid: 'existing-cat-uuid',
+              name: 'All Responses',
+              exit_uuid: 'existing-exit-uuid'
+            }
+          ]
+        },
+        exits: [
+          {
+            uuid: 'existing-exit-uuid',
+            destination_uuid: 'some-destination'
+          }
+        ]
+      };
+
+      const result = wait_for_audio.fromFormData!(formData, originalNode);
+
+      expect(result.router?.categories[0].uuid).to.equal('existing-cat-uuid');
+      expect(result.router?.categories[0].exit_uuid).to.equal(
+        'existing-exit-uuid'
+      );
+      expect(result.exits[0].uuid).to.equal('existing-exit-uuid');
+      expect(result.exits[0].destination_uuid).to.equal('some-destination');
+    });
+
+    it('omits result_name when empty', () => {
+      const formData = {
+        uuid: 'test-node',
+        result_name: ''
+      };
+
+      const originalNode: Node = {
+        uuid: 'test-node',
+        actions: [],
+        exits: [],
+        router: { type: 'switch', categories: [] }
+      };
+
+      const result = wait_for_audio.fromFormData!(formData, originalNode);
+      expect(result.router?.result_name).to.be.undefined;
+    });
+  });
+});