@mtcute/test 0.17.0 → 0.18.0

package/package.json

@@ -1,11 +1,21 @@
 {
     "name": "@mtcute/test",
     "type": "module",
-    "version": "0.17.0",
+    "version": "0.18.0",
     "description": "Test utilities for mtcute",
-    "author": "alina sireneva <alina@tei.su>",
     "license": "MIT",
-    "sideEffects": false,
+    "dependencies": {
+        "long": "5.2.3",
+        "@fuman/utils": "0.0.4",
+        "@fuman/net": "0.0.4"
+    },
+    "peerDependencies": {
+        "@mtcute/core": "^0.18.0",
+        "@mtcute/node": "^0.18.0",
+        "@mtcute/tl": "195.0.0",
+        "@mtcute/web": "^0.18.0",
+        "vitest": "*"
+    },
     "exports": {
         ".": {
             "import": {
@@ -18,14 +28,8 @@
             }
         }
     },
-    "scripts": {},
-    "peerDependencies": {
-        "@mtcute/core": "^0.17.0",
-        "@mtcute/node": "^0.17.0",
-        "@mtcute/tl": "*",
-        "@mtcute/web": "^0.17.0",
-        "vitest": "*"
-    },
+    "author": "alina sireneva <alina@tei.su>",
+    "sideEffects": false,
     "peerDependenciesMeta": {
         "@mtcute/node": {
             "optional": true
@@ -34,15 +38,13 @@
             "optional": true
         }
     },
-    "dependencies": {
-        "long": "5.2.3"
-    },
     "browser": {
-        "./esm/platform.js": "./esm/platform.web.js"
+        "./src/platform.js": "./src/platform.web.js"
     },
     "homepage": "https://mtcute.dev",
     "repository": {
         "type": "git",
-        "url": "https://github.com/mtcute/mtcute"
-    }
+        "url": "git+https://github.com/mtcute/mtcute.git"
+    },
+    "scripts": {}
 }

package/platform.web.js

@@ -0,0 +1,7 @@
+import { WebPlatform, WebCryptoProvider } from "@mtcute/web";
+const defaultPlatform = new WebPlatform();
+const defaultCryptoProvider = new WebCryptoProvider();
+export {
+  defaultCryptoProvider,
+  defaultPlatform
+};

package/schema.js

@@ -0,0 +1,29 @@
+import * as schema_ from "@mtcute/tl/api-schema.json";
+const schema = "default" in schema_ ? schema_.default : schema_;
+let _cachedEntriesMap = null;
+let _cachedUnionsMap = null;
+function getEntriesMap() {
+  if (_cachedEntriesMap) {
+    return {
+      entries: _cachedEntriesMap,
+      unions: _cachedUnionsMap
+    };
+  }
+  _cachedEntriesMap = /* @__PURE__ */ new Map();
+  _cachedUnionsMap = /* @__PURE__ */ new Map();
+  let entry;
+  for (entry of schema.e) {
+    _cachedEntriesMap.set(entry.name, entry);
+    if (!_cachedUnionsMap.has(entry.type)) {
+      _cachedUnionsMap.set(entry.type, []);
+    }
+    _cachedUnionsMap.get(entry.type).push(entry);
+  }
+  return {
+    entries: _cachedEntriesMap,
+    unions: _cachedUnionsMap
+  };
+}
+export {
+  getEntriesMap
+};

package/storage/auth-keys.js

