@risleylima/escpos 0.0.13 → 0.1.0

package/tests/unit/adapters/usb-adapter.test.js

@@ -0,0 +1,319 @@
+'use strict';
+
+const USB = require('../../../src/usb-adapter');
+const usb = require('usb');
+
+// Mock usb module (v2 API - uses Promises)
+jest.mock('usb', () => {
+  const createMockDevice = () => {
+    const mockEndpoint = {
+      direction: 'out',
+      transfer: jest.fn().mockResolvedValue(undefined)
+    };
+
+    const mockInterface = {
+      isKernelDriverActive: jest.fn().mockReturnValue(false),
+      claim: jest.fn().mockResolvedValue(undefined),
+      release: jest.fn().mockResolvedValue(undefined),
+      detachKernelDriver: jest.fn().mockResolvedValue(undefined),
+      descriptor: {
+        bInterfaceClass: 0x07, // PRINTER class
+        bInterfaceNumber: 0
+      },
+      endpoints: [mockEndpoint]
+    };
+
+    // Link endpoint to interface (v2 API structure)
+    mockEndpoint.interface = mockInterface;
+
+    return {
+      open: jest.fn().mockResolvedValue(undefined),
+      close: jest.fn().mockResolvedValue(undefined),
+      interfaces: [mockInterface],
+      configDescriptor: {
+        interfaces: [
+          [
+            {
+              bInterfaceClass: 0x07 // PRINTER class
+            }
+          ]
+        ]
+      },
+      deviceDescriptor: {
+        iManufacturer: 1,
+        iProduct: 2
+      },
+      getStringDescriptor: jest.fn().mockResolvedValue('Device String')
+    };
+  };
+
+  // Create a single shared mock device instance that persists across tests
+  // This ensures the same device is returned every time, maintaining state
+  const mockDeviceInstance = createMockDevice();
+
+  return {
+    getDeviceList: jest.fn().mockReturnValue([mockDeviceInstance]),
+    findByIds: jest.fn().mockReturnValue(mockDeviceInstance),
+    on: jest.fn()
+  };
+});
+
+describe('USB Adapter', () => {
+  beforeEach(() => {
+    // Don't clear mocks that break the device structure
+    // Only clear call history for methods that need it
+    const mockDevice = usb.findByIds(1046, 20497);
+    if (mockDevice) {
+      // Clear call history but preserve mock structure
+      if (mockDevice.open && typeof mockDevice.open.mockClear === 'function') {
+        mockDevice.open.mockClear();
+      }
+      if (mockDevice.close && typeof mockDevice.close.mockClear === 'function') {
+        mockDevice.close.mockClear();
+      }
+      if (mockDevice.interfaces && mockDevice.interfaces[0]) {
+        if (mockDevice.interfaces[0].claim && typeof mockDevice.interfaces[0].claim.mockClear === 'function') {
+          mockDevice.interfaces[0].claim.mockClear();
+        }
+        if (mockDevice.interfaces[0].release && typeof mockDevice.interfaces[0].release.mockClear === 'function') {
+          mockDevice.interfaces[0].release.mockClear();
+        }
+        if (mockDevice.interfaces[0].endpoints && mockDevice.interfaces[0].endpoints[0]) {
+          if (mockDevice.interfaces[0].endpoints[0].transfer && typeof mockDevice.interfaces[0].endpoints[0].transfer.mockClear === 'function') {
+            mockDevice.interfaces[0].endpoints[0].transfer.mockClear();
+          }
+        }
+      }
+    }
+    // Don't clear findByIds mock as it needs to return the device
+    // usb.findByIds.mockClear(); // Commented out to preserve mock return value
+    // usb.getDeviceList.mockClear(); // Commented out to preserve mock return value
+  });
+
+  describe('listUSB', () => {
+    it('should list USB printer devices', async () => {
+      const devices = await USB.listUSB();
+      expect(Array.isArray(devices)).toBe(true);
+    });
+
+    it('should filter only printer devices', async () => {
+      const devices = await USB.listUSB();
+      // Should only return devices with PRINTER interface class
+      expect(devices.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should get device manufacturer and product strings', async () => {
+      const devices = await USB.listUSB();
+      if (devices.length > 0) {
+        const device = devices[0];
+        expect(device.manufacturer).toBeDefined();
+        expect(device.product).toBeDefined();
+      }
+    });
+
+    it('should handle devices without descriptors gracefully', async () => {
+      // Mock a device that fails to get descriptor
+      const mockDeviceWithoutDescriptor = {
+        open: jest.fn().mockResolvedValue(undefined),
+        close: jest.fn().mockResolvedValue(undefined),
+        getStringDescriptor: jest.fn().mockRejectedValue(new Error('Descriptor error')),
+        configDescriptor: {
+          interfaces: [
+            [
+              {
+                bInterfaceClass: 0x07
+              }
+            ]
+          ]
+        },
+        deviceDescriptor: {
+          iManufacturer: 1,
+          iProduct: 2
+        }
+      };
+
+      usb.getDeviceList.mockReturnValueOnce([mockDeviceWithoutDescriptor]);
+      
+      const devices = await USB.listUSB();
+      // Should not include devices that fail to get descriptors
+      expect(devices.length).toBe(0);
+    });
+  });
+
+  describe('connect', () => {
+    it('should connect to device by VID/PID', async () => {
+      const result = await USB.connect(1046, 20497);
+      expect(result).toBe(true);
+      expect(usb.findByIds).toHaveBeenCalledWith(1046, 20497);
+    });
+
+    it('should connect to first available device if no VID/PID', async () => {
+      const result = await USB.connect();
+      expect(result).toBe(true);
+    });
+
+    it('should throw error if device not found', async () => {
+      usb.findByIds.mockReturnValueOnce(null);
+      usb.getDeviceList.mockReturnValueOnce([]);
+
+      await expect(USB.connect(9999, 9999)).rejects.toThrow('Cannot find printer!');
+    });
+
+    it('should emit connect event', (done) => {
+      USB.once('connect', () => {
+        done();
+      });
+      USB.connect(1046, 20497);
+    });
+  });
+
+  describe('open', () => {
+    beforeEach(async () => {
+      await USB.connect(1046, 20497);
+    });
+
+    it('should open device connection', async () => {
+      const result = await USB.open();
+      expect(result).toBe(true);
+      
+      // Verify device.open was called
+      const mockDevice = usb.findByIds(1046, 20497);
+      expect(mockDevice.open).toHaveBeenCalled();
+      
+      // Verify interface was claimed
+      if (mockDevice.interfaces && mockDevice.interfaces[0]) {
+        expect(mockDevice.interfaces[0].claim).toHaveBeenCalled();
+      }
+    });
+
+    it('should find output endpoint', async () => {
+      await USB.open();
+      // Endpoint should be found (mocked)
+      expect(USB.write).toBeDefined();
+      
+      // Verify endpoint was found
+      const mockDevice = usb.findByIds(1046, 20497);
+      if (mockDevice.interfaces && mockDevice.interfaces[0] && mockDevice.interfaces[0].endpoints[0]) {
+        expect(mockDevice.interfaces[0].endpoints[0].direction).toBe('out');
+      }
+    });
+
+    it('should throw error if endpoint not found', async () => {
+      const mockDevice = usb.findByIds(1046, 20497);
+      // Save original interfaces to restore later
+      const originalInterfaces = mockDevice.interfaces;
+      
+      const mockInterfaceWithoutEndpoints = {
+        isKernelDriverActive: jest.fn().mockReturnValue(false),
+        claim: jest.fn().mockResolvedValue(undefined),
+        release: jest.fn().mockResolvedValue(undefined),
+        detachKernelDriver: jest.fn().mockResolvedValue(undefined),
+        descriptor: {
+          bInterfaceClass: 0x07,
+          bInterfaceNumber: 0
+        },
+        endpoints: [] // No endpoints
+      };
+      mockDevice.interfaces = [mockInterfaceWithoutEndpoints];
+
+      try {
+        await expect(USB.open()).rejects.toThrow('Can not find endpoint from printer');
+      } finally {
+        // Restore original interfaces to prevent affecting other tests
+        mockDevice.interfaces = originalInterfaces;
+      }
+    });
+  });
+
+  describe('write', () => {
+    beforeEach(async () => {
+      await USB.connect(1046, 20497);
+      await USB.open();
+    });
+
+    it('should write data to endpoint', async () => {
+      const testData = Buffer.from('test', 'ascii');
+      const result = await USB.write(testData);
+      expect(result).toBe(true);
+      
+      // Verify that endpoint.transfer was called with correct data
+      const mockDevice = usb.findByIds(1046, 20497);
+      if (mockDevice.interfaces && mockDevice.interfaces[0] && mockDevice.interfaces[0].endpoints[0]) {
+        expect(mockDevice.interfaces[0].endpoints[0].transfer).toHaveBeenCalledWith(testData);
+      }
+    });
+  });
+
+  describe('close', () => {
+    beforeEach(async () => {
+      await USB.connect(1046, 20497);
+      await USB.open();
+    });
+
+    it('should close device connection', async () => {
+      const result = await USB.close();
+      expect(result).toBe(true);
+      
+      // Verify that interface release was called
+      const mockDevice = usb.findByIds(1046, 20497);
+      if (mockDevice.interfaces && mockDevice.interfaces[0]) {
+        expect(mockDevice.interfaces[0].release).toHaveBeenCalled();
+      }
+      expect(mockDevice.close).toHaveBeenCalled();
+    });
+
+    it('should emit close event', async () => {
+      let eventReceived = false;
+      const promise = new Promise((resolve) => {
+        USB.once('close', () => {
+          eventReceived = true;
+          resolve();
+        });
+      });
+      
+      expect(USB.listenerCount('close')).toBe(1);
+      
+      await USB.close();
+      
+      await Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Close event not emitted within timeout')), 1000))
+      ]);
+      
+      expect(eventReceived).toBe(true);
+    });
+  });
+
+  describe('disconnect', () => {
+    beforeEach(async () => {
+      await USB.connect(1046, 20497);
+    });
+
+    it('should disconnect device', async () => {
+      const result = await USB.disconnect();
+      expect(result).toBe(true);
+    });
+
+    it('should emit disconnect event', async () => {
+      let eventReceived = false;
+      const promise = new Promise((resolve) => {
+        USB.once('disconnect', () => {
+          eventReceived = true;
+          resolve();
+        });
+      });
+      
+      expect(USB.listenerCount('disconnect')).toBe(1);
+      
+      await USB.disconnect();
+      
+      await Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Disconnect event not emitted within timeout')), 1000))
+      ]);
+      
+      expect(eventReceived).toBe(true);
+    });
+  });
+});
+

