appium-ios-remotexpc 0.0.1

package/test/unit/plist/utils.spec.ts

@@ -0,0 +1,249 @@
+import { expect } from 'chai';
+
+import {
+  ensureString,
+  escapeXml,
+  findFirstReplacementCharacter,
+  fixMultipleXmlDeclarations,
+  hasUnicodeReplacementCharacter,
+  isValidXml,
+  isXmlPlistContent,
+  trimBeforeXmlDeclaration,
+} from '../../../src/lib/plist/utils.js';
+
+describe('Plist Utils', function () {
+  describe('ensureString', function () {
+    it('should return the input if it is already a string', function () {
+      const input = 'test string';
+      expect(ensureString(input)).to.equal(input);
+    });
+
+    it('should convert a Buffer to a string', function () {
+      const buffer = Buffer.from('test buffer');
+      expect(ensureString(buffer)).to.equal('test buffer');
+    });
+
+    it('should handle empty inputs', function () {
+      expect(ensureString('')).to.equal('');
+      expect(ensureString(Buffer.alloc(0))).to.equal('');
+    });
+
+    it('should handle Unicode characters', function () {
+      const unicodeStr = 'こんにちは世界';
+      const buffer = Buffer.from(unicodeStr, 'utf8');
+      expect(ensureString(buffer)).to.equal(unicodeStr);
+    });
+  });
+
+  describe('hasUnicodeReplacementCharacter', function () {
+    it('should return true if the string contains replacement characters', function () {
+      expect(hasUnicodeReplacementCharacter('test�string')).to.be.true;
+      expect(hasUnicodeReplacementCharacter('�at the beginning')).to.be.true;
+      expect(hasUnicodeReplacementCharacter('at the end�')).to.be.true;
+      expect(hasUnicodeReplacementCharacter('multiple��chars')).to.be.true;
+    });
+
+    it('should return false if the string does not contain replacement characters', function () {
+      expect(hasUnicodeReplacementCharacter('normal string')).to.be.false;
+      expect(hasUnicodeReplacementCharacter('')).to.be.false;
+    });
+
+    it('should work with Buffer inputs', function () {
+      const bufferWithReplacement = Buffer.from('test�string', 'utf8');
+      const bufferWithoutReplacement = Buffer.from('normal string', 'utf8');
+
+      expect(hasUnicodeReplacementCharacter(bufferWithReplacement)).to.be.true;
+      expect(hasUnicodeReplacementCharacter(bufferWithoutReplacement)).to.be
+        .false;
+    });
+  });
+
+  describe('findFirstReplacementCharacter', function () {
+    it('should return the index of the first replacement character', function () {
+      expect(findFirstReplacementCharacter('test�string')).to.equal(4);
+      expect(findFirstReplacementCharacter('�at the beginning')).to.equal(0);
+      expect(findFirstReplacementCharacter('multiple��chars')).to.equal(8);
+    });
+
+    it('should return -1 if no replacement character is found', function () {
+      expect(findFirstReplacementCharacter('normal string')).to.equal(-1);
+      expect(findFirstReplacementCharacter('')).to.equal(-1);
+    });
+
+    it('should work with Buffer inputs', function () {
+      const bufferWithReplacement = Buffer.from('test�string', 'utf8');
+      expect(findFirstReplacementCharacter(bufferWithReplacement)).to.equal(4);
+    });
+  });
+
+  describe('trimBeforeXmlDeclaration', function () {
+    it('should remove content before the XML declaration', function () {
+      const input = 'garbage data<?xml version="1.0"?><root></root>';
+      const expected = '<?xml version="1.0"?><root></root>';
+      expect(trimBeforeXmlDeclaration(input)).to.equal(expected);
+    });
+
+    it('should return the original string if there is no XML declaration', function () {
+      const input = '<root></root>';
+      expect(trimBeforeXmlDeclaration(input)).to.equal(input);
+    });
+
+    it('should return the original string if the XML declaration is at the beginning', function () {
+      const input = '<?xml version="1.0"?><root></root>';
+      expect(trimBeforeXmlDeclaration(input)).to.equal(input);
+    });
+
+    it('should work with Buffer inputs', function () {
+      const buffer = Buffer.from(
+        'garbage data<?xml version="1.0"?><root></root>',
+        'utf8',
+      );
+      const expected = '<?xml version="1.0"?><root></root>';
+      expect(trimBeforeXmlDeclaration(buffer)).to.equal(expected);
+    });
+
+    it('should handle whitespace before the XML declaration', function () {
+      const input = '  \n  <?xml version="1.0"?><root></root>';
+      const expected = '<?xml version="1.0"?><root></root>';
+      expect(trimBeforeXmlDeclaration(input)).to.equal(expected);
+    });
+  });
+
+  describe('fixMultipleXmlDeclarations', function () {
+    it('should remove additional XML declarations', function () {
+      const input = '<?xml version="1.0"?><root><?xml version="1.1"?></root>';
+      const expected = '<?xml version="1.0"?><root></root>';
+      expect(fixMultipleXmlDeclarations(input)).to.equal(expected);
+    });
+
+    it('should handle multiple additional declarations', function () {
+      const input =
+        '<?xml version="1.0"?><root><?xml version="1.1"?><?xml version="1.2"?></root>';
+      const expected = '<?xml version="1.0"?><root></root>';
+      expect(fixMultipleXmlDeclarations(input)).to.equal(expected);
+    });
+
+    it('should return the original string if there is only one XML declaration', function () {
+      const input = '<?xml version="1.0"?><root></root>';
+      expect(fixMultipleXmlDeclarations(input)).to.equal(input);
+    });
+
+    it('should return the original string if there is no XML declaration', function () {
+      const input = '<root></root>';
+      expect(fixMultipleXmlDeclarations(input)).to.equal(input);
+    });
+
+    it('should work with Buffer inputs', function () {
+      const buffer = Buffer.from(
+        '<?xml version="1.0"?><root><?xml version="1.1"?></root>',
+        'utf8',
+      );
+      const expected = '<?xml version="1.0"?><root></root>';
+      expect(fixMultipleXmlDeclarations(buffer)).to.equal(expected);
+    });
+  });
+
+  describe('isValidXml', function () {
+    it('should return true for valid XML', function () {
+      expect(isValidXml('<?xml version="1.0"?><root></root>')).to.be.true;
+      expect(isValidXml('<root></root>')).to.be.true;
+      expect(isValidXml('<root/>')).to.be.true;
+    });
+
+    it('should return false for invalid XML', function () {
+      expect(isValidXml('')).to.be.false;
+      expect(isValidXml('  ')).to.be.false;
+      expect(isValidXml('not xml')).to.be.false;
+    });
+
+    it('should work with Buffer inputs', function () {
+      const validBuffer = Buffer.from(
+        '<?xml version="1.0"?><root></root>',
+        'utf8',
+      );
+      const invalidBuffer = Buffer.from('not xml', 'utf8');
+
+      expect(isValidXml(validBuffer)).to.be.true;
+      expect(isValidXml(invalidBuffer)).to.be.false;
+    });
+
+    it('should handle XML with only a declaration', function () {
+      expect(isValidXml('<?xml version="1.0"?>')).to.be.true;
+    });
+  });
+
+  describe('escapeXml', function () {
+    it('should escape special XML characters', function () {
+      expect(escapeXml('<')).to.equal('&lt;');
+      expect(escapeXml('>')).to.equal('&gt;');
+      expect(escapeXml('&')).to.equal('&amp;');
+      expect(escapeXml('"')).to.equal('&quot;');
+      expect(escapeXml("'")).to.equal('&apos;');
+    });
+
+    it('should escape multiple special characters in a string', function () {
+      expect(escapeXml('<tag attr="value" & more=\'stuff\'>')).to.equal(
+        '&lt;tag attr=&quot;value&quot; &amp; more=&apos;stuff&apos;&gt;',
+      );
+    });
+
+    it('should not modify regular characters', function () {
+      expect(escapeXml('normal text')).to.equal('normal text');
+      expect(escapeXml('123')).to.equal('123');
+    });
+
+    it('should handle empty strings', function () {
+      expect(escapeXml('')).to.equal('');
+    });
+  });
+
+  describe('isXmlPlistContent', function () {
+    it('should return true for content with XML declaration', function () {
+      expect(isXmlPlistContent('<?xml version="1.0"?><root></root>')).to.be
+        .true;
+    });
+
+    it('should return true for content with plist tag', function () {
+      expect(isXmlPlistContent('<plist><dict></dict></plist>')).to.be.true;
+    });
+
+    it('should return false for content without XML declaration or plist tag', function () {
+      expect(isXmlPlistContent('<root></root>')).to.be.false;
+      expect(isXmlPlistContent('not xml')).to.be.false;
+    });
+
+    it('should work with Buffer inputs', function () {
+      const xmlBuffer = Buffer.from(
+        '<?xml version="1.0"?><root></root>',
+        'utf8',
+      );
+      const plistBuffer = Buffer.from('<plist><dict></dict></plist>', 'utf8');
+      const nonXmlBuffer = Buffer.from('not xml', 'utf8');
+
+      expect(isXmlPlistContent(xmlBuffer)).to.be.true;
+      expect(isXmlPlistContent(plistBuffer)).to.be.true;
+      expect(isXmlPlistContent(nonXmlBuffer)).to.be.false;
+    });
+  });
+
+  describe('Integration Tests', function () {
+    it('should clean and fix XML with multiple issues', function () {
+      // XML with multiple issues: content before declaration, multiple declarations, and replacement character
+      const problematicXml =
+        'garbage data<?xml version="1.0"?><?xml version="1.1"?><plist><dict><key>test</key><string>val�ue</string></dict></plist>';
+
+      // Apply the cleaning functions in sequence
+      let cleanedXml = trimBeforeXmlDeclaration(problematicXml);
+      cleanedXml = fixMultipleXmlDeclarations(cleanedXml);
+
+      // Verify the result
+      expect(cleanedXml).to.include('<?xml version="1.0"?>');
+      expect(cleanedXml).not.to.include('garbage data');
+      expect(cleanedXml).not.to.include('<?xml version="1.1"?>');
+      expect(cleanedXml).to.include('<plist>');
+
+      // Verify that the replacement character is still there (it's handled by the parser, not these utils)
+      expect(hasUnicodeReplacementCharacter(cleanedXml)).to.be.true;
+    });
+  });
+});