@@ -0,0 +1,91 @@
+import { vi, describe, afterEach, it, expect } from "vitest";
+function fakeAuthKeysRepository() {
+  return {
+    get: vi.fn(),
+    set: vi.fn(),
+    getTemp: vi.fn(),
+    setTemp: vi.fn(),
+    deleteByDc: vi.fn(),
+    deleteAll: vi.fn()
+  };
+}
+function fixBuffer(buf) {
+  if (!buf) return buf;
+  return typeof Buffer !== "undefined" && buf instanceof Buffer ? new Uint8Array(buf) : buf;
+}
+function testAuthKeysRepository(repo) {
+  const key2 = new Uint8Array(256).fill(66);
+  const key3 = new Uint8Array(256).fill(67);
+  const key2i0 = new Uint8Array(256).fill(68);
+  const key2i1 = new Uint8Array(256).fill(69);
+  const key3i0 = new Uint8Array(256).fill(70);
+  const key3i1 = new Uint8Array(256).fill(71);
+  describe("auth keys", () => {
+    afterEach(() => repo.deleteAll());
+    it("should be empty by default", async () => {
+      expect(fixBuffer(await repo.get(2))).toEqual(null);
+      expect(fixBuffer(await repo.get(3))).toEqual(null);
+    });
+    it("should store and retrieve auth keys", async () => {
+      await repo.set(2, key2);
+      await repo.set(3, key3);
+      expect(fixBuffer(await repo.get(2))).toEqual(key2);
+      expect(fixBuffer(await repo.get(3))).toEqual(key3);
+    });
+    it("should delete auth keys", async () => {
+      await repo.set(2, key2);
+      await repo.set(3, key3);
+      await repo.set(2, null);
+      await repo.set(3, null);
+      expect(fixBuffer(await repo.get(2))).toEqual(null);
+      expect(fixBuffer(await repo.get(3))).toEqual(null);
+    });
+    it("should store and retrieve temp auth keys", async () => {
+      await repo.setTemp(2, 0, key2i0, 1);
+      await repo.setTemp(2, 1, key2i1, 1);
+      await repo.setTemp(3, 0, key3i0, 1);
+      await repo.setTemp(3, 1, key3i1, 1);
+      expect(fixBuffer(await repo.getTemp(2, 0, 0))).toEqual(key2i0);
+      expect(fixBuffer(await repo.getTemp(2, 1, 0))).toEqual(key2i1);
+      expect(fixBuffer(await repo.getTemp(3, 0, 0))).toEqual(key3i0);
+      expect(fixBuffer(await repo.getTemp(3, 1, 0))).toEqual(key3i1);
+      expect(fixBuffer(await repo.getTemp(2, 0, 100))).toEqual(null);
+      expect(fixBuffer(await repo.getTemp(2, 1, 100))).toEqual(null);
+      expect(fixBuffer(await repo.getTemp(3, 0, 100))).toEqual(null);
+      expect(fixBuffer(await repo.getTemp(3, 1, 100))).toEqual(null);
+    });
+    it("should delete temp auth keys", async () => {
+      await repo.setTemp(2, 0, key2i0, 1);
+      await repo.setTemp(2, 1, key2i1, 1);
+      await repo.setTemp(3, 0, key3i0, 1);
+      await repo.setTemp(3, 1, key3i1, 1);
+      await repo.setTemp(2, 0, null, 1);
+      await repo.setTemp(2, 1, null, 1);
+      await repo.setTemp(3, 0, null, 1);
+      await repo.setTemp(3, 1, null, 1);
+      expect(fixBuffer(await repo.getTemp(2, 0, 0))).toEqual(null);
+      expect(fixBuffer(await repo.getTemp(2, 1, 0))).toEqual(null);
+      expect(fixBuffer(await repo.getTemp(3, 0, 0))).toEqual(null);
+      expect(fixBuffer(await repo.getTemp(3, 1, 0))).toEqual(null);
+    });
+    it("should delete all auth keys by DC", async () => {
+      await repo.set(2, key2);
+      await repo.set(3, key3);
+      await repo.setTemp(2, 0, key2i0, 1);
+      await repo.setTemp(2, 1, key2i1, 1);
+      await repo.setTemp(3, 0, key3i0, 1);
+      await repo.setTemp(3, 1, key3i1, 1);
+      await repo.deleteByDc(2);
+      expect(fixBuffer(await repo.get(2))).toEqual(null);
+      expect(fixBuffer(await repo.get(3))).toEqual(key3);
+      expect(fixBuffer(await repo.getTemp(2, 0, 0))).toEqual(null);
+      expect(fixBuffer(await repo.getTemp(2, 1, 0))).toEqual(null);
+      expect(fixBuffer(await repo.getTemp(3, 0, 0))).toEqual(key3i0);
+      expect(fixBuffer(await repo.getTemp(3, 1, 0))).toEqual(key3i1);
+    });
+  });
+}
+export {
+  fakeAuthKeysRepository,
+  testAuthKeysRepository
+};

