@capillarytech/creatives-library 9.0.13 → 9.0.14-beta.0

package/v2Components/FormBuilder/Functional/tests/fixtures/smsParityCases.js

@@ -0,0 +1,192 @@
+/**
+ * SMS cross-flow parity fixtures.
+ *
+ * A single source of truth describing, for a range of SMS content combinations,
+ * the result the FormBuilder must produce — validity, per-field error type, and
+ * the legacy formData payload the container hands to getChannelData(SMS) on save.
+ *
+ * The same array is fed to BOTH the legacy (Classic) and the new (Functional)
+ * FormBuilder in sms.crossFlowParity.test.js, in BOTH full mode and library mode.
+ * Each case asserts Classic ≡ Functional ≡ `expected`, so any divergence between
+ * the two flows (or from the documented contract) fails the suite.
+ *
+ * Field-error vocabulary (legacy errorData values, identical in both flows):
+ *   editorError  -> errorData[0]['sms-editor']:
+ *                     false | 'genericValidationError' | 'tagBracketCountMismatchError'
+ *   unicodeError -> errorData[0]['unicode-validity']: boolean
+ *   nameError    -> errorData['template-name']: boolean
+ *
+ * Payload = getChannelData('SMS', formData) = `${base['sms-editor']} ${template-name}`.
+ * (Note the documented quirk: it is a template literal, so empty parts render as
+ * the literal text — e.g. an empty name yields a trailing space, not "".)
+ *
+ * `modes` lists the modes a case runs in. `embedded: true` sets query.type
+ * 'embedded' (the engine then drops the template-name requirement, mirroring the
+ * container's removeStandAlone trim).
+ */
+
+export const SMS_PARITY_CASES = [
+  {
+    id: 'plain-ascii',
+    description: 'Plain GSM-7 content + name → valid, submits',
+    content: 'Hello world',
+    name: 'Promo',
+    allowUnicode: false,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: true,
+      editorError: false,
+      unicodeError: false,
+      nameError: false,
+      submits: true,
+      payload: 'Hello world Promo',
+    },
+  },
+  {
+    id: 'gsm-extended-symbols',
+    description: 'GSM-7 extended symbols (£, @) are NOT unicode → valid without the checkbox',
+    content: 'Cost £5 @home',
+    name: 'Promo',
+    allowUnicode: false,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: true,
+      editorError: false,
+      unicodeError: false,
+      nameError: false,
+      submits: true,
+      payload: 'Cost £5 @home Promo',
+    },
+  },
+  {
+    id: 'leading-trailing-spaces',
+    description: 'Spacing in content is preserved verbatim in the payload',
+    content: '  hi  ',
+    name: 'Promo',
+    allowUnicode: false,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: true,
+      editorError: false,
+      unicodeError: false,
+      nameError: false,
+      submits: true,
+      payload: '  hi   Promo',
+    },
+  },
+  {
+    id: 'long-multisegment',
+    description: 'Long (multi-segment) content does not block save; payload preserved',
+    content: 'A'.repeat(200),
+    name: 'Bulk',
+    allowUnicode: false,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: true,
+      editorError: false,
+      unicodeError: false,
+      nameError: false,
+      submits: true,
+      payload: `${'A'.repeat(200)} Bulk`,
+    },
+  },
+  {
+    id: 'empty-content',
+    description: 'Empty content → generic editor error, blocks save',
+    content: '',
+    name: 'Promo',
+    allowUnicode: false,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: false,
+      editorError: 'genericValidationError',
+      unicodeError: false,
+      nameError: false,
+      submits: false,
+      payload: null,
+    },
+  },
+  {
+    id: 'empty-name-full',
+    description: 'Empty name (non-embedded) → template-name error, blocks save',
+    content: 'Hello',
+    name: '',
+    allowUnicode: false,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: false,
+      editorError: false,
+      unicodeError: false,
+      nameError: true,
+      submits: false,
+      payload: null,
+    },
+  },
+  {
+    id: 'empty-name-embedded',
+    description: 'Empty name in embedded mode → template-name NOT required, submits',
+    content: 'Hello',
+    name: '',
+    allowUnicode: false,
+    embedded: true,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: true,
+      editorError: false,
+      unicodeError: false,
+      nameError: false,
+      submits: true,
+      payload: 'Hello ',
+    },
+  },
+  {
+    id: 'unicode-unchecked',
+    description: 'Unicode content with the checkbox OFF → unicode error, blocks save',
+    content: 'नमस्ते',
+    name: 'Diwali',
+    allowUnicode: false,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: false,
+      editorError: false,
+      unicodeError: true,
+      nameError: false,
+      submits: false,
+      payload: null,
+    },
+  },
+  {
+    id: 'unicode-checked',
+    description: 'Unicode content with the checkbox ON → valid, submits',
+    content: 'नमस्ते',
+    name: 'Diwali',
+    allowUnicode: true,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: true,
+      editorError: false,
+      unicodeError: false,
+      nameError: false,
+      submits: true,
+      payload: 'नमस्ते Diwali',
+    },
+  },
+  {
+    id: 'unbalanced-braces',
+    description: 'Unbalanced {{ → bracket error, blocks save (the "close all curly braces" case)',
+    content: 'Hi {{name',
+    name: 'Promo',
+    allowUnicode: false,
+    modes: ['full', 'library'],
+    expected: {
+      isValid: false,
+      editorError: 'tagBracketCountMismatchError',
+      unicodeError: false,
+      nameError: false,
+      submits: false,
+      payload: null,
+    },
+  },
+];
+
+export default SMS_PARITY_CASES;