package/test/unit/plist/xml-cleaning.spec.ts

@@ -0,0 +1,60 @@
+import { expect } from 'chai';
+
+import { parsePlist as parseXmlPlist } from '../../../src/lib/plist/plist-parser.js';
+import type { PlistDictionary } from '../../../src/lib/types.js';
+
+describe('XML Cleaning Logic', function () {
+  describe('Handling Unicode Replacement Characters', function () {
+    it('should handle replacement characters at different positions', function () {
+      const xmlAtBeginning =
+        '�<?xml version="1.0" encoding="UTF-8"?><plist><dict><key>test</key><string>value</string></dict></plist>';
+      const resultBeginning = parseXmlPlist(xmlAtBeginning) as PlistDictionary;
+      expect(resultBeginning).to.have.property('test', 'value');
+
+      const xmlAfterDeclaration =
+        '<?xml version="1.0" encoding="UTF-8"?>�<plist><dict><key>test</key><string>value</string></dict></plist>';
+      const resultAfterDeclaration = parseXmlPlist(
+        xmlAfterDeclaration,
+      ) as PlistDictionary;
+      expect(resultAfterDeclaration).to.have.property('test', 'value');
+
+      const xmlAtEnd =
+        '<?xml version="1.0" encoding="UTF-8"?><plist><dict><key>test</key><string>value</string></dict></plist>�';
+      const resultAtEnd = parseXmlPlist(xmlAtEnd) as PlistDictionary;
+      expect(resultAtEnd).to.have.property('test', 'value');
+    });
+  });
+
+  describe('Edge Cases', function () {
+    it('should handle the case where prevTagPos < 0', function () {
+      const xml =
+        '�<plist><dict><key>test</key><string>value</string></dict></plist>';
+
+      const result = parseXmlPlist(xml) as PlistDictionary;
+
+      expect(result).to.have.property('test', 'value');
+    });
+
+    it('should handle the case where nextTagPos <= prevTagPos', function () {
+      const xml =
+        '<?xml version="1.0" encoding="UTF-8"?><plist><dict><key>test</key><string>value</string></dict></plist>�';
+
+      const result = parseXmlPlist(xml) as PlistDictionary;
+
+      expect(result).to.have.property('test', 'value');
+    });
+
+    it('should handle XML with only replacement characters', function () {
+      const xml = '���';
+
+      try {
+        parseXmlPlist(xml);
+        expect.fail(
+          'Should have thrown an error for XML with only replacement characters',
+        );
+      } catch (error) {
+        expect(error).to.exist;
+      }
+    });
+  });
+});