package/tests/unit/image/image.test.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const Image = require('../../../src/printer/image');
+
+// Mock get-pixels
+jest.mock('get-pixels', () => {
+  return jest.fn((url, type, callback) => {
+    // Simula pixels de uma imagem 4x4 RGB
+    const mockPixels = {
+      shape: [4, 4, 3], // width, height, channels
+      data: new Uint8Array(4 * 4 * 3).fill(0)
+    };
+    
+    // Preenche alguns pixels como "pretos" (valores baixos)
+    for (let i = 0; i < 8; i++) {
+      mockPixels.data[i] = 50; // Pixel escuro
+    }
+    
+    // Preenche outros como "brancos" (valores altos)
+    for (let i = 24; i < 48; i++) {
+      mockPixels.data[i] = 250; // Pixel claro
+    }
+    
+    callback(null, mockPixels);
+  });
+});
+
+describe('Image', () => {
+  describe('load', () => {
+    it('should load image from URL', async () => {
+      const image = await Image.load('test.png', 'image/png');
+      expect(image).toBeInstanceOf(Image);
+      expect(image.size.width).toBe(4);
+      expect(image.size.height).toBe(4);
+      expect(image.size.colors).toBe(3);
+    });
+
+    it('should reject on error', async () => {
+      const getPixels = require('get-pixels');
+      getPixels.mockImplementationOnce((url, type, callback) => {
+        callback(new Error('Load failed'), null);
+      });
+
+      await expect(Image.load('invalid.png', 'image/png')).rejects.toThrow('Load failed');
+    });
+  });
+
+  describe('Constructor', () => {
+    it('should create image from pixels', () => {
+      const mockPixels = {
+        shape: [2, 2, 3],
+        data: new Uint8Array([0, 0, 0, 255, 255, 255, 0, 0, 0, 255, 255, 255])
+      };
+
+      const image = new Image(mockPixels);
+      expect(image.size.width).toBe(2);
+      expect(image.size.height).toBe(2);
+      expect(image.size.colors).toBe(3);
+      expect(image.data.length).toBe(4);
+    });
+
+    it('should convert pixels to binary data', () => {
+      const mockPixels = {
+        shape: [2, 2, 4], // width, height, channels (RGBA)
+        data: new Uint8Array([
+          0, 0, 0, 255,        // Pixel 0: preto (RGB=0,0,0)
+          255, 255, 255, 255,  // Pixel 1: branco (RGB=255,255,255)
+          0, 0, 0, 255,        // Pixel 2: preto (RGB=0,0,0)
+          255, 255, 255, 255   // Pixel 3: branco (RGB=255,255,255)
+        ])
+      };
+
+      const image = new Image(mockPixels);
+      expect(image.data[0]).toBe(1); // Preto = 1 (r=0, g=0, b=0, não é branco)
+      expect(image.data[1]).toBe(0); // Branco = 0 (r>200, g>200, b>200)
+      expect(image.data[2]).toBe(1); // Preto = 1
+      expect(image.data[3]).toBe(0); // Branco = 0
+    });
+
+    it('should handle transparent pixels', () => {
+      const mockPixels = {
+        shape: [1, 1, 4], // RGBA
+        data: new Uint8Array([255, 255, 255, 0]) // Transparente
+      };
+
+      const image = new Image(mockPixels);
+      expect(image.data[0]).toBe(0); // Transparente = 0
+    });
+  });
+
+  describe('toBitmap', () => {
+    it('should convert to bitmap format', async () => {
+      const image = await Image.load('test.png', 'image/png');
+      const bitmap = image.toBitmap(24);
+
+      expect(bitmap).toHaveProperty('data');
+      expect(bitmap).toHaveProperty('density');
+      expect(bitmap.density).toBe(24);
+      expect(Array.isArray(bitmap.data)).toBe(true);
+    });
+
+    it('should use default density of 24', async () => {
+      const image = await Image.load('test.png', 'image/png');
+      const bitmap = image.toBitmap();
+
+      expect(bitmap.density).toBe(24);
+    });
+
+    it('should handle different densities', async () => {
+      const image = await Image.load('test.png', 'image/png');
+      const bitmap8 = image.toBitmap(8);
+      const bitmap24 = image.toBitmap(24);
+
+      expect(bitmap8.density).toBe(8);
+      expect(bitmap24.density).toBe(24);
+    });
+
+    it('should generate correct bitmap structure', async () => {
+      const image = await Image.load('test.png', 'image/png');
+      const bitmap = image.toBitmap(8);
+
+      expect(bitmap.data.length).toBeGreaterThan(0);
+      bitmap.data.forEach(line => {
+        expect(Array.isArray(line)).toBe(true);
+      });
+    });
+  });
+
+  describe('toRaster', () => {
+    it('should convert to raster format', async () => {
+      const image = await Image.load('test.png', 'image/png');
+      const raster = image.toRaster();
+
+      expect(raster).toHaveProperty('data');
+      expect(raster).toHaveProperty('width');
+      expect(raster).toHaveProperty('height');
+      expect(Array.isArray(raster.data)).toBe(true);
+    });
+
+    it('should calculate correct raster dimensions', async () => {
+      const image = await Image.load('test.png', 'image/png');
+      const raster = image.toRaster();
+
+      // Width should be rounded up to nearest 8-bit boundary
+      expect(raster.width).toBeGreaterThan(0);
+      expect(raster.height).toBe(image.size.height);
+    });
+
+    it('should generate correct raster data structure', async () => {
+      const image = await Image.load('test.png', 'image/png');
+      const raster = image.toRaster();
+
+      expect(raster.data.length).toBe(raster.width * raster.height);
+    });
+  });
+});
+