package/v2Components/FormBuilder/Functional/tests/formReducer.test.js

@@ -0,0 +1,129 @@
+/**
+ * Unit tests for the V3 form reducer + selectors.
+ * Pins: action behavior, structural sharing (untouched slices keep identity),
+ * and no-op identity preservation.
+ */
+
+import formReducer, {
+  createInitialState,
+  hydrate,
+  fieldChanged,
+  validationResult,
+} from '../core/store/formReducer';
+import {
+  selectFieldValue,
+  selectFieldError,
+  selectIsFormValid,
+  selectBaseTabIndex,
+} from '../core/store/selectors';
+
+const seededState = () => ({
+  ...createInitialState('SMS'),
+  root: { 'template-name': '' },
+  tabs: [{ fields: { 'sms-editor': '', 'unicode-validity': false }, base: true, tabKey: 'k0' }],
+  errors: { root: {}, tabs: [{}] },
+});
+
+describe('formReducer', () => {
+  it('returns the same state for an unknown action', () => {
+    const s = seededState();
+    expect(formReducer(s, { type: 'nope' })).toBe(s);
+  });
+
+  it('HYDRATE replaces state', () => {
+    const next = seededState();
+    expect(formReducer(createInitialState('SMS'), hydrate(next))).toBe(next);
+  });
+
+  it('HYDRATE with a falsy payload keeps the current state', () => {
+    const s = seededState();
+    expect(formReducer(s, { type: 'fb/HYDRATE', state: null })).toBe(s);
+  });
+
+  it('createInitialState defaults the channel to null', () => {
+    expect(createInitialState().meta.channel).toBeNull();
+  });
+
+  describe('FIELD_CHANGED — tab field', () => {
+    it('updates the targeted tab field', () => {
+      const s = seededState();
+      const next = formReducer(s, fieldChanged({ fieldId: 'sms-editor', value: 'hi', tabIndex: 0 }));
+      expect(selectFieldValue(next, { fieldId: 'sms-editor', tabIndex: 0 })).toBe('hi');
+    });
+
+    it('replaces the changed tab object but keeps root identity (structural sharing)', () => {
+      const s = seededState();
+      const next = formReducer(s, fieldChanged({ fieldId: 'sms-editor', value: 'hi', tabIndex: 0 }));
+      expect(next).not.toBe(s);
+      expect(next.tabs[0]).not.toBe(s.tabs[0]); // changed slice gets a new ref
+      expect(next.root).toBe(s.root); // untouched slice keeps identity
+    });
+
+    it('is a no-op (same ref) when the value is unchanged', () => {
+      const s = seededState();
+      const next = formReducer(s, fieldChanged({ fieldId: 'sms-editor', value: '', tabIndex: 0 }));
+      expect(next).toBe(s);
+    });
+
+    it('ignores an out-of-range tabIndex', () => {
+      const s = seededState();
+      expect(formReducer(s, fieldChanged({ fieldId: 'x', value: 'y', tabIndex: 5 }))).toBe(s);
+    });
+
+    it('keeps sibling tabs by reference when one tab changes (structural sharing)', () => {
+      const s = { ...seededState(), tabs: [{ fields: { a: '' } }, { fields: { b: '' } }] };
+      const next = formReducer(s, fieldChanged({ fieldId: 'a', value: 'A', tabIndex: 0 }));
+      expect(next.tabs[0]).not.toBe(s.tabs[0]); // changed tab -> new ref
+      expect(next.tabs[1]).toBe(s.tabs[1]); // sibling tab -> same ref
+    });
+  });
+
+  describe('FIELD_CHANGED — root (standalone) field', () => {
+    it('updates a root field and keeps tabs identity', () => {
+      const s = seededState();
+      const next = formReducer(s, fieldChanged({ fieldId: 'template-name', value: 'My SMS' }));
+      expect(selectFieldValue(next, { fieldId: 'template-name' })).toBe('My SMS');
+      expect(next.tabs).toBe(s.tabs); // untouched
+      expect(next.root).not.toBe(s.root);
+    });
+
+    it('is a no-op (same ref) when the root value is unchanged', () => {
+      const s = seededState();
+      const next = formReducer(s, fieldChanged({ fieldId: 'template-name', value: '' }));
+      expect(next).toBe(s);
+    });
+  });
+
+  describe('VALIDATION_RESULT', () => {
+    it('merges errors + validity', () => {
+      const s = seededState();
+      const errors = { root: { 'template-name': true }, tabs: [{ 'sms-editor': 'bad' }] };
+      const next = formReducer(s, validationResult({ errors, isFormValid: false }));
+      expect(selectIsFormValid(next)).toBe(false);
+      expect(selectFieldError(next, { fieldId: 'template-name' })).toBe(true);
+      expect(selectFieldError(next, { fieldId: 'sms-editor', tabIndex: 0 })).toBe('bad');
+    });
+
+    it('coerces isFormValid to boolean', () => {
+      const s = seededState();
+      const next = formReducer(s, validationResult({ errors: s.errors, isFormValid: 1 }));
+      expect(selectIsFormValid(next)).toBe(true);
+    });
+
+    it('falls back to existing errors + liquidErrorMessage when omitted', () => {
+      const s = seededState();
+      const next = formReducer(s, { type: 'fb/VALIDATION_RESULT', isFormValid: true });
+      expect(next.errors).toBe(s.errors); // fallback to prior errors
+      expect(next.validity.liquidErrorMessage).toBe(s.validity.liquidErrorMessage);
+    });
+  });
+
+  describe('selectors', () => {
+    it('selectBaseTabIndex reads meta', () => {
+      expect(selectBaseTabIndex(seededState())).toBe(0);
+    });
+    it('selectFieldValue returns undefined for a missing tab', () => {
+      expect(selectFieldValue(seededState(), { fieldId: 'x', tabIndex: 9 })).toBeUndefined();
+    });
+  });
+});

