@pie-lib/rubric 2.0.22-beta.6 → 2.0.22-beta.7

package/lib/__tests__/rubric.test.js

@@ -0,0 +1,431 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = require("@testing-library/react");
+var _react2 = _interopRequireDefault(require("react"));
+var _authoring = require("../authoring");
+var _lodashEs = require("lodash-es");
+var _styles = require("@mui/material/styles");
+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 dependencies
+jest.mock('@pie-lib/editable-html-tip-tap', function () {
+  return function EditableHtml(props) {
+    return /*#__PURE__*/_react2["default"].createElement("div", {
+      "data-testid": "editable-html",
+      "data-markup": props.markup
+    });
+  };
+});
+jest.mock('@pie-lib/config-ui', function () {
+  return {
+    FeedbackConfig: function FeedbackConfig(_ref) {
+      var feedback = _ref.feedback;
+      return /*#__PURE__*/_react2["default"].createElement("div", {
+        "data-testid": "feedback-config"
+      }, JSON.stringify(feedback));
+    },
+    InputContainer: function InputContainer(_ref2) {
+      var children = _ref2.children,
+        label = _ref2.label;
+      return /*#__PURE__*/_react2["default"].createElement("div", {
+        "data-testid": "input-container",
+        "data-label": label
+      }, children);
+    }
+  };
+});
+jest.mock('@hello-pangea/dnd', function () {
+  return {
+    DragDropContext: function DragDropContext(_ref3) {
+      var children = _ref3.children;
+      return /*#__PURE__*/_react2["default"].createElement("div", {
+        "data-testid": "drag-drop-context"
+      }, children);
+    },
+    Droppable: function Droppable(_ref4) {
+      var children = _ref4.children;
+      return children({
+        droppableProps: {},
+        innerRef: function innerRef() {}
+      }, {});
+    },
+    Draggable: function Draggable(_ref5) {
+      var children = _ref5.children,
+        index = _ref5.index;
+      return children({
+        innerRef: function innerRef() {},
+        draggableProps: {
+          'data-draggable-index': index
+        },
+        dragHandleProps: {}
+      }, {});
+    }
+  };
+});
+describe('Rubric', function () {
+  var points = ['nothing right', 'a teeny bit right', 'mostly right', 'bingo'];
+  var sampleAnswers = [null, 'just right', 'not left', null];
+  var theme = (0, _styles.createTheme)();
+  var renderComponent = function renderComponent() {
+    var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var defaultProps = _objectSpread({
+      classes: {},
+      onChange: jest.fn(),
+      className: 'className',
+      value: _objectSpread({
+        excludeZero: false,
+        points: points,
+        sampleAnswers: sampleAnswers
+      }, value)
+    }, props);
+    return _objectSpread(_objectSpread({}, (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react2["default"].createElement(_authoring.RawAuthoring, defaultProps)))), {}, {
+      onChange: defaultProps.onChange,
+      props: defaultProps
+    });
+  };
+  describe('render', function () {
+    it('renders rubric title and main structure', function () {
+      renderComponent();
+      expect(_react.screen.getByText('Rubric')).toBeInTheDocument();
+      expect(_react.screen.getByLabelText('Max Points')).toBeInTheDocument();
+      expect(_react.screen.getByLabelText('Exclude zeros')).toBeInTheDocument();
+    });
+    it('renders all point configurations', function () {
+      var _renderComponent = renderComponent(),
+        container = _renderComponent.container;
+      // Verify DragDropContext is rendered
+      expect(container.querySelector('[data-testid="drag-drop-context"]')).toBeInTheDocument();
+
+      // Check that point labels are rendered (4 points = "3 pts", "2 pts", "1 pt", "0 pt")
+      // Note: The PointConfig component uses singular "pt" for 0 and 1, plural "pts" for 2+
+      expect(_react.screen.getByText('3 pts')).toBeInTheDocument();
+      expect(_react.screen.getByText('2 pts')).toBeInTheDocument();
+      expect(_react.screen.getByText('1 pt')).toBeInTheDocument();
+      expect(_react.screen.getByText('0 pt')).toBeInTheDocument();
+    });
+    describe('draggable', function () {
+      it('renders 3 draggable items when excludeZero is true', function () {
+        // When excludeZero is true, the last point (0 pts) should not be rendered
+        expect(_react.screen.queryByText('0 pt')).not.toBeInTheDocument();
+      });
+      it('renders 4 draggable items when excludeZero is false', function () {
+        var _renderComponent2 = renderComponent({
+            excludeZero: false
+          }),
+          container = _renderComponent2.container;
+
+        // When excludeZero is false, all points including 0 should be rendered
+        var draggableItems = container.querySelectorAll('[data-draggable-index]');
+        expect(draggableItems.length).toEqual(4);
+        expect(_react.screen.getByText('0 pt')).toBeInTheDocument();
+
+        // Verify all point labels are rendered
+        expect(_react.screen.getByText('3 pts')).toBeInTheDocument();
+        expect(_react.screen.getByText('2 pts')).toBeInTheDocument();
+        expect(_react.screen.getByText('1 pt')).toBeInTheDocument();
+        expect(_react.screen.getByText('0 pt')).toBeInTheDocument();
+      });
+    });
+  });
+  describe('logic', function () {
+    describe('changeMaxPoints', function () {
+      var testChangeMaxPoints = function testChangeMaxPoints(maxPoints, excludeZero, expectedPoints, expectedSampleAnswers) {
+        it("maxPoints=".concat(maxPoints, ", excludeZero=").concat(excludeZero, " calls onChange correctly"), function () {
+          var _container$querySelec;
+          var _renderComponent3 = renderComponent({
+              excludeZero: excludeZero
+            }),
+            onChange = _renderComponent3.onChange,
+            container = _renderComponent3.container;
+
+          // Get the component instance through the container
+          // We need to call the method directly since we're testing internal behavior
+          var instance = (_container$querySelec = container.querySelector('[class*="MuiBox-root"]')) === null || _container$querySelec === void 0 ? void 0 : _container$querySelec._owner;
+
+          // Since we can't easily access instance methods in RTL, we'll test the behavior
+          // by verifying the onChange prop receives the correct values
+          // For now, we'll directly test the logic
+          var component = new _authoring.RawAuthoring({
+            value: {
+              excludeZero: excludeZero,
+              points: points,
+              sampleAnswers: sampleAnswers
+            },
+            onChange: onChange,
+            classes: {},
+            className: 'className'
+          });
+          component.changeMaxPoints(maxPoints);
+          expect(onChange).toHaveBeenCalledWith({
+            excludeZero: excludeZero,
+            points: expectedPoints,
+            sampleAnswers: expectedSampleAnswers,
+            maxPoints: expectedPoints.length - 1
+          });
+        });
+      };
+      testChangeMaxPoints(1, false, (0, _lodashEs.takeRight)(points, 2), (0, _lodashEs.takeRight)(sampleAnswers, 2));
+      testChangeMaxPoints(1, true, (0, _lodashEs.takeRight)(points, 2), (0, _lodashEs.takeRight)(sampleAnswers, 2));
+      testChangeMaxPoints(2, true, (0, _lodashEs.takeRight)(points, 3), (0, _lodashEs.takeRight)(sampleAnswers, 3));
+      testChangeMaxPoints(2, false, (0, _lodashEs.takeRight)(points, 3), (0, _lodashEs.takeRight)(sampleAnswers, 3));
+      testChangeMaxPoints(5, false, ['', ''].concat(points), [null, null].concat(sampleAnswers));
+    });
+    describe('changeSampleResponse', function () {
+      var testChangeSampleResponse = function testChangeSampleResponse(index, clickedItem, excludeZero, expectedPoints, expectedSampleAnswers) {
+        it("Point ".concat(index, " with clickedItem=\"").concat(clickedItem, "\" calls onChange correctly"), function () {
+          var _renderComponent4 = renderComponent({
+              excludeZero: excludeZero
+            }),
+            onChange = _renderComponent4.onChange;
+
+          // Test the logic by creating a component instance and calling the method
+          var component = new _authoring.RawAuthoring({
+            value: {
+              excludeZero: excludeZero,
+              points: points,
+              sampleAnswers: sampleAnswers
+            },
+            onChange: onChange,
+            classes: {},
+            className: 'className'
+          });
+          component.onPointMenuChange(index, clickedItem);
+          expect(onChange).toHaveBeenCalledWith({
+            excludeZero: excludeZero,
+            points: expectedPoints,
+            sampleAnswers: expectedSampleAnswers
+          });
+        });
+      };
+      testChangeSampleResponse(0, 'sample', false, points, ['', 'just right', 'not left', null]);
+      testChangeSampleResponse(3, 'sample', false, points, [null, 'just right', 'not left', '']);
+      testChangeSampleResponse(1, 'sample', true, points, [null, null, 'not left', null]);
+      testChangeSampleResponse(3, 'sample', true, points, [null, 'just right', 'not left', '']);
+    });
+  });
+  describe('user interactions', function () {
+    it('calls onChange when excluding zeros checkbox is toggled', function () {
+      var _renderComponent5 = renderComponent({
+          excludeZero: false
+        }),
+        onChange = _renderComponent5.onChange;
+      var checkbox = _react.screen.getByLabelText('Exclude zeros');
+      _react.fireEvent.click(checkbox);
+      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+        excludeZero: true
+      }));
+    });
+    it('calls onChange when max points is changed', function () {
+      var _renderComponent6 = renderComponent(),
+        onChange = _renderComponent6.onChange;
+      var selectInput = _react.screen.getByLabelText('Max Points');
+      _react.fireEvent.mouseDown(selectInput);
+
+      // The onChange should be called when a new value is selected
+      // This tests the changeMaxPoints logic indirectly
+    });
+    it('renders correct number of points based on excludeZero', function () {
+      var _renderComponent7 = renderComponent({
+          excludeZero: false
+        }),
+        rerender = _renderComponent7.rerender;
+      expect(_react.screen.getByText('0 pt')).toBeInTheDocument();
+
+      // Rerender with excludeZero true
+      rerender(/*#__PURE__*/_react2["default"].createElement(_styles.ThemeProvider, {
+        theme: theme
+      }, /*#__PURE__*/_react2["default"].createElement(_authoring.RawAuthoring, {
+        classes: {},
+        onChange: jest.fn(),
+        className: "className",
+        value: {
+          excludeZero: true,
+          points: points,
+          sampleAnswers: sampleAnswers
+        }
+      })));
+      expect(_react.screen.queryByText('0 pt')).not.toBeInTheDocument();
+    });
+  });
+  describe('drag and drop', function () {
+    it('calls onChange with reordered points after drag end', function () {
+      var _renderComponent8 = renderComponent(),
+        onChange = _renderComponent8.onChange;
+      var component = new _authoring.RawAuthoring({
+        value: {
+          excludeZero: false,
+          points: points,
+          sampleAnswers: sampleAnswers
+        },
+        onChange: onChange,
+        classes: {},
+        className: 'className'
+      });
+
+      // Simulate drag from index 0 to index 2
+      component.dragEnd({
+        source: {
+          index: 0
+        },
+        destination: {
+          index: 2
+        }
+      });
+      expect(onChange).toHaveBeenCalled();
+      var result = onChange.mock.calls[0][0];
+      expect(result.points).not.toEqual(points);
+      expect(result.points.length).toBe(points.length);
+    });
+    it('does nothing when drag has no destination', function () {
+      var _renderComponent9 = renderComponent(),
+        onChange = _renderComponent9.onChange;
+      var component = new _authoring.RawAuthoring({
+        value: {
+          excludeZero: false,
+          points: points,
+          sampleAnswers: sampleAnswers
+        },
+        onChange: onChange,
+        classes: {},
+        className: 'className'
+      });
+
+      // Simulate drag without destination
+      component.dragEnd({
+        source: {
+          index: 0
+        },
+        destination: null
+      });
+      expect(onChange).not.toHaveBeenCalled();
+    });
+  });
+  describe('content editing', function () {
+    it('calls onChange when point content is changed', function () {
+      var _renderComponent0 = renderComponent(),
+        onChange = _renderComponent0.onChange;
+      var component = new _authoring.RawAuthoring({
+        value: {
+          excludeZero: false,
+          points: points,
+          sampleAnswers: sampleAnswers
+        },
+        onChange: onChange,
+        classes: {},
+        className: 'className'
+      });
+      component.changeContent(0, 'new content', 'points');
+      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+        points: expect.arrayContaining(['new content'])
+      }));
+    });
+    it('calls onChange when sample answer is changed', function () {
+      var _renderComponent1 = renderComponent(),
+        onChange = _renderComponent1.onChange;
+      var component = new _authoring.RawAuthoring({
+        value: {
+          excludeZero: false,
+          points: points,
+          sampleAnswers: sampleAnswers
+        },
+        onChange: onChange,
+        classes: {},
+        className: 'className'
+      });
+      component.changeContent(1, 'new sample answer', 'sampleAnswers');
+      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+        sampleAnswers: expect.arrayContaining(['new sample answer'])
+      }));
+    });
+    it('does not change content for invalid type', function () {
+      var _renderComponent10 = renderComponent(),
+        onChange = _renderComponent10.onChange;
+      var component = new _authoring.RawAuthoring({
+        value: {
+          excludeZero: false,
+          points: points,
+          sampleAnswers: sampleAnswers
+        },
+        onChange: onChange,
+        classes: {},
+        className: 'className'
+      });
+      component.changeContent(0, 'new content', 'invalidType');
+      expect(onChange).not.toHaveBeenCalled();
+    });
+  });
+  describe('rubricless mode', function () {
+    it('calls onChange when rubricless instruction is changed', function () {
+      var _renderComponent11 = renderComponent({
+          rubriclessInstruction: ''
+        }, {
+          rubricless: true
+        }),
+        onChange = _renderComponent11.onChange;
+      var component = new _authoring.RawAuthoring({
+        value: {
+          excludeZero: false,
+          points: points,
+          sampleAnswers: sampleAnswers,
+          rubriclessInstruction: ''
+        },
+        onChange: onChange,
+        classes: {},
+        className: 'className',
+        rubricless: true
+      });
+      component.changeRubriclessInstruction('New instruction');
+      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+        rubriclessInstruction: 'New instruction'
+      }));
+    });
+  });
+  describe('edge cases', function () {
+    it('handles empty points array', function () {
+      var _renderComponent12 = renderComponent({
+          points: [],
+          sampleAnswers: []
+        }),
+        container = _renderComponent12.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('handles maxPoints greater than current max', function () {
+      var _renderComponent13 = renderComponent(),
+        onChange = _renderComponent13.onChange;
+      var component = new _authoring.RawAuthoring({
+        value: {
+          excludeZero: false,
+          points: points,
+          sampleAnswers: sampleAnswers
+        },
+        onChange: onChange,
+        classes: {},
+        className: 'className'
+      });
+      component.changeMaxPoints(10);
+      expect(onChange).toHaveBeenCalled();
+      var result = onChange.mock.calls[0][0];
+      expect(result.points.length).toBe(11); // 10 + 1 for 0 points
+    });
+    it('handles config and pluginOpts props', function () {
+      var config = {
+        someConfig: true
+      };
+      var pluginOpts = {
+        somePlugin: true
+      };
+      var _renderComponent14 = renderComponent({}, {
+          config: config,
+          pluginOpts: pluginOpts
+        }),
+        container = _renderComponent14.container;
+      expect(container).toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_react2","_interopRequireDefault","_authoring","_lodashEs","_styles","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","EditableHtml","props","createElement","markup","FeedbackConfig","_ref","feedback","JSON","stringify","InputContainer","_ref2","children","label","DragDropContext","_ref3","Droppable","_ref4","droppableProps","innerRef","Draggable","_ref5","index","draggableProps","dragHandleProps","describe","points","sampleAnswers","theme","createTheme","renderComponent","value","undefined","defaultProps","classes","onChange","fn","className","excludeZero","render","ThemeProvider","RawAuthoring","it","expect","screen","getByText","toBeInTheDocument","getByLabelText","_renderComponent","container","querySelector","queryByText","not","_renderComponent2","draggableItems","querySelectorAll","toEqual","testChangeMaxPoints","maxPoints","expectedPoints","expectedSampleAnswers","concat","_container$querySelec","_renderComponent3","instance","_owner","component","changeMaxPoints","toHaveBeenCalledWith","takeRight","testChangeSampleResponse","clickedItem","_renderComponent4","onPointMenuChange","_renderComponent5","checkbox","fireEvent","click","objectContaining","_renderComponent6","selectInput","mouseDown","_renderComponent7","rerender","_renderComponent8","dragEnd","source","destination","toHaveBeenCalled","result","calls","toBe","_renderComponent9","_renderComponent0","changeContent","arrayContaining","_renderComponent1","_renderComponent10","_renderComponent11","rubriclessInstruction","rubricless","changeRubriclessInstruction","_renderComponent12","_renderComponent13","config","someConfig","pluginOpts","somePlugin","_renderComponent14"],"sources":["../../src/__tests__/rubric.test.jsx"],"sourcesContent":["import { fireEvent, render, screen } from '@testing-library/react';\nimport React from 'react';\nimport { RawAuthoring } from '../authoring';\nimport { takeRight } from 'lodash-es';\nimport { createTheme, ThemeProvider } from '@mui/material/styles';\n\n// Mock dependencies\njest.mock('@pie-lib/editable-html-tip-tap', () => {\n  return function EditableHtml(props) {\n    return <div data-testid=\"editable-html\" data-markup={props.markup} />;\n  };\n});\n\njest.mock('@pie-lib/config-ui', () => ({\n  FeedbackConfig: ({ feedback }) => <div data-testid=\"feedback-config\">{JSON.stringify(feedback)}</div>,\n  InputContainer: ({ children, label }) => (\n    <div data-testid=\"input-container\" data-label={label}>\n      {children}\n    </div>\n  ),\n}));\n\njest.mock('@hello-pangea/dnd', () => ({\n  DragDropContext: ({ children }) => <div data-testid=\"drag-drop-context\">{children}</div>,\n  Droppable: ({ children }) => children({ droppableProps: {}, innerRef: () => {} }, {}),\n  Draggable: ({ children, index }) =>\n    children(\n      {\n        innerRef: () => {},\n        draggableProps: { 'data-draggable-index': index },\n        dragHandleProps: {},\n      },\n      {},\n    ),\n}));\n\ndescribe('Rubric', () => {\n  const points = ['nothing right', 'a teeny bit right', 'mostly right', 'bingo'];\n  const sampleAnswers = [null, 'just right', 'not left', null];\n  const theme = createTheme();\n\n  const renderComponent = (value = {}, props = {}) => {\n    const defaultProps = {\n      classes: {},\n      onChange: jest.fn(),\n      className: 'className',\n      value: {\n        excludeZero: false,\n        points,\n        sampleAnswers,\n        ...value,\n      },\n      ...props,\n    };\n\n    return {\n      ...render(\n        <ThemeProvider theme={theme}>\n          <RawAuthoring {...defaultProps} />\n        </ThemeProvider>,\n      ),\n      onChange: defaultProps.onChange,\n      props: defaultProps,\n    };\n  };\n\n  describe('render', () => {\n    it('renders rubric title and main structure', () => {\n      renderComponent();\n      expect(screen.getByText('Rubric')).toBeInTheDocument();\n      expect(screen.getByLabelText('Max Points')).toBeInTheDocument();\n      expect(screen.getByLabelText('Exclude zeros')).toBeInTheDocument();\n    });\n\n    it('renders all point configurations', () => {\n      const { container } = renderComponent();\n      // Verify DragDropContext is rendered\n      expect(container.querySelector('[data-testid=\"drag-drop-context\"]')).toBeInTheDocument();\n\n      // Check that point labels are rendered (4 points = \"3 pts\", \"2 pts\", \"1 pt\", \"0 pt\")\n      // Note: The PointConfig component uses singular \"pt\" for 0 and 1, plural \"pts\" for 2+\n      expect(screen.getByText('3 pts')).toBeInTheDocument();\n      expect(screen.getByText('2 pts')).toBeInTheDocument();\n      expect(screen.getByText('1 pt')).toBeInTheDocument();\n      expect(screen.getByText('0 pt')).toBeInTheDocument();\n    });\n\n    describe('draggable', () => {\n      it('renders 3 draggable items when excludeZero is true', () => {\n        // When excludeZero is true, the last point (0 pts) should not be rendered\n        expect(screen.queryByText('0 pt')).not.toBeInTheDocument();\n      });\n\n      it('renders 4 draggable items when excludeZero is false', () => {\n        const { container } = renderComponent({ excludeZero: false });\n\n        // When excludeZero is false, all points including 0 should be rendered\n        const draggableItems = container.querySelectorAll('[data-draggable-index]');\n        expect(draggableItems.length).toEqual(4);\n        expect(screen.getByText('0 pt')).toBeInTheDocument();\n\n        // Verify all point labels are rendered\n        expect(screen.getByText('3 pts')).toBeInTheDocument();\n        expect(screen.getByText('2 pts')).toBeInTheDocument();\n        expect(screen.getByText('1 pt')).toBeInTheDocument();\n        expect(screen.getByText('0 pt')).toBeInTheDocument();\n      });\n    });\n  });\n\n  describe('logic', () => {\n    describe('changeMaxPoints', () => {\n      const testChangeMaxPoints = (maxPoints, excludeZero, expectedPoints, expectedSampleAnswers) => {\n        it(`maxPoints=${maxPoints}, excludeZero=${excludeZero} calls onChange correctly`, () => {\n          const { onChange, container } = renderComponent({ excludeZero });\n\n          // Get the component instance through the container\n          // We need to call the method directly since we're testing internal behavior\n          const instance = container.querySelector('[class*=\"MuiBox-root\"]')?._owner;\n\n          // Since we can't easily access instance methods in RTL, we'll test the behavior\n          // by verifying the onChange prop receives the correct values\n          // For now, we'll directly test the logic\n          const component = new RawAuthoring({\n            value: { excludeZero, points, sampleAnswers },\n            onChange,\n            classes: {},\n            className: 'className',\n          });\n\n          component.changeMaxPoints(maxPoints);\n\n          expect(onChange).toHaveBeenCalledWith({\n            excludeZero,\n            points: expectedPoints,\n            sampleAnswers: expectedSampleAnswers,\n            maxPoints: expectedPoints.length - 1,\n          });\n        });\n      };\n\n      testChangeMaxPoints(1, false, takeRight(points, 2), takeRight(sampleAnswers, 2));\n      testChangeMaxPoints(1, true, takeRight(points, 2), takeRight(sampleAnswers, 2));\n      testChangeMaxPoints(2, true, takeRight(points, 3), takeRight(sampleAnswers, 3));\n      testChangeMaxPoints(2, false, takeRight(points, 3), takeRight(sampleAnswers, 3));\n      testChangeMaxPoints(5, false, ['', ''].concat(points), [null, null].concat(sampleAnswers));\n    });\n\n    describe('changeSampleResponse', () => {\n      const testChangeSampleResponse = (index, clickedItem, excludeZero, expectedPoints, expectedSampleAnswers) => {\n        it(`Point ${index} with clickedItem=\"${clickedItem}\" calls onChange correctly`, () => {\n          const { onChange } = renderComponent({ excludeZero });\n\n          // Test the logic by creating a component instance and calling the method\n          const component = new RawAuthoring({\n            value: { excludeZero, points, sampleAnswers },\n            onChange,\n            classes: {},\n            className: 'className',\n          });\n\n          component.onPointMenuChange(index, clickedItem);\n\n          expect(onChange).toHaveBeenCalledWith({\n            excludeZero,\n            points: expectedPoints,\n            sampleAnswers: expectedSampleAnswers,\n          });\n        });\n      };\n\n      testChangeSampleResponse(0, 'sample', false, points, ['', 'just right', 'not left', null]);\n      testChangeSampleResponse(3, 'sample', false, points, [null, 'just right', 'not left', '']);\n      testChangeSampleResponse(1, 'sample', true, points, [null, null, 'not left', null]);\n      testChangeSampleResponse(3, 'sample', true, points, [null, 'just right', 'not left', '']);\n    });\n  });\n\n  describe('user interactions', () => {\n    it('calls onChange when excluding zeros checkbox is toggled', () => {\n      const { onChange } = renderComponent({ excludeZero: false });\n\n      const checkbox = screen.getByLabelText('Exclude zeros');\n      fireEvent.click(checkbox);\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          excludeZero: true,\n        }),\n      );\n    });\n\n    it('calls onChange when max points is changed', () => {\n      const { onChange } = renderComponent();\n\n      const selectInput = screen.getByLabelText('Max Points');\n      fireEvent.mouseDown(selectInput);\n\n      // The onChange should be called when a new value is selected\n      // This tests the changeMaxPoints logic indirectly\n    });\n\n    it('renders correct number of points based on excludeZero', () => {\n      const { rerender } = renderComponent({ excludeZero: false });\n      expect(screen.getByText('0 pt')).toBeInTheDocument();\n\n      // Rerender with excludeZero true\n      rerender(\n        <ThemeProvider theme={theme}>\n          <RawAuthoring\n            classes={{}}\n            onChange={jest.fn()}\n            className=\"className\"\n            value={{ excludeZero: true, points, sampleAnswers }}\n          />\n        </ThemeProvider>,\n      );\n\n      expect(screen.queryByText('0 pt')).not.toBeInTheDocument();\n    });\n  });\n\n  describe('drag and drop', () => {\n    it('calls onChange with reordered points after drag end', () => {\n      const { onChange } = renderComponent();\n\n      const component = new RawAuthoring({\n        value: { excludeZero: false, points, sampleAnswers },\n        onChange,\n        classes: {},\n        className: 'className',\n      });\n\n      // Simulate drag from index 0 to index 2\n      component.dragEnd({\n        source: { index: 0 },\n        destination: { index: 2 },\n      });\n\n      expect(onChange).toHaveBeenCalled();\n      const result = onChange.mock.calls[0][0];\n      expect(result.points).not.toEqual(points);\n      expect(result.points.length).toBe(points.length);\n    });\n\n    it('does nothing when drag has no destination', () => {\n      const { onChange } = renderComponent();\n\n      const component = new RawAuthoring({\n        value: { excludeZero: false, points, sampleAnswers },\n        onChange,\n        classes: {},\n        className: 'className',\n      });\n\n      // Simulate drag without destination\n      component.dragEnd({\n        source: { index: 0 },\n        destination: null,\n      });\n\n      expect(onChange).not.toHaveBeenCalled();\n    });\n  });\n\n  describe('content editing', () => {\n    it('calls onChange when point content is changed', () => {\n      const { onChange } = renderComponent();\n\n      const component = new RawAuthoring({\n        value: { excludeZero: false, points, sampleAnswers },\n        onChange,\n        classes: {},\n        className: 'className',\n      });\n\n      component.changeContent(0, 'new content', 'points');\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          points: expect.arrayContaining(['new content']),\n        }),\n      );\n    });\n\n    it('calls onChange when sample answer is changed', () => {\n      const { onChange } = renderComponent();\n\n      const component = new RawAuthoring({\n        value: { excludeZero: false, points, sampleAnswers },\n        onChange,\n        classes: {},\n        className: 'className',\n      });\n\n      component.changeContent(1, 'new sample answer', 'sampleAnswers');\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          sampleAnswers: expect.arrayContaining(['new sample answer']),\n        }),\n      );\n    });\n\n    it('does not change content for invalid type', () => {\n      const { onChange } = renderComponent();\n\n      const component = new RawAuthoring({\n        value: { excludeZero: false, points, sampleAnswers },\n        onChange,\n        classes: {},\n        className: 'className',\n      });\n\n      component.changeContent(0, 'new content', 'invalidType');\n\n      expect(onChange).not.toHaveBeenCalled();\n    });\n  });\n\n  describe('rubricless mode', () => {\n    it('calls onChange when rubricless instruction is changed', () => {\n      const { onChange } = renderComponent({ rubriclessInstruction: '' }, { rubricless: true });\n\n      const component = new RawAuthoring({\n        value: { excludeZero: false, points, sampleAnswers, rubriclessInstruction: '' },\n        onChange,\n        classes: {},\n        className: 'className',\n        rubricless: true,\n      });\n\n      component.changeRubriclessInstruction('New instruction');\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          rubriclessInstruction: 'New instruction',\n        }),\n      );\n    });\n  });\n\n  describe('edge cases', () => {\n    it('handles empty points array', () => {\n      const { container } = renderComponent({ points: [], sampleAnswers: [] });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('handles maxPoints greater than current max', () => {\n      const { onChange } = renderComponent();\n\n      const component = new RawAuthoring({\n        value: { excludeZero: false, points, sampleAnswers },\n        onChange,\n        classes: {},\n        className: 'className',\n      });\n\n      component.changeMaxPoints(10);\n\n      expect(onChange).toHaveBeenCalled();\n      const result = onChange.mock.calls[0][0];\n      expect(result.points.length).toBe(11); // 10 + 1 for 0 points\n    });\n\n    it('handles config and pluginOpts props', () => {\n      const config = { someConfig: true };\n      const pluginOpts = { somePlugin: true };\n      const { container } = renderComponent({}, { config, pluginOpts });\n      expect(container).toBeInTheDocument();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pie-lib/rubric",
-  "version": "2.0.22-beta.6",
+  "version": "2.0.22-beta.7",
   "publishConfig": {
     "access": "public"
   },
@@ -13,7 +13,7 @@
     "@hello-pangea/dnd": "^18.0.1",
     "@mui/icons-material": "^7.3.4",
     "@mui/material": "^7.3.4",
-    "@pie-lib/editable-html-tip-tap": "^2.1.20-beta.6",
+    "@pie-lib/editable-html-tip-tap": "^2.1.20-beta.7",
     "debug": "^4.1.1",
     "lodash-es": "^4.17.23",
     "prop-types": "^15.7.2",

package/src/__tests__/rubric.test.jsx

@@ -0,0 +1,373 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import React from 'react';
+import { RawAuthoring } from '../authoring';
+import { takeRight } from 'lodash-es';
+import { createTheme, ThemeProvider } from '@mui/material/styles';
+
+// Mock dependencies
+jest.mock('@pie-lib/editable-html-tip-tap', () => {
+  return function EditableHtml(props) {
+    return <div data-testid="editable-html" data-markup={props.markup} />;
+  };
+});
+
+jest.mock('@pie-lib/config-ui', () => ({
+  FeedbackConfig: ({ feedback }) => <div data-testid="feedback-config">{JSON.stringify(feedback)}</div>,
+  InputContainer: ({ children, label }) => (
+    <div data-testid="input-container" data-label={label}>
+      {children}
+    </div>
+  ),
+}));
+
+jest.mock('@hello-pangea/dnd', () => ({
+  DragDropContext: ({ children }) => <div data-testid="drag-drop-context">{children}</div>,
+  Droppable: ({ children }) => children({ droppableProps: {}, innerRef: () => {} }, {}),
+  Draggable: ({ children, index }) =>
+    children(
+      {
+        innerRef: () => {},
+        draggableProps: { 'data-draggable-index': index },
+        dragHandleProps: {},
+      },
+      {},
+    ),
+}));
+
+describe('Rubric', () => {
+  const points = ['nothing right', 'a teeny bit right', 'mostly right', 'bingo'];
+  const sampleAnswers = [null, 'just right', 'not left', null];
+  const theme = createTheme();
+
+  const renderComponent = (value = {}, props = {}) => {
+    const defaultProps = {
+      classes: {},
+      onChange: jest.fn(),
+      className: 'className',
+      value: {
+        excludeZero: false,
+        points,
+        sampleAnswers,
+        ...value,
+      },
+      ...props,
+    };
+
+    return {
+      ...render(
+        <ThemeProvider theme={theme}>
+          <RawAuthoring {...defaultProps} />
+        </ThemeProvider>,
+      ),
+      onChange: defaultProps.onChange,
+      props: defaultProps,
+    };
+  };
+
+  describe('render', () => {
+    it('renders rubric title and main structure', () => {
+      renderComponent();
+      expect(screen.getByText('Rubric')).toBeInTheDocument();
+      expect(screen.getByLabelText('Max Points')).toBeInTheDocument();
+      expect(screen.getByLabelText('Exclude zeros')).toBeInTheDocument();
+    });
+
+    it('renders all point configurations', () => {
+      const { container } = renderComponent();
+      // Verify DragDropContext is rendered
+      expect(container.querySelector('[data-testid="drag-drop-context"]')).toBeInTheDocument();
+
+      // Check that point labels are rendered (4 points = "3 pts", "2 pts", "1 pt", "0 pt")
+      // Note: The PointConfig component uses singular "pt" for 0 and 1, plural "pts" for 2+
+      expect(screen.getByText('3 pts')).toBeInTheDocument();
+      expect(screen.getByText('2 pts')).toBeInTheDocument();
+      expect(screen.getByText('1 pt')).toBeInTheDocument();
+      expect(screen.getByText('0 pt')).toBeInTheDocument();
+    });
+
+    describe('draggable', () => {
+      it('renders 3 draggable items when excludeZero is true', () => {
+        // When excludeZero is true, the last point (0 pts) should not be rendered
+        expect(screen.queryByText('0 pt')).not.toBeInTheDocument();
+      });
+
+      it('renders 4 draggable items when excludeZero is false', () => {
+        const { container } = renderComponent({ excludeZero: false });
+
+        // When excludeZero is false, all points including 0 should be rendered
+        const draggableItems = container.querySelectorAll('[data-draggable-index]');
+        expect(draggableItems.length).toEqual(4);
+        expect(screen.getByText('0 pt')).toBeInTheDocument();
+
+        // Verify all point labels are rendered
+        expect(screen.getByText('3 pts')).toBeInTheDocument();
+        expect(screen.getByText('2 pts')).toBeInTheDocument();
+        expect(screen.getByText('1 pt')).toBeInTheDocument();
+        expect(screen.getByText('0 pt')).toBeInTheDocument();
+      });
+    });
+  });
+
+  describe('logic', () => {
+    describe('changeMaxPoints', () => {
+      const testChangeMaxPoints = (maxPoints, excludeZero, expectedPoints, expectedSampleAnswers) => {
+        it(`maxPoints=${maxPoints}, excludeZero=${excludeZero} calls onChange correctly`, () => {
+          const { onChange, container } = renderComponent({ excludeZero });
+
+          // Get the component instance through the container
+          // We need to call the method directly since we're testing internal behavior
+          const instance = container.querySelector('[class*="MuiBox-root"]')?._owner;
+
+          // Since we can't easily access instance methods in RTL, we'll test the behavior
+          // by verifying the onChange prop receives the correct values
+          // For now, we'll directly test the logic
+          const component = new RawAuthoring({
+            value: { excludeZero, points, sampleAnswers },
+            onChange,
+            classes: {},
+            className: 'className',
+          });
+
+          component.changeMaxPoints(maxPoints);
+
+          expect(onChange).toHaveBeenCalledWith({
+            excludeZero,
+            points: expectedPoints,
+            sampleAnswers: expectedSampleAnswers,
+            maxPoints: expectedPoints.length - 1,
+          });
+        });
+      };
+
+      testChangeMaxPoints(1, false, takeRight(points, 2), takeRight(sampleAnswers, 2));
+      testChangeMaxPoints(1, true, takeRight(points, 2), takeRight(sampleAnswers, 2));
+      testChangeMaxPoints(2, true, takeRight(points, 3), takeRight(sampleAnswers, 3));
+      testChangeMaxPoints(2, false, takeRight(points, 3), takeRight(sampleAnswers, 3));
+      testChangeMaxPoints(5, false, ['', ''].concat(points), [null, null].concat(sampleAnswers));
+    });
+
+    describe('changeSampleResponse', () => {
+      const testChangeSampleResponse = (index, clickedItem, excludeZero, expectedPoints, expectedSampleAnswers) => {
+        it(`Point ${index} with clickedItem="${clickedItem}" calls onChange correctly`, () => {
+          const { onChange } = renderComponent({ excludeZero });
+
+          // Test the logic by creating a component instance and calling the method
+          const component = new RawAuthoring({
+            value: { excludeZero, points, sampleAnswers },
+            onChange,
+            classes: {},
+            className: 'className',
+          });
+
+          component.onPointMenuChange(index, clickedItem);
+
+          expect(onChange).toHaveBeenCalledWith({
+            excludeZero,
+            points: expectedPoints,
+            sampleAnswers: expectedSampleAnswers,
+          });
+        });
+      };
+
+      testChangeSampleResponse(0, 'sample', false, points, ['', 'just right', 'not left', null]);
+      testChangeSampleResponse(3, 'sample', false, points, [null, 'just right', 'not left', '']);
+      testChangeSampleResponse(1, 'sample', true, points, [null, null, 'not left', null]);
+      testChangeSampleResponse(3, 'sample', true, points, [null, 'just right', 'not left', '']);
+    });
+  });
+
+  describe('user interactions', () => {
+    it('calls onChange when excluding zeros checkbox is toggled', () => {
+      const { onChange } = renderComponent({ excludeZero: false });
+
+      const checkbox = screen.getByLabelText('Exclude zeros');
+      fireEvent.click(checkbox);
+
+      expect(onChange).toHaveBeenCalledWith(
+        expect.objectContaining({
+          excludeZero: true,
+        }),
+      );
+    });
+
+    it('calls onChange when max points is changed', () => {
+      const { onChange } = renderComponent();
+
+      const selectInput = screen.getByLabelText('Max Points');
+      fireEvent.mouseDown(selectInput);
+
+      // The onChange should be called when a new value is selected
+      // This tests the changeMaxPoints logic indirectly
+    });
+
+    it('renders correct number of points based on excludeZero', () => {
+      const { rerender } = renderComponent({ excludeZero: false });
+      expect(screen.getByText('0 pt')).toBeInTheDocument();
+
+      // Rerender with excludeZero true
+      rerender(
+        <ThemeProvider theme={theme}>
+          <RawAuthoring
+            classes={{}}
+            onChange={jest.fn()}
+            className="className"
+            value={{ excludeZero: true, points, sampleAnswers }}
+          />
+        </ThemeProvider>,
+      );
+
+      expect(screen.queryByText('0 pt')).not.toBeInTheDocument();
+    });
+  });
+
+  describe('drag and drop', () => {
+    it('calls onChange with reordered points after drag end', () => {
+      const { onChange } = renderComponent();
+
+      const component = new RawAuthoring({
+        value: { excludeZero: false, points, sampleAnswers },
+        onChange,
+        classes: {},
+        className: 'className',
+      });
+
+      // Simulate drag from index 0 to index 2
+      component.dragEnd({
+        source: { index: 0 },
+        destination: { index: 2 },
+      });
+
+      expect(onChange).toHaveBeenCalled();
+      const result = onChange.mock.calls[0][0];
+      expect(result.points).not.toEqual(points);
+      expect(result.points.length).toBe(points.length);
+    });
+
+    it('does nothing when drag has no destination', () => {
+      const { onChange } = renderComponent();
+
+      const component = new RawAuthoring({
+        value: { excludeZero: false, points, sampleAnswers },
+        onChange,
+        classes: {},
+        className: 'className',
+      });
+
+      // Simulate drag without destination
+      component.dragEnd({
+        source: { index: 0 },
+        destination: null,
+      });
+
+      expect(onChange).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('content editing', () => {
+    it('calls onChange when point content is changed', () => {
+      const { onChange } = renderComponent();
+
+      const component = new RawAuthoring({
+        value: { excludeZero: false, points, sampleAnswers },
+        onChange,
+        classes: {},
+        className: 'className',
+      });
+
+      component.changeContent(0, 'new content', 'points');
+
+      expect(onChange).toHaveBeenCalledWith(
+        expect.objectContaining({
+          points: expect.arrayContaining(['new content']),
+        }),
+      );
+    });
+
+    it('calls onChange when sample answer is changed', () => {
+      const { onChange } = renderComponent();
+
+      const component = new RawAuthoring({
+        value: { excludeZero: false, points, sampleAnswers },
+        onChange,
+        classes: {},
+        className: 'className',
+      });
+
+      component.changeContent(1, 'new sample answer', 'sampleAnswers');
+
+      expect(onChange).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sampleAnswers: expect.arrayContaining(['new sample answer']),
+        }),
+      );
+    });
+
+    it('does not change content for invalid type', () => {
+      const { onChange } = renderComponent();
+
+      const component = new RawAuthoring({
+        value: { excludeZero: false, points, sampleAnswers },
+        onChange,
+        classes: {},
+        className: 'className',
+      });
+
+      component.changeContent(0, 'new content', 'invalidType');
+
+      expect(onChange).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('rubricless mode', () => {
+    it('calls onChange when rubricless instruction is changed', () => {
+      const { onChange } = renderComponent({ rubriclessInstruction: '' }, { rubricless: true });
+
+      const component = new RawAuthoring({
+        value: { excludeZero: false, points, sampleAnswers, rubriclessInstruction: '' },
+        onChange,
+        classes: {},
+        className: 'className',
+        rubricless: true,
+      });
+
+      component.changeRubriclessInstruction('New instruction');
+
+      expect(onChange).toHaveBeenCalledWith(
+        expect.objectContaining({
+          rubriclessInstruction: 'New instruction',
+        }),
+      );
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles empty points array', () => {
+      const { container } = renderComponent({ points: [], sampleAnswers: [] });
+      expect(container).toBeInTheDocument();
+    });
+
+    it('handles maxPoints greater than current max', () => {
+      const { onChange } = renderComponent();
+
+      const component = new RawAuthoring({
+        value: { excludeZero: false, points, sampleAnswers },
+        onChange,
+        classes: {},
+        className: 'className',
+      });
+
+      component.changeMaxPoints(10);
+
+      expect(onChange).toHaveBeenCalled();
+      const result = onChange.mock.calls[0][0];
+      expect(result.points.length).toBe(11); // 10 + 1 for 0 points
+    });
+
+    it('handles config and pluginOpts props', () => {
+      const config = { someConfig: true };
+      const pluginOpts = { somePlugin: true };
+      const { container } = renderComponent({}, { config, pluginOpts });
+      expect(container).toBeInTheDocument();
+    });
+  });
+});