package/tests/unit/printer/buffer.test.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const Printer = require('../../../src/printer');
+
+describe('SpecBuffer', () => {
+  let printer;
+  let mockAdapter;
+
+  beforeEach(() => {
+    mockAdapter = {
+      write: jest.fn().mockResolvedValue(true)
+    };
+    printer = new Printer(mockAdapter);
+  });
+
+  describe('Buffer Operations', () => {
+    it('should initialize with empty buffer', () => {
+      const buffer = printer.buffer.flush();
+      expect(buffer.length).toBe(0);
+    });
+
+    it('should write data to buffer', () => {
+      printer.buffer.write('Hello', 'ascii');
+      const buffer = printer.buffer.flush();
+      expect(buffer.toString('ascii')).toBe('Hello');
+    });
+
+    it('should write hex data to buffer', () => {
+      printer.buffer.write('1B40', 'hex');
+      const buffer = printer.buffer.flush();
+      expect(buffer.toString('hex').toUpperCase()).toBe('1B40');
+    });
+
+    it('should concatenate multiple writes', () => {
+      printer.buffer.write('Hello', 'ascii');
+      printer.buffer.write(' World', 'ascii');
+      const buffer = printer.buffer.flush();
+      expect(buffer.toString('ascii')).toBe('Hello World');
+    });
+
+    it('should flush and clear buffer', () => {
+      printer.buffer.write('Test', 'ascii');
+      const buffer1 = printer.buffer.flush();
+      const buffer2 = printer.buffer.flush();
+      
+      expect(buffer1.toString('ascii')).toBe('Test');
+      expect(buffer2.length).toBe(0);
+    });
+
+    it('should handle Buffer objects', () => {
+      const testBuffer = Buffer.from('Test', 'ascii');
+      // SpecBuffer.write expects (data, type), but can handle Buffer directly
+      // We'll test through printer methods instead
+      printer.print('Test');
+      const buffer = printer.buffer.flush();
+      expect(buffer.toString('ascii')).toBe('Test');
+    });
+  });
+});
+