package/v2Components/FormBuilder/Functional/tests/initializeFormState.test.js

@@ -0,0 +1,132 @@
+/**
+ * Unit tests for initializeFormState, seeded from the REAL bundled SMS schema.
+ * Pins: standalone field -> root, data fields -> tab 0, onlyDisplay fields not
+ * seeded, correct defaults, single base tab with a tabKey.
+ */
+
+import initializeFormState from '../core/schema/initializeFormState';
+import { response as smsSchemaResponse } from '../../../../v2Containers/Sms/initialSchema';
+
+const smsDefinition = smsSchemaResponse.metaEntities[0].definition;
+
+describe('initializeFormState — SMS', () => {
+  const state = initializeFormState(smsDefinition, { generateId: () => 'k0' });
+
+  it('records the channel', () => {
+    expect(state.meta.channel).toBe('SMS');
+  });
+
+  it('creates exactly one base tab with a tabKey', () => {
+    expect(state.tabs).toHaveLength(1);
+    expect(state.tabs[0].base).toBe(true);
+    expect(state.tabs[0].tabKey).toBe('k0');
+    expect(state.meta.baseTabIndex).toBe(0);
+  });
+
+  it('seeds the standalone field (template-name) into root, not into the tab', () => {
+    expect(state.root['template-name']).toBe('');
+    expect(state.tabs[0].fields['template-name']).toBeUndefined();
+  });
+
+  it('seeds tab data fields with correct defaults', () => {
+    expect(state.tabs[0].fields['sms-editor']).toBe(''); // textarea -> ''
+    expect(state.tabs[0].fields['unicode-validity']).toBe(false); // checkbox -> false
+  });
+
+  it('does NOT seed onlyDisplay / UI-control fields', () => {
+    const allSeeded = { ...state.root, ...state.tabs[0].fields };
+    ['tagList', 'sms-count', 'sms-preview', 'save-button', 'test-and-preview-button'].forEach((id) => {
+      expect(allSeeded[id]).toBeUndefined();
+    });
+  });
+
+  it('produces parallel empty error buckets', () => {
+    expect(state.errors).toEqual({ root: {}, tabs: [{}] });
+    expect(state.validity.isFormValid).toBe(false);
+  });
+
+  it('uses an injectable id generator (deterministic in tests)', () => {
+    const s = initializeFormState(smsDefinition, { generateId: () => 'XYZ' });
+    expect(s.tabs[0].tabKey).toBe('XYZ');
+  });
+
+  it('uses the default id generator when none is injected', () => {
+    const s = initializeFormState(smsDefinition);
+    expect(typeof s.tabs[0].tabKey).toBe('string');
+    expect(s.tabs[0].tabKey).toMatch(/^fb-\d+$/);
+  });
+});
+
+// A synthetic schema exercising the traversal branches the bundled SMS schema
+// does not contain: col-label sections, actionFields, an unknown section type,
+// a null section, missing child arrays, and a field carrying an explicit value.
+describe('initializeFormState — traversal branch coverage', () => {
+  const synthetic = {
+    channel: 'SMS',
+    standalone: {
+      sections: [
+        null, // null-section guard
+        { type: 'unknownType' }, // switch default
+        { type: 'parent' }, // parent with no childSections (|| [])
+        {
+          type: 'parent',
+          childSections: [
+            {
+              type: 'multicols',
+              inputFields: [
+                { cols: [{ id: 'name', type: 'input', standalone: true, value: 'seed' }] },
+                { rowClassName: 'row-without-cols' },
+              ],
+              actionFields: [{ cols: [{ id: 'save', type: 'button', onlyDisplay: true }] }],
+            },
+            {
+              type: 'col-label',
+              inputFields: [{ id: 'chk', type: 'checkbox' }, { id: 'body', type: 'textarea' }],
+              actionFields: [{ id: 'lbl', type: 'div', onlyDisplay: true }],
+            },
+            { type: 'multicols' }, // multicols with no input/action fields
+          ],
+        },
+      ],
+    },
+  };
+
+  const state = initializeFormState(synthetic, { generateId: () => 'k0' });
+
+  it('seeds a standalone field carrying an explicit value into root', () => {
+    expect(state.root.name).toBe('seed');
+  });
+
+  it('seeds col-label data fields into tab 0 with correct defaults', () => {
+    expect(state.tabs[0].fields.chk).toBe(false); // checkbox default
+    expect(state.tabs[0].fields.body).toBe(''); // textarea default
+  });
+
+  it('skips onlyDisplay fields (button / div label)', () => {
+    const seeded = { ...state.root, ...state.tabs[0].fields };
+    expect(seeded.save).toBeUndefined();
+    expect(seeded.lbl).toBeUndefined();
+  });
+
+  it('returns a valid state for an empty / missing schema', () => {
+    expect(initializeFormState().tabs).toHaveLength(1);
+    expect(initializeFormState({}).root).toEqual({});
+  });
+
+  it('does not overwrite an already-seeded field id (first occurrence wins)', () => {
+    const schema = {
+      channel: 'SMS',
+      standalone: {
+        sections: [{
+          type: 'col-label',
+          inputFields: [
+            { id: 'dup', type: 'input', value: 'first' },
+            { id: 'dup', type: 'input', value: 'second' },
+          ],
+        }],
+      },
+    };
+    const s = initializeFormState(schema, { generateId: () => 'k0' });
+    expect(s.tabs[0].fields.dup).toBe('first');
+  });
+});