package/storage/key-value.js

@@ -0,0 +1,37 @@
+import { vi, describe, afterEach, it, expect } from "vitest";
+function fakeKeyValueRepository() {
+  return {
+    get: vi.fn(),
+    set: vi.fn(),
+    delete: vi.fn(),
+    deleteAll: vi.fn()
+  };
+}
+function fixBuffer(buf) {
+  if (!buf) return buf;
+  return typeof Buffer !== "undefined" && buf instanceof Buffer ? new Uint8Array(buf) : buf;
+}
+function testKeyValueRepository(repo, driver) {
+  describe("key-value", () => {
+    afterEach(() => repo.deleteAll());
+    it("should be empty by default", async () => {
+      expect(fixBuffer(await repo.get("key"))).toEqual(null);
+    });
+    it("should store and retrieve values", async () => {
+      await repo.set("key", new Uint8Array([1, 2, 3]));
+      await driver.save?.();
+      expect(fixBuffer(await repo.get("key"))).toEqual(new Uint8Array([1, 2, 3]));
+    });
+    it("should delete values", async () => {
+      await repo.set("key", new Uint8Array([1, 2, 3]));
+      await driver.save?.();
+      await repo.delete("key");
+      await driver.save?.();
+      expect(fixBuffer(await repo.get("key"))).toEqual(null);
+    });
+  });
+}
+export {
+  fakeKeyValueRepository,
+  testKeyValueRepository
+};

package/storage/peers.js

@@ -0,0 +1,83 @@
+import { TlBinaryWriter } from "@mtcute/core/utils.js";
+import { __tlWriterMap } from "@mtcute/tl/binary/writer.js";
+import { vi, describe, it, expect } from "vitest";
+import { createStub } from "../stub.js";
+function fakePeersRepository() {
+  return {
+    getById: vi.fn(),
+    getByUsername: vi.fn(),
+    getByPhone: vi.fn(),
+    store: vi.fn(),
+    deleteAll: vi.fn()
+  };
+}
+function fixPeerInfo(peer) {
+  if (!peer) return peer;
+  return {
+    ...peer,
+    complete: (
+      // eslint-disable-next-line no-restricted-globals
+      typeof Buffer !== "undefined" && peer.complete instanceof Buffer ? new Uint8Array(peer.complete) : peer.complete
+    )
+  };
+}
+function testPeersRepository(repo, driver) {
+  const stubPeerUser = {
+    id: 123123,
+    accessHash: "123|456",
+    isMin: false,
+    usernames: ["some_user"],
+    phone: "78005553535",
+    updated: 666,
+    complete: TlBinaryWriter.serializeObject(__tlWriterMap, createStub("user", { id: 123123 }))
+  };
+  const stubPeerChannel = {
+    id: -1001183945448,
+    accessHash: "666|555",
+    isMin: false,
+    usernames: ["some_channel"],
+    updated: 777,
+    complete: TlBinaryWriter.serializeObject(__tlWriterMap, createStub("channel", { id: 123123 }))
+  };
+  const stupPeerMinUser = { ...stubPeerUser, isMin: true };
+  describe("peers", () => {
+    it("should be empty by default", async () => {
+      expect(await repo.getById(123123, false)).toEqual(null);
+      expect(await repo.getByUsername("some_user")).toEqual(null);
+      expect(await repo.getByPhone("phone")).toEqual(null);
+    });
+    it("should store and retrieve peers", async () => {
+      await repo.store(stubPeerUser);
+      await repo.store(stubPeerChannel);
+      await driver.save?.();
+      expect(fixPeerInfo(await repo.getById(123123, false))).toEqual(stubPeerUser);
+      expect(fixPeerInfo(await repo.getByUsername("some_user"))).toEqual(stubPeerUser);
+      expect(fixPeerInfo(await repo.getByPhone("78005553535"))).toEqual(stubPeerUser);
+      expect(fixPeerInfo(await repo.getById(-1001183945448, false))).toEqual(stubPeerChannel);
+      expect(fixPeerInfo(await repo.getByUsername("some_channel"))).toEqual(stubPeerChannel);
+    });
+    it("should update peers usernames", async () => {
+      await repo.store(stubPeerUser);
+      await driver.save?.();
+      const modUser = { ...stubPeerUser, usernames: ["some_user2"] };
+      await repo.store(modUser);
+      await driver.save?.();
+      expect(fixPeerInfo(await repo.getById(123123, false))).toEqual(modUser);
+      expect(await repo.getByUsername("some_user")).toEqual(null);
+      expect(fixPeerInfo(await repo.getByUsername("some_user2"))).toEqual(modUser);
+    });
+    it("should not return min peers by default", async () => {
+      await repo.deleteAll();
+      await repo.store(stupPeerMinUser);
+      await driver.save?.();
+      expect(await repo.getById(123123, false)).toEqual(null);
+      expect(await repo.getByUsername("some_user")).toEqual(null);
+      expect(await repo.getByPhone("78005553535")).toEqual(null);
+      expect(fixPeerInfo(await repo.getById(123123, true))).toEqual(stupPeerMinUser);
+    });
+  });
+}
+export {
+  fakePeersRepository,
+  testPeersRepository
+};