package/tests/unit/printer/commands.test.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const commands = require('../../../src/printer/commands');
+
+describe('Commands', () => {
+  describe('numToHexString', () => {
+    it('should convert number to hex string', () => {
+      const result = commands.numToHexString(255);
+      expect(result).toBe('ff');
+    });
+
+    it('should pad odd-length hex strings with leading zero', () => {
+      const result = commands.numToHexString(15);
+      expect(result).toBe('0f');
+    });
+
+    it('should handle zero', () => {
+      const result = commands.numToHexString(0);
+      expect(result).toBe('00');
+    });
+
+    it('should handle large numbers', () => {
+      const result = commands.numToHexString(256);
+      expect(result).toBe('0100');
+    });
+
+    it('should return empty string for NaN input', () => {
+      const result = commands.numToHexString('invalid');
+      expect(result).toBe('');
+    });
+
+    it('should return empty string for NaN value', () => {
+      const result = commands.numToHexString(NaN);
+      expect(result).toBe('');
+    });
+
+    it('should return empty string for undefined', () => {
+      const result = commands.numToHexString(undefined);
+      expect(result).toBe('');
+    });
+  });
+
+  describe('TXT_CUSTOM_SIZE', () => {
+    it('should clamp width to 8 when width > 8', () => {
+      const result = commands.TEXT_FORMAT.TXT_CUSTOM_SIZE(10, 2);
+      // When width is clamped to 8, the calculation is:
+      // widthDec = (8 - 1) * 16 = 112 (0x70)
+      // heightDec = (2 - 1) = 1 (0x01)
+      // sizeDec = 112 + 1 = 113 (0x71)
+      expect(result.toString('hex').toUpperCase()).toContain('1D2171');
+    });
+
+    it('should clamp width to 1 when width < 1', () => {
+      const result = commands.TEXT_FORMAT.TXT_CUSTOM_SIZE(0, 2);
+      // When width is clamped to 1, the calculation is:
+      // widthDec = (1 - 1) * 16 = 0 (0x00)
+      // heightDec = (2 - 1) = 1 (0x01)
+      // sizeDec = 0 + 1 = 1 (0x01)
+      expect(result.toString('hex').toUpperCase()).toContain('1D2101');
+    });
+
+    it('should clamp height to 8 when height > 8', () => {
+      const result = commands.TEXT_FORMAT.TXT_CUSTOM_SIZE(2, 10);
+      // When height is clamped to 8, the calculation is:
+      // widthDec = (2 - 1) * 16 = 16 (0x10)
+      // heightDec = (8 - 1) = 7 (0x07)
+      // sizeDec = 16 + 7 = 23 (0x17)
+      expect(result.toString('hex').toUpperCase()).toContain('1D2117');
+    });
+
+    it('should clamp height to 1 when height < 1', () => {
+      const result = commands.TEXT_FORMAT.TXT_CUSTOM_SIZE(2, 0);
+      // When height is clamped to 1, the calculation is:
+      // widthDec = (2 - 1) * 16 = 16 (0x10)
+      // heightDec = (1 - 1) = 0 (0x00)
+      // sizeDec = 16 + 0 = 16 (0x10)
+      expect(result.toString('hex').toUpperCase()).toContain('1D2110');
+    });
+
+    it('should clamp both width and height when both are out of range', () => {
+      const result = commands.TEXT_FORMAT.TXT_CUSTOM_SIZE(10, 0);
+      // When both are clamped: width=8, height=1
+      // widthDec = (8 - 1) * 16 = 112 (0x70)
+      // heightDec = (1 - 1) = 0 (0x00)
+      // sizeDec = 112 + 0 = 112 (0x70)
+      expect(result.toString('hex').toUpperCase()).toContain('1D2170');
+    });
+
+    it('should handle valid range values correctly', () => {
+      const result = commands.TEXT_FORMAT.TXT_CUSTOM_SIZE(4, 3);
+      // widthDec = (4 - 1) * 16 = 48 (0x30)
+      // heightDec = (3 - 1) = 2 (0x02)
+      // sizeDec = 48 + 2 = 50 (0x32)
+      expect(result.toString('hex').toUpperCase()).toContain('1D2132');
+    });
+
+    it('should handle boundary values (1 and 8)', () => {
+      const result1 = commands.TEXT_FORMAT.TXT_CUSTOM_SIZE(1, 1);
+      expect(result1.toString('hex').toUpperCase()).toContain('1D2100');
+
+      const result2 = commands.TEXT_FORMAT.TXT_CUSTOM_SIZE(8, 8);
+      // widthDec = (8 - 1) * 16 = 112 (0x70)
+      // heightDec = (8 - 1) = 7 (0x07)
+      // sizeDec = 112 + 7 = 119 (0x77)
+      expect(result2.toString('hex').toUpperCase()).toContain('1D2177');
+    });
+  });
+});
+