package/v2Components/FormBuilder/Functional/tests/schemaForm.test.js

@@ -0,0 +1,40 @@
+/**
+ * Unit tests for SchemaForm — the standalone-sections walker + its guards.
+ */
+import React from 'react';
+import { render } from '@testing-library/react';
+import SchemaForm from '../layout/SchemaForm';
+
+const Stub = () => <div data-testid="stub">r</div>;
+const registry = { resolve: () => Stub };
+const renderContext = {
+  registry,
+  state: { root: {}, tabs: [{ fields: {} }] },
+  errorData: {},
+  activeTabIndex: 0,
+  onFieldChange: () => {},
+  onFieldBlur: () => {},
+  onEvent: () => {},
+};
+
+describe('SchemaForm', () => {
+  it('renders nothing when schema is missing or has no standalone', () => {
+    const { container: c1 } = render(<SchemaForm schema={null} renderContext={renderContext} />);
+    expect(c1.textContent).toBe('');
+    const { container: c2 } = render(<SchemaForm schema={{}} renderContext={renderContext} />);
+    expect(c2.textContent).toBe('');
+  });
+
+  it('walks standalone.sections and renders each section', () => {
+    const schema = {
+      standalone: {
+        sections: [
+          { type: 'col-label', inputFields: [{ id: 'a', type: 'div' }] },
+          { type: 'col-label', inputFields: [{ id: 'b', type: 'div' }] },
+        ],
+      },
+    };
+    const { getAllByTestId } = render(<SchemaForm schema={schema} renderContext={renderContext} />);
+    expect(getAllByTestId('stub').length).toBe(2);
+  });
+});

