@pie-lib/config-ui 13.0.22-beta.6 → 13.0.22-beta.7

package/lib/choice-configuration/__tests__/index.test.js

@@ -0,0 +1,253 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _userEvent = _interopRequireDefault(require("@testing-library/user-event"));
+var _index = require("../index");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+jest.mock('@pie-lib/editable-html-tip-tap', function () {
+  return {
+    __esModule: true,
+    "default": function _default(_ref) {
+      var markup = _ref.markup,
+        _onChange = _ref.onChange,
+        disabled = _ref.disabled;
+      return /*#__PURE__*/_react["default"].createElement("textarea", {
+        "data-testid": "editable-html",
+        defaultValue: markup || '',
+        onChange: function onChange(e) {
+          return _onChange(e.target.value);
+        },
+        disabled: disabled
+      });
+    }
+  };
+});
+var defaultFeedback = {
+  correct: 'Correct',
+  incorrect: 'Incorrect'
+};
+var data = {
+  correct: true,
+  value: 'foo',
+  label: 'Foo',
+  feedback: {
+    type: 'custom'
+  }
+};
+var classes = {
+  choiceConfiguration: 'choiceConfiguration'
+};
+describe('ChoiceConfiguration', function () {
+  var onChange = jest.fn();
+  beforeEach(function () {
+    onChange.mockClear();
+  });
+  describe('rendering', function () {
+    it('renders correctly with default props', function () {
+      var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+          classes: classes,
+          defaultFeedback: defaultFeedback,
+          data: data,
+          onChange: onChange
+        })),
+        container = _render.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+    it('renders with checked state', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+        classes: classes,
+        defaultFeedback: defaultFeedback,
+        data: data,
+        onChange: onChange,
+        mode: "checkbox"
+      }));
+      var checkbox = _react2.screen.getByRole('checkbox');
+      expect(checkbox).toBeChecked();
+    });
+    it('renders without feedback when allowFeedBack is false', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+        allowFeedBack: false,
+        classes: classes,
+        defaultFeedback: defaultFeedback,
+        data: data,
+        onChange: onChange
+      }));
+      expect(_react2.screen.queryByRole('button', {
+        name: /feedback/i
+      })).not.toBeInTheDocument();
+    });
+    it('renders without delete button when allowDelete is false', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+        allowDelete: false,
+        classes: classes,
+        defaultFeedback: defaultFeedback,
+        data: data,
+        onChange: onChange
+      }));
+      expect(_react2.screen.queryByRole('button', {
+        name: /delete/i
+      })).not.toBeInTheDocument();
+    });
+  });
+  describe('user interactions', function () {
+    it('calls onChange when label is edited', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var user, editableHtmlElements, editableHtml;
+      return _regenerator["default"].wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+              classes: classes,
+              defaultFeedback: defaultFeedback,
+              data: data,
+              onChange: onChange
+            }));
+            editableHtmlElements = _react2.screen.getAllByTestId('editable-html');
+            editableHtml = editableHtmlElements[0];
+            _context.next = 1;
+            return user.clear(editableHtml);
+          case 1:
+            _context.next = 2;
+            return user.type(editableHtml, 'new label');
+          case 2:
+            expect(onChange).toHaveBeenCalled();
+            expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+              label: expect.stringContaining('new label')
+            }));
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('calls onChange when checkbox is toggled', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var user, checkbox;
+      return _regenerator["default"].wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+              classes: classes,
+              defaultFeedback: defaultFeedback,
+              data: _objectSpread(_objectSpread({}, data), {}, {
+                correct: false
+              }),
+              onChange: onChange,
+              mode: "checkbox"
+            }));
+            checkbox = _react2.screen.getByRole('checkbox');
+            _context2.next = 1;
+            return user.click(checkbox);
+          case 1:
+            expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+              correct: true
+            }));
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+  });
+  describe('prop variations', function () {
+    it('renders with radio mode instead of checkbox', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+        classes: classes,
+        defaultFeedback: defaultFeedback,
+        data: data,
+        onChange: onChange,
+        mode: "radio"
+      }));
+      var radio = _react2.screen.getByRole('radio');
+      expect(radio).toBeInTheDocument();
+    });
+    it('renders with disabled state', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+        classes: classes,
+        defaultFeedback: defaultFeedback,
+        data: data,
+        onChange: onChange,
+        disabled: true,
+        mode: "checkbox"
+      }));
+      var checkbox = _react2.screen.getByRole('checkbox');
+      expect(checkbox).toBeInTheDocument();
+    });
+    it('renders with custom feedback type', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+        classes: classes,
+        defaultFeedback: defaultFeedback,
+        data: _objectSpread(_objectSpread({}, data), {}, {
+          feedback: {
+            type: 'custom'
+          }
+        }),
+        onChange: onChange,
+        mode: "checkbox"
+      }));
+      var editableElements = _react2.screen.getAllByTestId('editable-html');
+      expect(editableElements.length).toBeGreaterThan(0);
+    });
+    it('renders with incorrect answer', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+        classes: classes,
+        defaultFeedback: defaultFeedback,
+        data: _objectSpread(_objectSpread({}, data), {}, {
+          correct: false
+        }),
+        onChange: onChange,
+        mode: "checkbox"
+      }));
+      var checkbox = _react2.screen.getByRole('checkbox');
+      expect(checkbox).not.toBeChecked();
+    });
+  });
+  describe('edge cases', function () {
+    it('handles data with empty label', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+        classes: classes,
+        defaultFeedback: defaultFeedback,
+        data: _objectSpread(_objectSpread({}, data), {}, {
+          label: ''
+        }),
+        onChange: onChange
+      }));
+      var editableElements = _react2.screen.getAllByTestId('editable-html');
+      expect(editableElements.length).toBeGreaterThan(0);
+    });
+    it('handles multiple feedback types', function () {
+      var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+          classes: classes,
+          defaultFeedback: defaultFeedback,
+          data: _objectSpread(_objectSpread({}, data), {}, {
+            feedback: {
+              type: 'default'
+            }
+          }),
+          onChange: onChange
+        })),
+        rerender = _render2.rerender;
+      var editableElements = _react2.screen.getAllByTestId('editable-html');
+      expect(editableElements.length).toBeGreaterThan(0);
+      rerender(/*#__PURE__*/_react["default"].createElement(_index.ChoiceConfiguration, {
+        classes: classes,
+        defaultFeedback: defaultFeedback,
+        data: _objectSpread(_objectSpread({}, data), {}, {
+          feedback: {
+            type: 'custom'
+          }
+        }),
+        onChange: onChange
+      }));
+      editableElements = _react2.screen.getAllByTestId('editable-html');
+      expect(editableElements.length).toBeGreaterThan(0);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_userEvent","_index","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","__esModule","default","_ref","markup","onChange","disabled","createElement","defaultValue","target","value","defaultFeedback","correct","incorrect","data","label","feedback","type","classes","choiceConfiguration","describe","fn","beforeEach","mockClear","it","_render","render","ChoiceConfiguration","container","expect","firstChild","toBeInTheDocument","mode","checkbox","screen","getByRole","toBeChecked","allowFeedBack","queryByRole","name","not","allowDelete","_asyncToGenerator2","_regenerator","mark","_callee","user","editableHtmlElements","editableHtml","wrap","_context","prev","next","userEvent","setup","getAllByTestId","clear","toHaveBeenCalled","toHaveBeenCalledWith","objectContaining","stringContaining","stop","_callee2","_context2","click","radio","editableElements","toBeGreaterThan","_render2","rerender"],"sources":["../../../src/choice-configuration/__tests__/index.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, screen } from '@testing-library/react';\nimport userEvent from '@testing-library/user-event';\nimport { ChoiceConfiguration } from '../index';\n\njest.mock('@pie-lib/editable-html-tip-tap', () => ({\n  __esModule: true,\n  default: ({ markup, onChange, disabled }) => (\n    <textarea\n      data-testid=\"editable-html\"\n      defaultValue={markup || ''}\n      onChange={(e) => onChange(e.target.value)}\n      disabled={disabled}\n    />\n  ),\n}));\n\nconst defaultFeedback = {\n  correct: 'Correct',\n  incorrect: 'Incorrect',\n};\n\nconst data = {\n  correct: true,\n  value: 'foo',\n  label: 'Foo',\n  feedback: {\n    type: 'custom',\n  },\n};\n\nconst classes = {\n  choiceConfiguration: 'choiceConfiguration',\n};\n\ndescribe('ChoiceConfiguration', () => {\n  const onChange = jest.fn();\n\n  beforeEach(() => {\n    onChange.mockClear();\n  });\n\n  describe('rendering', () => {\n    it('renders correctly with default props', () => {\n      const { container } = render(\n        <ChoiceConfiguration classes={classes} defaultFeedback={defaultFeedback} data={data} onChange={onChange} />,\n      );\n      expect(container.firstChild).toBeInTheDocument();\n    });\n\n    it('renders with checked state', () => {\n      render(\n        <ChoiceConfiguration\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={data}\n          onChange={onChange}\n          mode=\"checkbox\"\n        />,\n      );\n      const checkbox = screen.getByRole('checkbox');\n      expect(checkbox).toBeChecked();\n    });\n\n    it('renders without feedback when allowFeedBack is false', () => {\n      render(\n        <ChoiceConfiguration\n          allowFeedBack={false}\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={data}\n          onChange={onChange}\n        />,\n      );\n      expect(screen.queryByRole('button', { name: /feedback/i })).not.toBeInTheDocument();\n    });\n\n    it('renders without delete button when allowDelete is false', () => {\n      render(\n        <ChoiceConfiguration\n          allowDelete={false}\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={data}\n          onChange={onChange}\n        />,\n      );\n      expect(screen.queryByRole('button', { name: /delete/i })).not.toBeInTheDocument();\n    });\n  });\n\n  describe('user interactions', () => {\n    it('calls onChange when label is edited', async () => {\n      const user = userEvent.setup();\n      render(\n        <ChoiceConfiguration classes={classes} defaultFeedback={defaultFeedback} data={data} onChange={onChange} />,\n      );\n\n      const editableHtmlElements = screen.getAllByTestId('editable-html');\n      const editableHtml = editableHtmlElements[0];\n      await user.clear(editableHtml);\n      await user.type(editableHtml, 'new label');\n\n      expect(onChange).toHaveBeenCalled();\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          label: expect.stringContaining('new label'),\n        }),\n      );\n    });\n\n    it('calls onChange when checkbox is toggled', async () => {\n      const user = userEvent.setup();\n      render(\n        <ChoiceConfiguration\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={{ ...data, correct: false }}\n          onChange={onChange}\n          mode=\"checkbox\"\n        />,\n      );\n\n      const checkbox = screen.getByRole('checkbox');\n      await user.click(checkbox);\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          correct: true,\n        }),\n      );\n    });\n  });\n\n  describe('prop variations', () => {\n    it('renders with radio mode instead of checkbox', () => {\n      render(\n        <ChoiceConfiguration\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={data}\n          onChange={onChange}\n          mode=\"radio\"\n        />,\n      );\n      const radio = screen.getByRole('radio');\n      expect(radio).toBeInTheDocument();\n    });\n\n    it('renders with disabled state', () => {\n      render(\n        <ChoiceConfiguration\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={data}\n          onChange={onChange}\n          disabled={true}\n          mode=\"checkbox\"\n        />,\n      );\n      const checkbox = screen.getByRole('checkbox');\n      expect(checkbox).toBeInTheDocument();\n    });\n\n    it('renders with custom feedback type', () => {\n      render(\n        <ChoiceConfiguration\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={{ ...data, feedback: { type: 'custom' } }}\n          onChange={onChange}\n          mode=\"checkbox\"\n        />,\n      );\n      const editableElements = screen.getAllByTestId('editable-html');\n      expect(editableElements.length).toBeGreaterThan(0);\n    });\n\n    it('renders with incorrect answer', () => {\n      render(\n        <ChoiceConfiguration\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={{ ...data, correct: false }}\n          onChange={onChange}\n          mode=\"checkbox\"\n        />,\n      );\n      const checkbox = screen.getByRole('checkbox');\n      expect(checkbox).not.toBeChecked();\n    });\n  });\n\n  describe('edge cases', () => {\n    it('handles data with empty label', () => {\n      render(\n        <ChoiceConfiguration\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={{ ...data, label: '' }}\n          onChange={onChange}\n        />,\n      );\n      const editableElements = screen.getAllByTestId('editable-html');\n      expect(editableElements.length).toBeGreaterThan(0);\n    });\n\n    it('handles multiple feedback types', () => {\n      const { rerender } = render(\n        <ChoiceConfiguration\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={{ ...data, feedback: { type: 'default' } }}\n          onChange={onChange}\n        />,\n      );\n\n      let editableElements = screen.getAllByTestId('editable-html');\n      expect(editableElements.length).toBeGreaterThan(0);\n\n      rerender(\n        <ChoiceConfiguration\n          classes={classes}\n          defaultFeedback={defaultFeedback}\n          data={{ ...data, feedback: { type: 'custom' } }}\n          onChange={onChange}\n        />,\n      );\n\n      editableElements = screen.getAllByTestId('editable-html');\n      expect(editableElements.length).toBeGreaterThan(0);\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/feedback-config/__tests__/feedback-config.test.js

@@ -0,0 +1,201 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _userEvent = _interopRequireDefault(require("@testing-library/user-event"));
+var _index = require("../index");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// Mock FeedbackSelector to simplify testing
+jest.mock('../feedback-selector', function () {
+  return function FeedbackSelector(_ref) {
+    var label = _ref.label,
+      feedback = _ref.feedback,
+      _onChange = _ref.onChange;
+    return /*#__PURE__*/_react["default"].createElement("div", {
+      "data-testid": "feedback-selector"
+    }, /*#__PURE__*/_react["default"].createElement("label", null, label), /*#__PURE__*/_react["default"].createElement("select", {
+      "aria-label": label,
+      value: feedback.type,
+      onChange: function onChange(e) {
+        return _onChange(_objectSpread(_objectSpread({}, feedback), {}, {
+          type: e.target.value
+        }));
+      }
+    }, /*#__PURE__*/_react["default"].createElement("option", {
+      value: "default"
+    }, "Default"), /*#__PURE__*/_react["default"].createElement("option", {
+      value: "custom"
+    }, "Custom"), /*#__PURE__*/_react["default"].createElement("option", {
+      value: "none"
+    }, "None")));
+  };
+});
+describe('FeedbackConfig', function () {
+  var onChange = jest.fn();
+  beforeEach(function () {
+    onChange.mockClear();
+  });
+  describe('rendering', function () {
+    it('renders with default feedback types', function () {
+      var feedback = (0, _index.buildDefaults)();
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.FeedbackConfig, {
+        feedback: feedback,
+        onChange: onChange
+      }));
+      expect(_react2.screen.getByText('Feedback')).toBeInTheDocument();
+      expect(_react2.screen.getByText('If correct, show')).toBeInTheDocument();
+      expect(_react2.screen.getByText('If partially correct, show')).toBeInTheDocument();
+      expect(_react2.screen.getByText('If incorrect, show')).toBeInTheDocument();
+    });
+    it('renders all three feedback selectors by default', function () {
+      var feedback = (0, _index.buildDefaults)();
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.FeedbackConfig, {
+        feedback: feedback,
+        onChange: onChange
+      }));
+      var selectors = _react2.screen.getAllByTestId('feedback-selector');
+      expect(selectors).toHaveLength(3);
+    });
+    it('does not render partial feedback selector when allowPartial is false', function () {
+      var feedback = (0, _index.buildDefaults)();
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.FeedbackConfig, {
+        allowPartial: false,
+        feedback: feedback,
+        onChange: onChange
+      }));
+      expect(_react2.screen.getByText('If correct, show')).toBeInTheDocument();
+      expect(_react2.screen.queryByText('If partially correct, show')).not.toBeInTheDocument();
+      expect(_react2.screen.getByText('If incorrect, show')).toBeInTheDocument();
+      var selectors = _react2.screen.getAllByTestId('feedback-selector');
+      expect(selectors).toHaveLength(2);
+    });
+  });
+  describe('user interactions', function () {
+    it('calls onChange when correct feedback type changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var user, feedback, correctSelect;
+      return _regenerator["default"].wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            feedback = (0, _index.buildDefaults)();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.FeedbackConfig, {
+              feedback: feedback,
+              onChange: onChange
+            }));
+            correctSelect = _react2.screen.getByLabelText('If correct, show');
+            _context.next = 1;
+            return user.selectOptions(correctSelect, 'custom');
+          case 1:
+            expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+              correct: expect.objectContaining({
+                type: 'custom'
+              })
+            }));
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('calls onChange when incorrect feedback type changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var user, feedback, incorrectSelect;
+      return _regenerator["default"].wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            feedback = (0, _index.buildDefaults)();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.FeedbackConfig, {
+              feedback: feedback,
+              onChange: onChange
+            }));
+            incorrectSelect = _react2.screen.getByLabelText('If incorrect, show');
+            _context2.next = 1;
+            return user.selectOptions(incorrectSelect, 'none');
+          case 1:
+            expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+              incorrect: expect.objectContaining({
+                type: 'none'
+              })
+            }));
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+    it('calls onChange when partial feedback type changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+      var user, feedback, partialSelect;
+      return _regenerator["default"].wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            feedback = (0, _index.buildDefaults)();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.FeedbackConfig, {
+              feedback: feedback,
+              onChange: onChange
+            }));
+            partialSelect = _react2.screen.getByLabelText('If partially correct, show');
+            _context3.next = 1;
+            return user.selectOptions(partialSelect, 'custom');
+          case 1:
+            expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+              partial: expect.objectContaining({
+                type: 'custom'
+              })
+            }));
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+  });
+  describe('buildDefaults helper', function () {
+    it('returns default feedback configuration', function () {
+      var defaults = (0, _index.buildDefaults)();
+      expect(defaults).toEqual({
+        correct: {
+          type: 'default',
+          "default": 'Correct'
+        },
+        incorrect: {
+          type: 'default',
+          "default": 'Incorrect'
+        },
+        partial: {
+          type: 'default',
+          "default": 'Nearly'
+        }
+      });
+    });
+    it('merges custom values with defaults', function () {
+      var defaults = (0, _index.buildDefaults)({
+        correct: {
+          type: 'custom',
+          custom: 'Great job!'
+        }
+      });
+      expect(defaults).toEqual({
+        correct: {
+          type: 'custom',
+          "default": 'Correct',
+          custom: 'Great job!'
+        },
+        incorrect: {
+          type: 'default',
+          "default": 'Incorrect'
+        },
+        partial: {
+          type: 'default',
+          "default": 'Nearly'
+        }
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_userEvent","_index","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","FeedbackSelector","_ref","label","feedback","onChange","createElement","value","type","target","describe","fn","beforeEach","mockClear","it","buildDefaults","render","FeedbackConfig","expect","screen","getByText","toBeInTheDocument","selectors","getAllByTestId","toHaveLength","allowPartial","queryByText","not","_asyncToGenerator2","_regenerator","mark","_callee","user","correctSelect","wrap","_context","prev","next","userEvent","setup","getByLabelText","selectOptions","toHaveBeenCalledWith","objectContaining","correct","stop","_callee2","incorrectSelect","_context2","incorrect","_callee3","partialSelect","_context3","partial","defaults","toEqual","custom"],"sources":["../../../src/feedback-config/__tests__/feedback-config.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, screen } from '@testing-library/react';\nimport userEvent from '@testing-library/user-event';\nimport { buildDefaults, FeedbackConfig } from '../index';\n\n// Mock FeedbackSelector to simplify testing\njest.mock('../feedback-selector', () => {\n  return function FeedbackSelector({ label, feedback, onChange }) {\n    return (\n      <div data-testid=\"feedback-selector\">\n        <label>{label}</label>\n        <select\n          aria-label={label}\n          value={feedback.type}\n          onChange={(e) => onChange({ ...feedback, type: e.target.value })}\n        >\n          <option value=\"default\">Default</option>\n          <option value=\"custom\">Custom</option>\n          <option value=\"none\">None</option>\n        </select>\n      </div>\n    );\n  };\n});\n\ndescribe('FeedbackConfig', () => {\n  const onChange = jest.fn();\n\n  beforeEach(() => {\n    onChange.mockClear();\n  });\n\n  describe('rendering', () => {\n    it('renders with default feedback types', () => {\n      const feedback = buildDefaults();\n\n      render(<FeedbackConfig feedback={feedback} onChange={onChange} />);\n\n      expect(screen.getByText('Feedback')).toBeInTheDocument();\n      expect(screen.getByText('If correct, show')).toBeInTheDocument();\n      expect(screen.getByText('If partially correct, show')).toBeInTheDocument();\n      expect(screen.getByText('If incorrect, show')).toBeInTheDocument();\n    });\n\n    it('renders all three feedback selectors by default', () => {\n      const feedback = buildDefaults();\n\n      render(<FeedbackConfig feedback={feedback} onChange={onChange} />);\n\n      const selectors = screen.getAllByTestId('feedback-selector');\n      expect(selectors).toHaveLength(3);\n    });\n\n    it('does not render partial feedback selector when allowPartial is false', () => {\n      const feedback = buildDefaults();\n\n      render(<FeedbackConfig allowPartial={false} feedback={feedback} onChange={onChange} />);\n\n      expect(screen.getByText('If correct, show')).toBeInTheDocument();\n      expect(screen.queryByText('If partially correct, show')).not.toBeInTheDocument();\n      expect(screen.getByText('If incorrect, show')).toBeInTheDocument();\n\n      const selectors = screen.getAllByTestId('feedback-selector');\n      expect(selectors).toHaveLength(2);\n    });\n  });\n\n  describe('user interactions', () => {\n    it('calls onChange when correct feedback type changes', async () => {\n      const user = userEvent.setup();\n      const feedback = buildDefaults();\n\n      render(<FeedbackConfig feedback={feedback} onChange={onChange} />);\n\n      const correctSelect = screen.getByLabelText('If correct, show');\n      await user.selectOptions(correctSelect, 'custom');\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          correct: expect.objectContaining({ type: 'custom' }),\n        }),\n      );\n    });\n\n    it('calls onChange when incorrect feedback type changes', async () => {\n      const user = userEvent.setup();\n      const feedback = buildDefaults();\n\n      render(<FeedbackConfig feedback={feedback} onChange={onChange} />);\n\n      const incorrectSelect = screen.getByLabelText('If incorrect, show');\n      await user.selectOptions(incorrectSelect, 'none');\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          incorrect: expect.objectContaining({ type: 'none' }),\n        }),\n      );\n    });\n\n    it('calls onChange when partial feedback type changes', async () => {\n      const user = userEvent.setup();\n      const feedback = buildDefaults();\n\n      render(<FeedbackConfig feedback={feedback} onChange={onChange} />);\n\n      const partialSelect = screen.getByLabelText('If partially correct, show');\n      await user.selectOptions(partialSelect, 'custom');\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          partial: expect.objectContaining({ type: 'custom' }),\n        }),\n      );\n    });\n  });\n\n  describe('buildDefaults helper', () => {\n    it('returns default feedback configuration', () => {\n      const defaults = buildDefaults();\n\n      expect(defaults).toEqual({\n        correct: { type: 'default', default: 'Correct' },\n        incorrect: { type: 'default', default: 'Incorrect' },\n        partial: { type: 'default', default: 'Nearly' },\n      });\n    });\n\n    it('merges custom values with defaults', () => {\n      const defaults = buildDefaults({\n        correct: { type: 'custom', custom: 'Great job!' },\n      });\n\n      expect(defaults).toEqual({\n        correct: { type: 'custom', default: 'Correct', custom: 'Great job!' },\n        incorrect: { type: 'default', default: 'Incorrect' },\n        partial: { type: 'default', default: 'Nearly' },\n      });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}