package/test/unit/tunnel/tunnel-registry-server.spec.ts

@@ -0,0 +1,194 @@
+import { expect } from 'chai';
+
+import {
+  TunnelRegistryServer,
+  startTunnelRegistryServer,
+} from '../../../src/lib/tunnel/tunnel-registry-server.js';
+import type {
+  TunnelRegistry,
+  TunnelRegistryEntry,
+} from '../../../src/lib/types.js';
+
+describe('TunnelRegistryServer', function () {
+  let server: TunnelRegistryServer;
+  const testPort = 4724;
+
+  // Test data
+  const testRegistry = {
+    tunnels: {
+      'test-udid-123': {
+        udid: 'test-udid-123',
+        deviceId: 1,
+        address: '127.0.0.1',
+        packetStreamPort: 12345,
+        rsdPort: 58783,
+        connectionType: 'USB',
+        productId: 12345,
+        createdAt: Date.now(),
+        lastUpdated: Date.now(),
+      },
+    },
+    metadata: {
+      lastUpdated: new Date().toISOString(),
+      totalTunnels: 1,
+      activeTunnels: 1,
+    },
+  };
+
+  beforeEach(async function () {
+    server = await startTunnelRegistryServer(testRegistry, testPort);
+  });
+
+  afterEach(async function () {
+    if (server) {
+      await server.stop();
+    }
+  });
+
+  describe('GET /remotexpc/tunnels', function () {
+    it('should return all tunnels', async function () {
+      const response = await fetch(
+        `http://localhost:${testPort}/remotexpc/tunnels`,
+      );
+      const data = (await response.json()) as TunnelRegistry;
+
+      expect(response.status).to.equal(200);
+      expect(data).to.have.property('tunnels');
+      expect(data).to.have.property('metadata');
+      expect(data.tunnels).to.have.property('test-udid-123');
+    });
+  });
+
+  describe('GET /remotexpc/tunnels/:udid', function () {
+    it('should return tunnel by UDID', async function () {
+      const response = await fetch(
+        `http://localhost:${testPort}/remotexpc/tunnels/test-udid-123`,
+      );
+      const data = (await response.json()) as TunnelRegistryEntry;
+
+      expect(response.status).to.equal(200);
+      expect(data.udid).to.equal('test-udid-123');
+      expect(data.deviceId).to.equal(1);
+    });
+
+    it('should return 404 for non-existent UDID', async function () {
+      const response = await fetch(
+        `http://localhost:${testPort}/remotexpc/tunnels/non-existent`,
+      );
+      const data = (await response.json()) as { error: string };
+
+      expect(response.status).to.equal(404);
+      expect(data).to.have.property('error');
+      expect(data.error).to.include('Tunnel not found');
+    });
+  });
+
+  describe('GET /remotexpc/tunnels/device/:deviceId', function () {
+    it('should return tunnel by device ID', async function () {
+      const response = await fetch(
+        `http://localhost:${testPort}/remotexpc/tunnels/device/1`,
+      );
+      const data = (await response.json()) as TunnelRegistryEntry;
+
+      expect(response.status).to.equal(200);
+      expect(data.udid).to.equal('test-udid-123');
+      expect(data.deviceId).to.equal(1);
+    });
+
+    it('should return 404 for non-existent device ID', async function () {
+      const response = await fetch(
+        `http://localhost:${testPort}/remotexpc/tunnels/device/999`,
+      );
+      const data = (await response.json()) as { error: string };
+
+      expect(response.status).to.equal(404);
+      expect(data).to.have.property('error');
+      expect(data.error).to.include('Tunnel not found');
+    });
+
+    it('should return 400 for invalid device ID', async function () {
+      const response = await fetch(
+        `http://localhost:${testPort}/remotexpc/tunnels/device/invalid`,
+      );
+      const data = (await response.json()) as { error: string };
+
+      expect(response.status).to.equal(400);
+      expect(data).to.have.property('error');
+      expect(data.error).to.equal('Invalid device ID');
+    });
+  });
+
+  describe('PUT /remotexpc/tunnels/:udid', function () {
+    it('should update tunnel', async function () {
+      const updateData = {
+        ...testRegistry.tunnels['test-udid-123'],
+        rsdPort: 58784,
+      };
+
+      const response = await fetch(
+        `http://localhost:${testPort}/remotexpc/tunnels/test-udid-123`,
+        {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(updateData),
+        },
+      );
+      const data = (await response.json()) as {
+        success: boolean;
+        tunnel: TunnelRegistryEntry;
+      };
+
+      expect(response.status).to.equal(200);
+      expect(data).to.have.property('success', true);
+      expect(data.tunnel.rsdPort).to.equal(58784);
+    });
+
+    it('should return 400 for UDID mismatch', async function () {
+      const updateData = {
+        ...testRegistry.tunnels['test-udid-123'],
+        udid: 'different-udid',
+      };
+
+      const response = await fetch(
+        `http://localhost:${testPort}/remotexpc/tunnels/test-udid-123`,
+        {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(updateData),
+        },
+      );
+      const data = (await response.json()) as { error: string };
+
+      expect(response.status).to.equal(400);
+      expect(data).to.have.property('error');
+      expect(data.error).to.include('UDID mismatch');
+    });
+
+    it('should return 400 for invalid JSON', async function () {
+      const response = await fetch(
+        `http://localhost:${testPort}/remotexpc/tunnels/test-udid-123`,
+        {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: 'invalid json',
+        },
+      );
+      const data = (await response.json()) as { error: string };
+
+      expect(response.status).to.equal(400);
+      expect(data).to.have.property('error');
+    });
+  });
+
+  describe('Unknown routes', function () {
+    it('should return 404 for unknown routes', async function () {
+      const response = await fetch(
+        `http://localhost:${testPort}/unknown/route`,
+      );
+      const data = (await response.json()) as { error: string };
+
+      expect(response.status).to.equal(404);
+      expect(data).to.have.property('error', 'Not found');
+    });
+  });
+});