package/storage/ref-messages.js

@@ -0,0 +1,67 @@
+import { vi, describe, afterEach, it, expect } from "vitest";
+function fakeRefMessagesRepository() {
+  return {
+    store: vi.fn(),
+    getByPeer: vi.fn(),
+    delete: vi.fn(),
+    deleteByPeer: vi.fn(),
+    deleteAll: vi.fn()
+  };
+}
+function testRefMessagesRepository(repo, driver) {
+  describe("IReferenceMessagesRepository", () => {
+    afterEach(() => repo.deleteAll());
+    it("should be empty by default", async () => {
+      expect(await repo.getByPeer(1)).toEqual(null);
+    });
+    it("should store and retrieve reference messages", async () => {
+      await repo.store(1, 2, 3);
+      await repo.store(1, 4, 5);
+      await repo.store(2, 6, 7);
+      await driver.save?.();
+      expect(await repo.getByPeer(1)).deep.oneOf([
+        [2, 3],
+        [4, 5]
+      ]);
+      expect(await repo.getByPeer(2)).toEqual([6, 7]);
+      expect(await repo.getByPeer(3)).toEqual(null);
+      expect(await repo.getByPeer(4)).toEqual(null);
+      expect(await repo.getByPeer(5)).toEqual(null);
+      expect(await repo.getByPeer(6)).toEqual(null);
+      expect(await repo.getByPeer(7)).toEqual(null);
+    });
+    it("should delete reference messages", async () => {
+      await repo.store(1, 2, 3);
+      await repo.store(1, 4, 5);
+      await repo.store(2, 6, 7);
+      await driver.save?.();
+      await repo.delete(4, [5]);
+      await driver.save?.();
+      expect(await repo.getByPeer(1)).toEqual([2, 3]);
+      await repo.delete(2, [2, 3, 4]);
+      await driver.save?.();
+      expect(await repo.getByPeer(1)).toEqual(null);
+    });
+    it("should delete all reference messages for a peer", async () => {
+      await repo.store(1, 2, 3);
+      await repo.store(1, 4, 5);
+      await repo.store(1, 6, 7);
+      await repo.store(2, 20, 30);
+      await repo.store(2, 40, 50);
+      await repo.store(2, 60, 70);
+      await driver.save?.();
+      await repo.deleteByPeer(1);
+      await driver.save?.();
+      expect(await repo.getByPeer(1)).toEqual(null);
+      expect(await repo.getByPeer(2)).deep.oneOf([
+        [20, 30],
+        [40, 50],
+        [60, 70]
+      ]);
+    });
+  });
+}
+export {
+  fakeRefMessagesRepository,
+  testRefMessagesRepository
+};

package/storage.d.ts