package/v2Components/FormBuilder/Functional/tests/section.test.js

@@ -0,0 +1,99 @@
+/**
+ * Unit tests for Section + the exported renderField helper. Covers the three
+ * structural section types, the memoized vs direct render paths, the handler
+ * closures on the direct path, and the unknown-type / unknown-renderer guards.
+ */
+import React from 'react';
+import { render } from '@testing-library/react';
+import Section, { renderField } from '../layout/Section';
+
+const Stub = () => <div data-testid="stub">r</div>;
+// `none` resolves to no renderer; everything else resolves to the stub.
+const registry = { resolve: (type) => (type === 'none' ? null : Stub) };
+
+const ctx = (over = {}) => ({
+  registry,
+  state: { root: { name: 'v' }, tabs: [{ fields: { body: 'b' } }] },
+  errorData: { name: true, 0: { body: 'err' } },
+  activeTabIndex: 0,
+  checkValidation: true,
+  channel: 'SMS',
+  resolvedFieldErrors: { body: 'msg' },
+  onFieldChange: jest.fn(),
+  onFieldBlur: jest.fn(),
+  onEvent: jest.fn(),
+  ...over,
+});
+
+describe('renderField', () => {
+  it('returns null for a field without a type or a null field', () => {
+    expect(renderField(null, ctx())).toBeNull();
+    expect(renderField({ id: 'x' }, ctx())).toBeNull();
+  });
+
+  it('returns null when the registry has no renderer for the type', () => {
+    expect(renderField({ id: 'x', type: 'none' }, ctx())).toBeNull();
+  });
+
+  it('memoized type (input) renders through FieldSlot', () => {
+    const el = renderField({ id: 'name', type: 'input', standalone: true }, ctx());
+    expect(el).toBeTruthy();
+    expect(el.key).toBe('name');
+  });
+
+  it('direct (derived) type wires onChange/onBlur/onEvent to the context handlers', () => {
+    const renderContext = ctx();
+    const field = { id: 'body', type: 'div' }; // not in MEMOIZED_TYPES -> direct path, tab field
+    const el = renderField(field, renderContext);
+    el.props.onChange('x');
+    el.props.onBlur();
+    el.props.onEvent('evt', { a: 1 });
+    expect(renderContext.onFieldChange).toHaveBeenCalledWith(field, 'x');
+    expect(renderContext.onFieldBlur).toHaveBeenCalledWith(field);
+    expect(renderContext.onEvent).toHaveBeenCalledWith(field, 'evt', { a: 1 });
+  });
+
+  it('reads the root error for a standalone field and the tab error otherwise', () => {
+    const standalone = renderField({ id: 'name', type: 'div', standalone: true }, ctx());
+    expect(standalone.props.error).toBe(true); // errorData.name
+    const tabField = renderField({ id: 'body', type: 'div' }, ctx());
+    expect(tabField.props.error).toBe('err'); // errorData[0].body
+  });
+
+  it('error is undefined when the context has no errorData', () => {
+    const el = renderField({ id: 'body', type: 'div' }, ctx({ errorData: undefined }));
+    expect(el.props.error).toBeUndefined();
+  });
+});
+
+describe('Section', () => {
+  it('renders nothing for a null section or an unknown type', () => {
+    const { container: c1 } = render(<Section section={null} renderContext={ctx()} />);
+    expect(c1.textContent).toBe('');
+    const { container: c2 } = render(<Section section={{ type: 'mystery' }} renderContext={ctx()} />);
+    expect(c2.textContent).toBe('');
+  });
+
+  it('renders a parent -> multicols (inputFields + actionFields)', () => {
+    const section = {
+      type: 'parent',
+      childSections: [{
+        type: 'multicols',
+        inputFields: [{ cols: [{ id: 'body', type: 'div' }] }],
+        actionFields: [{ cols: [{ id: 'save', type: 'div' }] }],
+      }],
+    };
+    const { getAllByTestId } = render(<Section section={section} renderContext={ctx()} />);
+    expect(getAllByTestId('stub').length).toBe(2);
+  });
+
+  it('renders a col-label section (inputFields + actionFields)', () => {
+    const section = {
+      type: 'col-label',
+      inputFields: [{ id: 'body', type: 'div' }],
+      actionFields: [{ id: 'save', type: 'div' }],
+    };
+    const { getAllByTestId } = render(<Section section={section} renderContext={ctx()} />);
+    expect(getAllByTestId('stub').length).toBe(2);
+  });
+});