package/test/unit/usbmux/usbmux-specs.ts

@@ -0,0 +1,71 @@
+import type { expect as expectType } from 'chai';
+import { Server, Socket } from 'node:net';
+
+import { Usbmux } from '../../../src/lib/usbmux/index.js';
+import { UDID, fixtures, getServerWithFixtures } from '../fixtures/index.js';
+
+let chai;
+let chaiAsPromised;
+let expect: typeof expectType;
+
+before(async function () {
+  chai = await import('chai');
+  chaiAsPromised = await import('chai-as-promised');
+  chai.use(chaiAsPromised.default);
+  chai.should();
+  expect = chai.expect;
+});
+
+describe('usbmux', function () {
+  let usbmux: Usbmux | null;
+  let server: Server | null;
+  let socket: Socket | null;
+
+  beforeEach(function () {
+    usbmux = null;
+    server = null;
+    socket = null;
+  });
+
+  afterEach(async function () {
+    if (usbmux) {
+      usbmux.close();
+      usbmux = null;
+    }
+
+    // Add a small delay to avoid connection reset errors
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    if (server) {
+      server.close();
+      server = null;
+    }
+
+    socket = null;
+  });
+
+  it('should read usbmux message', async function () {
+    ({ server, socket } = await getServerWithFixtures(fixtures.DEVICE_LIST));
+    usbmux = new Usbmux(socket);
+    const devices = await usbmux.listDevices();
+    expect(devices.length).to.equal(1);
+  });
+
+  it('should fail due to timeout', async function () {
+    ({ server, socket } = await getServerWithFixtures());
+    usbmux = new Usbmux(socket);
+
+    await expect(usbmux.listDevices(-1)).to.be.rejected;
+  });
+
+  it('should find correct device', async function () {
+    ({ server, socket } = await getServerWithFixtures(fixtures.DEVICE_LIST));
+    usbmux = new Usbmux(socket);
+
+    const device = await usbmux.findDevice(UDID);
+    expect(device).to.not.be.undefined;
+    if (device) {
+      expect(device.Properties.SerialNumber).to.equal(UDID);
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "target": "es2022",
+    "preserveSymlinks": true,
+    "rootDir": "./",
+
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+
+    "outDir": "./build",
+    "declaration": true,
+    "declarationMap": true,
+    "removeComments": false,
+    "lib": ["es2023"],
+    "types": ["node", "mocha", "chai"],
+
+    "allowSyntheticDefaultImports": true,
+    "noImplicitAny": true,
+    "noImplicitThis": false,
+    "noUnusedParameters": false,
+    "verbatimModuleSyntax": true,
+  },
+
+  "include": [
+    "./src/**/*.ts",
+    "./test/**/*.ts"
+  ],
+
+  "exclude": [
+    "node_modules",
+  ]
+}