@pie-lib/editable-html-tip-tap 1.2.0-next.0 → 1.2.0-next.2

package/lib/components/__tests__/InsertImageHandler.test.js

@@ -0,0 +1,162 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _InsertImageHandler = _interopRequireDefault(require("../image/InsertImageHandler"));
+describe('InsertImageHandler', function () {
+  var mockNode = {
+    attrs: {},
+    nodeSize: 1
+  };
+  var createMockEditor = function createMockEditor() {
+    return {
+      state: {
+        doc: {
+          descendants: jest.fn(function (callback) {
+            callback(mockNode, 5);
+          })
+        },
+        tr: {
+          setNodeMarkup: jest.fn(function (pos, type, attrs) {
+            return {
+              setNodeMarkup: jest.fn()
+            };
+          }),
+          "delete": jest.fn(function (from, to) {
+            return {
+              "delete": jest.fn()
+            };
+          })
+        }
+      },
+      view: {
+        dispatch: jest.fn()
+      }
+    };
+  };
+  var mockOnFinish = jest.fn();
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+  it('creates handler instance', function () {
+    var editor = createMockEditor();
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    expect(handler).toBeDefined();
+    expect(handler.editor).toBe(editor);
+    expect(handler.node).toBe(mockNode);
+    expect(handler.onFinish).toBe(mockOnFinish);
+  });
+  it('stores nodePos from descendants', function () {
+    var editor = createMockEditor();
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    expect(handler.nodePos).toBe(5);
+  });
+  it('stores isPasted parameter', function () {
+    var editor = createMockEditor();
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish, true);
+    expect(handler.isPasted).toBe(true);
+  });
+  it('defaults isPasted to false', function () {
+    var editor = createMockEditor();
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    expect(handler.isPasted).toBe(false);
+  });
+  it('cancel deletes node and calls onFinish', function () {
+    var editor = createMockEditor();
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    handler.cancel();
+    expect(mockOnFinish).toHaveBeenCalledWith(false);
+  });
+  it('updateNode dispatches transaction with new attributes', function () {
+    var editor = createMockEditor();
+    var mockNodeAt = jest.fn(function () {
+      return {
+        attrs: {
+          existing: 'value'
+        }
+      };
+    });
+    editor.state.doc.nodeAt = mockNodeAt;
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    handler.updateNode({
+      newAttr: 'newValue'
+    });
+    expect(mockNodeAt).toHaveBeenCalledWith(5);
+    expect(editor.view.dispatch).toHaveBeenCalled();
+  });
+  it('done calls onFinish with false on error', function () {
+    var editor = createMockEditor();
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    var consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+    handler.done('error', null);
+    expect(consoleLogSpy).toHaveBeenCalledWith('error');
+    expect(mockOnFinish).toHaveBeenCalledWith(false);
+    consoleLogSpy.mockRestore();
+  });
+  it('done updates node and calls onFinish with true on success', function () {
+    var editor = createMockEditor();
+    var mockNodeAt = jest.fn(function () {
+      return {
+        attrs: {}
+      };
+    });
+    editor.state.doc.nodeAt = mockNodeAt;
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    handler.done(null, 'http://example.com/image.jpg');
+    expect(editor.view.dispatch).toHaveBeenCalled();
+    expect(mockOnFinish).toHaveBeenCalledWith(true);
+  });
+  it('fileChosen returns early when no file provided', function () {
+    var editor = createMockEditor();
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    handler.fileChosen(null);
+    expect(editor.view.dispatch).not.toHaveBeenCalled();
+  });
+  it('fileChosen saves file and reads it as data URL', function () {
+    var editor = createMockEditor();
+    var mockNodeAt = jest.fn(function () {
+      return {
+        attrs: {}
+      };
+    });
+    editor.state.doc.nodeAt = mockNodeAt;
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    var mockFile = new File(['content'], 'test.jpg', {
+      type: 'image/jpeg'
+    });
+    global.FileReader = jest.fn(function () {
+      this.readAsDataURL = jest.fn(function () {
+        this.result = 'data:image/jpeg;base64,abc123';
+        this.onload();
+      });
+    });
+    handler.fileChosen(mockFile);
+    expect(handler.chosenFile).toBe(mockFile);
+  });
+  it('progress updates node with percent', function () {
+    var editor = createMockEditor();
+    var mockNodeAt = jest.fn(function () {
+      return {
+        attrs: {}
+      };
+    });
+    editor.state.doc.nodeAt = mockNodeAt;
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    handler.progress(50, 500, 1000);
+    expect(editor.view.dispatch).toHaveBeenCalled();
+  });
+  it('getChosenFile returns the chosen file', function () {
+    var editor = createMockEditor();
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    var mockFile = new File(['content'], 'test.jpg', {
+      type: 'image/jpeg'
+    });
+    handler.chosenFile = mockFile;
+    expect(handler.getChosenFile()).toBe(mockFile);
+  });
+  it('getChosenFile returns null initially', function () {
+    var editor = createMockEditor();
+    var handler = new _InsertImageHandler["default"](editor, mockNode, mockOnFinish);
+    expect(handler.getChosenFile()).toBeNull();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_InsertImageHandler","_interopRequireDefault","require","describe","mockNode","attrs","nodeSize","createMockEditor","state","doc","descendants","jest","fn","callback","tr","setNodeMarkup","pos","type","from","to","view","dispatch","mockOnFinish","beforeEach","clearAllMocks","it","editor","handler","InsertImageHandler","expect","toBeDefined","toBe","node","onFinish","nodePos","isPasted","cancel","toHaveBeenCalledWith","mockNodeAt","existing","nodeAt","updateNode","newAttr","toHaveBeenCalled","consoleLogSpy","spyOn","console","mockImplementation","done","mockRestore","fileChosen","not","mockFile","File","global","FileReader","readAsDataURL","result","onload","chosenFile","progress","getChosenFile","toBeNull"],"sources":["../../../src/components/__tests__/InsertImageHandler.test.js"],"sourcesContent":["import InsertImageHandler from '../image/InsertImageHandler';\n\ndescribe('InsertImageHandler', () => {\n  const mockNode = {\n    attrs: {},\n    nodeSize: 1,\n  };\n\n  const createMockEditor = () => ({\n    state: {\n      doc: {\n        descendants: jest.fn((callback) => {\n          callback(mockNode, 5);\n        }),\n      },\n      tr: {\n        setNodeMarkup: jest.fn((pos, type, attrs) => ({ setNodeMarkup: jest.fn() })),\n        delete: jest.fn((from, to) => ({ delete: jest.fn() })),\n      },\n    },\n    view: {\n      dispatch: jest.fn(),\n    },\n  });\n\n  const mockOnFinish = jest.fn();\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  it('creates handler instance', () => {\n    const editor = createMockEditor();\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    expect(handler).toBeDefined();\n    expect(handler.editor).toBe(editor);\n    expect(handler.node).toBe(mockNode);\n    expect(handler.onFinish).toBe(mockOnFinish);\n  });\n\n  it('stores nodePos from descendants', () => {\n    const editor = createMockEditor();\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    expect(handler.nodePos).toBe(5);\n  });\n\n  it('stores isPasted parameter', () => {\n    const editor = createMockEditor();\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish, true);\n    expect(handler.isPasted).toBe(true);\n  });\n\n  it('defaults isPasted to false', () => {\n    const editor = createMockEditor();\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    expect(handler.isPasted).toBe(false);\n  });\n\n  it('cancel deletes node and calls onFinish', () => {\n    const editor = createMockEditor();\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    handler.cancel();\n    expect(mockOnFinish).toHaveBeenCalledWith(false);\n  });\n\n  it('updateNode dispatches transaction with new attributes', () => {\n    const editor = createMockEditor();\n    const mockNodeAt = jest.fn(() => ({ attrs: { existing: 'value' } }));\n    editor.state.doc.nodeAt = mockNodeAt;\n\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    handler.updateNode({ newAttr: 'newValue' });\n\n    expect(mockNodeAt).toHaveBeenCalledWith(5);\n    expect(editor.view.dispatch).toHaveBeenCalled();\n  });\n\n  it('done calls onFinish with false on error', () => {\n    const editor = createMockEditor();\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();\n\n    handler.done('error', null);\n\n    expect(consoleLogSpy).toHaveBeenCalledWith('error');\n    expect(mockOnFinish).toHaveBeenCalledWith(false);\n    consoleLogSpy.mockRestore();\n  });\n\n  it('done updates node and calls onFinish with true on success', () => {\n    const editor = createMockEditor();\n    const mockNodeAt = jest.fn(() => ({ attrs: {} }));\n    editor.state.doc.nodeAt = mockNodeAt;\n\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    handler.done(null, 'http://example.com/image.jpg');\n\n    expect(editor.view.dispatch).toHaveBeenCalled();\n    expect(mockOnFinish).toHaveBeenCalledWith(true);\n  });\n\n  it('fileChosen returns early when no file provided', () => {\n    const editor = createMockEditor();\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    handler.fileChosen(null);\n    expect(editor.view.dispatch).not.toHaveBeenCalled();\n  });\n\n  it('fileChosen saves file and reads it as data URL', () => {\n    const editor = createMockEditor();\n    const mockNodeAt = jest.fn(() => ({ attrs: {} }));\n    editor.state.doc.nodeAt = mockNodeAt;\n\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    const mockFile = new File(['content'], 'test.jpg', { type: 'image/jpeg' });\n\n    global.FileReader = jest.fn(function () {\n      this.readAsDataURL = jest.fn(function () {\n        this.result = 'data:image/jpeg;base64,abc123';\n        this.onload();\n      });\n    });\n\n    handler.fileChosen(mockFile);\n\n    expect(handler.chosenFile).toBe(mockFile);\n  });\n\n  it('progress updates node with percent', () => {\n    const editor = createMockEditor();\n    const mockNodeAt = jest.fn(() => ({ attrs: {} }));\n    editor.state.doc.nodeAt = mockNodeAt;\n\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    handler.progress(50, 500, 1000);\n\n    expect(editor.view.dispatch).toHaveBeenCalled();\n  });\n\n  it('getChosenFile returns the chosen file', () => {\n    const editor = createMockEditor();\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    const mockFile = new File(['content'], 'test.jpg', { type: 'image/jpeg' });\n    handler.chosenFile = mockFile;\n\n    expect(handler.getChosenFile()).toBe(mockFile);\n  });\n\n  it('getChosenFile returns null initially', () => {\n    const editor = createMockEditor();\n    const handler = new InsertImageHandler(editor, mockNode, mockOnFinish);\n    expect(handler.getChosenFile()).toBeNull();\n  });\n});\n"],"mappings":"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","ignoreList":[]}