package/v2Components/FormBuilder/Functional/tests/selectors.test.js

@@ -0,0 +1,67 @@
+/**
+ * Unit tests for the state selectors — covers root vs tab paths and the
+ * defensive branches (undefined state / missing tab / missing errors).
+ */
+import {
+  selectFieldValue,
+  selectFieldError,
+  selectIsFormValid,
+  selectLiquidErrorMessage,
+  selectBaseTabIndex,
+  selectChannel,
+} from '../core/store/selectors';
+
+const state = {
+  meta: { channel: 'SMS', baseTabIndex: 0 },
+  root: { 'template-name': 'My SMS' },
+  tabs: [{ fields: { 'sms-editor': 'hi' } }],
+  errors: { root: { 'template-name': true }, tabs: [{ 'sms-editor': 'genericValidationError' }] },
+  validity: { isFormValid: true, liquidErrorMessage: { STANDARD_ERROR_MSG: ['x'], LIQUID_ERROR_MSG: [] } },
+};
+
+describe('selectFieldValue', () => {
+  it('returns a root field value when tabIndex is null', () => {
+    expect(selectFieldValue(state, { fieldId: 'template-name', tabIndex: null })).toBe('My SMS');
+  });
+
+  it('returns a tab field value when tabIndex is set', () => {
+    expect(selectFieldValue(state, { fieldId: 'sms-editor', tabIndex: 0 })).toBe('hi');
+  });
+
+  it('returns undefined for a missing tab', () => {
+    expect(selectFieldValue(state, { fieldId: 'sms-editor', tabIndex: 5 })).toBeUndefined();
+  });
+
+  it('is defensive when state is undefined', () => {
+    expect(selectFieldValue(undefined, { fieldId: 'sms-editor', tabIndex: 0 })).toBeUndefined();
+    expect(selectFieldValue(undefined, { fieldId: 'template-name', tabIndex: null })).toBeUndefined();
+  });
+});
+
+describe('selectFieldError', () => {
+  it('returns a root error when tabIndex is null', () => {
+    expect(selectFieldError(state, { fieldId: 'template-name', tabIndex: null })).toBe(true);
+  });
+
+  it('returns a tab error when tabIndex is set', () => {
+    expect(selectFieldError(state, { fieldId: 'sms-editor', tabIndex: 0 })).toBe('genericValidationError');
+  });
+
+  it('returns undefined for a missing tab', () => {
+    expect(selectFieldError(state, { fieldId: 'sms-editor', tabIndex: 9 })).toBeUndefined();
+  });
+
+  it('is defensive when state/errors are undefined', () => {
+    expect(selectFieldError(undefined, { fieldId: 'sms-editor', tabIndex: 0 })).toBeUndefined();
+    expect(selectFieldError({}, { fieldId: 'template-name', tabIndex: null })).toBeUndefined();
+  });
+});
+
+describe('scalar selectors', () => {
+  it('selectIsFormValid / selectLiquidErrorMessage / selectBaseTabIndex / selectChannel', () => {
+    expect(selectIsFormValid(state)).toBe(true);
+    expect(selectLiquidErrorMessage(state).STANDARD_ERROR_MSG).toEqual(['x']);
+    expect(selectBaseTabIndex(state)).toBe(0);
+    expect(selectChannel(state)).toBe('SMS');
+  });
+});