@@ -1,5 +1,5 @@
-import { MemoryStorage } from '@mtcute/core';
 import { ICryptoProvider } from '@mtcute/core/utils.js';
+import { MemoryStorage } from '@mtcute/core';
 export declare class StubMemoryTelegramStorage extends MemoryStorage {
     readonly params: {
         /**

package/storage.js

@@ -0,0 +1,45 @@
+import { MemoryStorage, MtArgumentError } from "@mtcute/core";
+import { createAesIgeForMessage } from "@mtcute/core/utils.js";
+class StubMemoryTelegramStorage extends MemoryStorage {
+  constructor(params = {
+    hasKeys: true,
+    hasTempKeys: true
+  }) {
+    super();
+    this.params = params;
+    const _origGet = this.authKeys.get;
+    this.authKeys.get = (dcId) => {
+      if (this.params.hasKeys) {
+        if (this.params.hasKeys === true || this.params.hasKeys.includes(dcId)) {
+          return new Uint8Array(256);
+        }
+      }
+      return _origGet.call(this.authKeys, dcId);
+    };
+    const _origGetTemp = this.authKeys.getTemp;
+    this.authKeys.getTemp = (dcId, idx, now) => {
+      if (this.params.hasTempKeys) {
+        if (this.params.hasTempKeys === true || this.params.hasTempKeys.includes(dcId)) {
+          return new Uint8Array(256);
+        }
+      }
+      return _origGetTemp.call(this.authKeys, dcId, idx, now);
+    };
+  }
+  decryptOutgoingMessage(crypto, data, dcId, tempIndex) {
+    const key = tempIndex ? this.authKeys.getTemp(dcId, tempIndex, Date.now()) : this.authKeys.get(dcId);
+    if (!key) {
+      throw new MtArgumentError(`No auth key for DC ${dcId}`);
+    }
+    const messageKey = data.subarray(8, 24);
+    const encryptedData = data.subarray(24);
+    const ige = createAesIgeForMessage(crypto, key, messageKey, true);
+    const innerData = ige.decrypt(encryptedData);
+    const dv = new DataView(innerData.buffer, innerData.byteOffset, innerData.byteLength);
+    const length = dv.getUint32(28, true);
+    return innerData.subarray(32, 32 + length);
+  }
+}
+export {
+  StubMemoryTelegramStorage
+};

package/stub.js

@@ -0,0 +1,60 @@
+import { u8 } from "@fuman/utils";
+import Long from "long";
+import { getEntriesMap } from "./schema.js";
+function getDefaultFor(arg) {
+  if (arg.typeModifiers?.isVector || arg.typeModifiers?.isBareVector) {
+    return [];
+  }
+  if (arg.typeModifiers?.predicate) {
+    return arg.type === "true" ? false : void 0;
+  }
+  switch (arg.type) {
+    case "int":
+    case "int53":
+    case "double":
+      return 0;
+    case "long":
+      return Long.ZERO;
+    case "int128":
+      return u8.alloc(16);
+    case "int256":
+      return u8.alloc(32);
+    case "string":
+      return "";
+    case "bytes":
+      return u8.alloc(0);
+    case "Bool":
+    case "bool":
+      return false;
+    default: {
+      const union = getEntriesMap().unions.get(arg.type);
+      if (!union) throw new Error(`Unknown type ${arg.type}`);
+      return createStub(union[0].name);
+    }
+  }
+}
+function snakeToCamel(s) {
+  return s.replace(/(?<!^|_)_[a-z0-9]/gi, ($1) => {
+    return $1.substring(1).toUpperCase();
+  });
+}
+function createStub(name, partial = {}) {
+  const { entries } = getEntriesMap();
+  const entry = entries.get(name);
+  if (!entry) throw new Error(`Entry ${name} is unknown`);
+  const ret = {
+    _: name
+  };
+  for (const arg of entry.arguments) {
+    if (arg.type === "#") continue;
+    if (arg.name in partial) continue;
+    ret[snakeToCamel(arg.name)] = getDefaultFor(arg);
+  }
+  for (const key in partial) {
+    ret[key] = partial[key];
+  }
+  return ret;
+}
+export {
+  createStub
+};

package/transport.d.ts

@@ -1,29 +1,19 @@
-import { default as EventEmitter } from 'events';
-import { ITelegramTransport, TransportState } from '@mtcute/core';
-import { ICryptoProvider, Logger } from '@mtcute/core/utils.js';
-import { tl } from '@mtcute/tl';
-export declare class StubTelegramTransport extends EventEmitter implements ITelegramTransport {
+import { BasicDcOption } from '@mtcute/core/utils.js';
+import { IPacketCodec, ITelegramConnection, TelegramTransport } from '@mtcute/core';
+export declare class StubTelegramTransport implements TelegramTransport {
     readonly params: {
-        getMtproxyInfo?: () => tl.RawInputClientProxy;
-        onConnect?: (dc: tl.RawDcOption, testMode: boolean) => void;
+        packetCodec?: () => IPacketCodec;
+        onConnect?: (dc: BasicDcOption) => void;
         onClose?: () => void;
-        onMessage?: (msg: Uint8Array) => void;
+        onMessage?: (msg: Uint8Array, dcId: number) => void;
     };
     constructor(params: {
-        getMtproxyInfo?: () => tl.RawInputClientProxy;
-        onConnect?: (dc: tl.RawDcOption, testMode: boolean) => void;
+        packetCodec?: () => IPacketCodec;
+        onConnect?: (dc: BasicDcOption) => void;
         onClose?: () => void;
-        onMessage?: (msg: Uint8Array) => void;
+        onMessage?: (msg: Uint8Array, dcId: number) => void;
     });
-    _state: TransportState;
-    _currentDc: tl.RawDcOption | null;
-    _crypto: ICryptoProvider;
-    _log: Logger;
-    write(data: Uint8Array): void;
-    setup(crypto: ICryptoProvider, log: Logger): void;
-    state(): TransportState;
-    currentDc(): tl.RawDcOption | null;
-    connect(dc: tl.RawDcOption, testMode: boolean): void;
-    close(): void;
-    send(data: Uint8Array): Promise<void>;
+    private _dcId;
+    connect(dc: BasicDcOption): Promise<ITelegramConnection>;
+    packetCodec(): IPacketCodec;
 }

package/transport.js

@@ -0,0 +1,28 @@
+import { FakeConnection } from "@fuman/net";
+import { IntermediatePacketCodec } from "@mtcute/core";
+class StubTelegramTransport {
+  constructor(params) {
+    this.params = params;
+  }
+  _dcId = 0;
+  async connect(dc) {
+    this.params.onConnect?.(dc);
+    this._dcId = dc.id;
+    return new FakeConnection(dc);
+  }
+  packetCodec() {
+    const inner = this.params.packetCodec?.() ?? new IntermediatePacketCodec();
+    return {
+      decode: (reader, eof) => inner.decode(reader, eof),
+      reset: () => inner.reset(),
+      tag: () => inner.tag(),
+      encode: (message, into) => {
+        this.params.onMessage?.(message, this._dcId);
+        return inner.encode(message, into);
+      }
+    };
+  }
+}
+export {
+  StubTelegramTransport
+};

package/utils.js

@@ -0,0 +1,15 @@
+import { parseMarkedPeerId } from "@mtcute/core";
+function markedIdToPeer(id) {
+  const [type, bareId] = parseMarkedPeerId(id);
+  switch (type) {
+    case "user":
+      return { _: "peerUser", userId: bareId };
+    case "chat":
+      return { _: "peerChat", chatId: bareId };
+    case "channel":
+      return { _: "peerChannel", channelId: bareId };
+  }
+}
+export {
+  markedIdToPeer
+};

package/index.d.cts

@@ -1,8 +0,0 @@
-export * from './client.js';
-export * from './crypto.js';
-export * from './platform.js';
-export * from './storage.js';
-export * from './storage/index.js';
-export * from './stub.js';
-export * from './transport.js';
-export * from './types.js';

package/platform.test.d.ts

@@ -1 +0,0 @@
-export {};

package/transport.test.d.ts

@@ -1 +0,0 @@
-export {};