@solytude/listmonk 1.0.0

package/dist/testing/index.js

@@ -0,0 +1,573 @@
+import"../chunk-saezhne8.js";
+
+// src/testing/errors.ts
+class MockNotConfiguredError extends Error {
+  name = "MockNotConfiguredError";
+  methodName;
+  resourceName;
+  constructor(resourceName, methodName) {
+    const fullPath = `${resourceName}.${methodName}`;
+    super(`Mock method '${fullPath}' was called but not configured.
+` + `Configure with: mockClient.${fullPath}.mockResolvedValue(...)`);
+    this.resourceName = resourceName;
+    this.methodName = methodName;
+  }
+}
+
+// src/testing/mock-function.ts
+function createMockFunction(resourceName, methodName) {
+  let implementation;
+  let isConfigured = false;
+  const state = {
+    calls: [],
+    results: [],
+    lastCall: undefined,
+    callCount: 0
+  };
+  const mockFn = (...args) => {
+    state.calls.push(args);
+    state.lastCall = args;
+    state.callCount++;
+    if (!isConfigured) {
+      const error = new MockNotConfiguredError(resourceName, methodName);
+      state.results.push({ type: "throw", value: error });
+      throw error;
+    }
+    try {
+      const result = implementation(...args);
+      if (result instanceof Promise) {
+        return result.then((value) => {
+          state.results.push({
+            type: "return",
+            value
+          });
+          return value;
+        }).catch((error) => {
+          state.results.push({ type: "throw", value: error });
+          throw error;
+        });
+      }
+      state.results.push({
+        type: "return",
+        value: result
+      });
+      return result;
+    } catch (error) {
+      state.results.push({
+        type: "throw",
+        value: error instanceof Error ? error : new Error(String(error))
+      });
+      throw error;
+    }
+  };
+  mockFn.mock = state;
+  mockFn.mockResolvedValue = function(value) {
+    isConfigured = true;
+    implementation = () => Promise.resolve(value);
+    return this;
+  };
+  mockFn.mockRejectedValue = function(error) {
+    isConfigured = true;
+    implementation = () => Promise.reject(error);
+    return this;
+  };
+  mockFn.mockImplementation = function(fn) {
+    isConfigured = true;
+    implementation = fn;
+    return this;
+  };
+  mockFn.mockReturnValue = function(value) {
+    isConfigured = true;
+    implementation = () => value;
+    return this;
+  };
+  mockFn.mockAsyncIterator = function(values) {
+    isConfigured = true;
+    implementation = () => {
+      let index = 0;
+      return {
+        [Symbol.asyncIterator]() {
+          return this;
+        },
+        async next() {
+          if (index < values.length) {
+            return { done: false, value: values[index++] };
+          }
+          return { done: true, value: undefined };
+        }
+      };
+    };
+    return this;
+  };
+  mockFn.mockClear = function() {
+    state.calls = [];
+    state.results = [];
+    state.lastCall = undefined;
+    state.callCount = 0;
+    return this;
+  };
+  mockFn.mockReset = function() {
+    this.mockClear();
+    implementation = undefined;
+    isConfigured = false;
+    return this;
+  };
+  return mockFn;
+}
+
+// src/testing/resources/subscribers.ts
+function createMockSubscribersResource() {
+  return {
+    create: createMockFunction("subscribers", "create"),
+    retrieve: createMockFunction("subscribers", "retrieve"),
+    update: createMockFunction("subscribers", "update"),
+    remove: createMockFunction("subscribers", "remove"),
+    list: createMockFunction("subscribers", "list"),
+    listAll: createMockFunction("subscribers", "listAll"),
+    modifyLists: createMockFunction("subscribers", "modifyLists"),
+    modifyListsForList: createMockFunction("subscribers", "modifyListsForList"),
+    blocklist: createMockFunction("subscribers", "blocklist"),
+    blocklistMany: createMockFunction("subscribers", "blocklistMany"),
+    blocklistByQuery: createMockFunction("subscribers", "blocklistByQuery"),
+    deleteMany: createMockFunction("subscribers", "deleteMany"),
+    deleteByQuery: createMockFunction("subscribers", "deleteByQuery"),
+    getBounces: createMockFunction("subscribers", "getBounces"),
+    deleteBounces: createMockFunction("subscribers", "deleteBounces"),
+    export: createMockFunction("subscribers", "export"),
+    sendOptin: createMockFunction("subscribers", "sendOptin"),
+    modifyListsByQuery: createMockFunction("subscribers", "modifyListsByQuery")
+  };
+}
+// src/testing/resources/lists.ts
+function createMockListsResource() {
+  return {
+    create: createMockFunction("lists", "create"),
+    retrieve: createMockFunction("lists", "retrieve"),
+    update: createMockFunction("lists", "update"),
+    remove: createMockFunction("lists", "remove"),
+    list: createMockFunction("lists", "list"),
+    listAll: createMockFunction("lists", "listAll"),
+    deleteMany: createMockFunction("lists", "deleteMany"),
+    deleteByQuery: createMockFunction("lists", "deleteByQuery"),
+    getPublic: createMockFunction("lists", "getPublic")
+  };
+}
+// src/testing/resources/campaigns.ts
+function createMockCampaignsResource() {
+  return {
+    create: createMockFunction("campaigns", "create"),
+    retrieve: createMockFunction("campaigns", "retrieve"),
+    update: createMockFunction("campaigns", "update"),
+    remove: createMockFunction("campaigns", "remove"),
+    list: createMockFunction("campaigns", "list"),
+    listAll: createMockFunction("campaigns", "listAll"),
+    updateStatus: createMockFunction("campaigns", "updateStatus"),
+    preview: createMockFunction("campaigns", "preview"),
+    previewText: createMockFunction("campaigns", "previewText"),
+    getRunningStats: createMockFunction("campaigns", "getRunningStats"),
+    getAnalytics: createMockFunction("campaigns", "getAnalytics"),
+    sendTest: createMockFunction("campaigns", "sendTest"),
+    archive: createMockFunction("campaigns", "archive"),
+    convertContent: createMockFunction("campaigns", "convertContent"),
+    deleteMany: createMockFunction("campaigns", "deleteMany"),
+    deleteByQuery: createMockFunction("campaigns", "deleteByQuery")
+  };
+}
+// src/testing/resources/templates.ts
+function createMockTemplatesResource() {
+  return {
+    create: createMockFunction("templates", "create"),
+    retrieve: createMockFunction("templates", "retrieve"),
+    update: createMockFunction("templates", "update"),
+    remove: createMockFunction("templates", "remove"),
+    list: createMockFunction("templates", "list"),
+    listAll: createMockFunction("templates", "listAll"),
+    preview: createMockFunction("templates", "preview"),
+    setDefault: createMockFunction("templates", "setDefault"),
+    deleteMany: createMockFunction("templates", "deleteMany")
+  };
+}
+// src/testing/resources/tx.ts
+function createMockTransactionalResource() {
+  return {
+    send: createMockFunction("tx", "send")
+  };
+}
+// src/testing/resources/media.ts
+function createMockMediaResource() {
+  return {
+    upload: createMockFunction("media", "upload"),
+    list: createMockFunction("media", "list"),
+    listAll: createMockFunction("media", "listAll"),
+    retrieve: createMockFunction("media", "retrieve"),
+    remove: createMockFunction("media", "remove"),
+    deleteMany: createMockFunction("media", "deleteMany")
+  };
+}
+// src/testing/resources/import.ts
+function createMockImportResource() {
+  return {
+    start: createMockFunction("import", "start"),
+    getStatus: createMockFunction("import", "getStatus"),
+    getLogs: createMockFunction("import", "getLogs"),
+    cancel: createMockFunction("import", "cancel")
+  };
+}
+// src/testing/resources/bounces.ts
+function createMockBouncesResource() {
+  return {
+    list: createMockFunction("bounces", "list"),
+    listAll: createMockFunction("bounces", "listAll"),
+    remove: createMockFunction("bounces", "remove"),
+    deleteMany: createMockFunction("bounces", "deleteMany"),
+    deleteAll: createMockFunction("bounces", "deleteAll"),
+    retrieve: createMockFunction("bounces", "retrieve"),
+    blocklistBounced: createMockFunction("bounces", "blocklistBounced")
+  };
+}
+// src/testing/resources/settings.ts
+function createMockSettingsResource() {
+  return {
+    getAll: createMockFunction("settings", "getAll"),
+    update: createMockFunction("settings", "update"),
+    updateByKey: createMockFunction("settings", "updateByKey"),
+    testSmtp: createMockFunction("settings", "testSmtp")
+  };
+}
+// src/testing/resources/dashboard.ts
+function createMockDashboardResource() {
+  return {
+    getCounts: createMockFunction("dashboard", "getCounts"),
+    getCharts: createMockFunction("dashboard", "getCharts")
+  };
+}
+// src/testing/resources/admin.ts
+function createMockAdminResource() {
+  return {
+    reload: createMockFunction("admin", "reload"),
+    getLogs: createMockFunction("admin", "getLogs"),
+    getEventStream: createMockFunction("admin", "getEventStream")
+  };
+}
+// src/testing/resources/maintenance.ts
+function createMockMaintenanceResource() {
+  return {
+    gcSubscribers: createMockFunction("maintenance", "gcSubscribers"),
+    gcSubscriptions: createMockFunction("maintenance", "gcSubscriptions"),
+    gcAnalytics: createMockFunction("maintenance", "gcAnalytics")
+  };
+}
+// src/testing/resources/public.ts
+function createMockPublicResource() {
+  return {
+    getLists: createMockFunction("public", "getLists"),
+    subscribe: createMockFunction("public", "subscribe"),
+    getCaptchaChallenge: createMockFunction("public", "getCaptchaChallenge")
+  };
+}
+// src/testing/mock-client.ts
+class MockListmonkClient {
+  subscribers;
+  lists;
+  campaigns;
+  templates;
+  tx;
+  media;
+  import;
+  bounces;
+  settings;
+  dashboard;
+  admin;
+  maintenance;
+  public;
+  health;
+  publicHealth;
+  getConfig;
+  constructor() {
+    this.subscribers = createMockSubscribersResource();
+    this.lists = createMockListsResource();
+    this.campaigns = createMockCampaignsResource();
+    this.templates = createMockTemplatesResource();
+    this.tx = createMockTransactionalResource();
+    this.media = createMockMediaResource();
+    this.import = createMockImportResource();
+    this.bounces = createMockBouncesResource();
+    this.settings = createMockSettingsResource();
+    this.dashboard = createMockDashboardResource();
+    this.admin = createMockAdminResource();
+    this.maintenance = createMockMaintenanceResource();
+    this.public = createMockPublicResource();
+    this.health = createMockFunction("client", "health");
+    this.publicHealth = createMockFunction("client", "publicHealth");
+    this.getConfig = createMockFunction("client", "getConfig");
+  }
+  reset() {
+    for (const method of Object.values(this.subscribers)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.lists)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.campaigns)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.templates)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.tx)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.media)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.import)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.bounces)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.settings)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.dashboard)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.admin)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.maintenance)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    for (const method of Object.values(this.public)) {
+      if (typeof method?.mockReset === "function") {
+        method.mockReset();
+      }
+    }
+    this.health.mockReset();
+    this.publicHealth.mockReset();
+    this.getConfig.mockReset();
+  }
+}
+// src/testing/factories/common.ts
+var counters = {
+  subscriber: 0,
+  list: 0,
+  campaign: 0,
+  template: 0,
+  media: 0,
+  bounce: 0
+};
+function nextId(key) {
+  return ++counters[key];
+}
+function resetFactories() {
+  counters.subscriber = 0;
+  counters.list = 0;
+  counters.campaign = 0;
+  counters.template = 0;
+  counters.media = 0;
+  counters.bounce = 0;
+}
+var ENTITY_HEX_CODES = {
+  sub: "00000001",
+  list: "00000002",
+  camp: "00000003",
+  tmpl: "00000004",
+  med: "00000005",
+  bnce: "00000006"
+};
+function mockUuid(entityType, id) {
+  const segment1 = ENTITY_HEX_CODES[entityType] || "00000000";
+  const segment2 = id.toString(16).padStart(4, "0");
+  const segment3 = "4000";
+  const segment4 = "8000";
+  const segment5 = id.toString(16).padStart(12, "0");
+  return `${segment1}-${segment2}-${segment3}-${segment4}-${segment5}`;
+}
+function nowISO() {
+  return new Date().toISOString();
+}
+// src/testing/factories/subscriber.ts
+function createMockSubscriber(overrides) {
+  const id = overrides?.id ?? nextId("subscriber");
+  const now = nowISO();
+  return {
+    id,
+    uuid: mockUuid("sub", id),
+    email: `user${id}@example.com`,
+    name: `Test User ${id}`,
+    status: "enabled",
+    attribs: {},
+    lists: [],
+    created_at: now,
+    updated_at: now,
+    ...overrides
+  };
+}
+function createMockSubscribers(count, overrides) {
+  return Array.from({ length: count }, () => createMockSubscriber(overrides));
+}
+// src/testing/factories/list.ts
+function createMockList(overrides) {
+  const id = overrides?.id ?? nextId("list");
+  const now = nowISO();
+  return {
+    id,
+    uuid: mockUuid("list", id),
+    name: `Test List ${id}`,
+    type: "public",
+    optin: "single",
+    status: "active",
+    tags: [],
+    description: "",
+    subscriber_count: 0,
+    created_at: now,
+    updated_at: now,
+    ...overrides
+  };
+}
+function createMockLists(count, overrides) {
+  return Array.from({ length: count }, () => createMockList(overrides));
+}
+// src/testing/factories/campaign.ts
+function createMockCampaign(overrides) {
+  const id = overrides?.id ?? nextId("campaign");
+  const now = nowISO();
+  return {
+    id,
+    uuid: mockUuid("camp", id),
+    name: `Test Campaign ${id}`,
+    subject: `Test Subject ${id}`,
+    from_email: "test@example.com",
+    status: "draft",
+    type: "regular",
+    content_type: "html",
+    body: "<p>Test campaign content</p>",
+    altbody: null,
+    template_id: 1,
+    messenger: "email",
+    lists: [],
+    headers: [],
+    tags: [],
+    send_at: null,
+    started_at: null,
+    to_send: 0,
+    sent: 0,
+    archive: false,
+    archive_slug: null,
+    archive_template_id: null,
+    archive_meta: {},
+    views: 0,
+    clicks: 0,
+    bounces: 0,
+    created_at: now,
+    updated_at: now,
+    ...overrides
+  };
+}
+function createMockCampaigns(count, overrides) {
+  return Array.from({ length: count }, () => createMockCampaign(overrides));
+}
+// src/testing/factories/template.ts
+function createMockTemplate(overrides) {
+  const id = overrides?.id ?? nextId("template");
+  const now = nowISO();
+  return {
+    id,
+    name: `Test Template ${id}`,
+    type: "campaign",
+    subject: null,
+    body: '<html><body>{{ template "content" . }}</body></html>',
+    is_default: false,
+    created_at: now,
+    updated_at: now,
+    ...overrides
+  };
+}
+function createMockTemplates(count, overrides) {
+  return Array.from({ length: count }, () => createMockTemplate(overrides));
+}
+// src/testing/factories/media.ts
+function createMockMedia(overrides) {
+  const id = overrides?.id ?? nextId("media");
+  const now = nowISO();
+  return {
+    id,
+    uuid: mockUuid("med", id),
+    filename: `image${id}.jpg`,
+    content_type: "image/jpeg",
+    url: `/uploads/image${id}.jpg`,
+    thumb_url: `/uploads/thumb_image${id}.jpg`,
+    provider: "filesystem",
+    meta: {},
+    created_at: now,
+    ...overrides
+  };
+}
+function createMockMediaItems(count, overrides) {
+  return Array.from({ length: count }, () => createMockMedia(overrides));
+}
+// src/testing/factories/bounce.ts
+function createMockBounce(overrides) {
+  const id = overrides?.id ?? nextId("bounce");
+  const now = nowISO();
+  return {
+    id,
+    email: `bounce${id}@example.com`,
+    subscriber_uuid: mockUuid("sub", id),
+    subscriber_id: id,
+    campaign: null,
+    type: "hard",
+    source: "smtp",
+    meta: {},
+    created_at: now,
+    ...overrides
+  };
+}
+function createMockBounces(count, overrides) {
+  return Array.from({ length: count }, () => createMockBounce(overrides));
+}
+export {
+  resetFactories,
+  createMockTemplates,
+  createMockTemplate,
+  createMockSubscribers,
+  createMockSubscriber,
+  createMockMediaItems,
+  createMockMedia,
+  createMockLists,
+  createMockList,
+  createMockFunction,
+  createMockCampaigns,
+  createMockCampaign,
+  createMockBounces,
+  createMockBounce,
+  MockNotConfiguredError,
+  MockListmonkClient
+};
+
+//# debugId=367CDA81B275C35364756E2164756E21