@schmock/query 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+interface PaginationOptions {
+    /** Default items per page (default: 10) */
+    defaultLimit?: number;
+    /** Maximum items per page (default: 100) */
+    maxLimit?: number;
+    /** Query parameter name for page number (default: "page") */
+    pageParam?: string;
+    /** Query parameter name for limit (default: "limit") */
+    limitParam?: string;
+}
+interface SortingOptions {
+    /** Fields allowed for sorting */
+    allowed: string[];
+    /** Default sort field */
+    default?: string;
+    /** Default sort order (default: "asc") */
+    defaultOrder?: "asc" | "desc";
+    /** Query parameter name for sort field (default: "sort") */
+    sortParam?: string;
+    /** Query parameter name for sort order (default: "order") */
+    orderParam?: string;
+}
+interface FilteringOptions {
+    /** Fields allowed for filtering */
+    allowed: string[];
+    /** Query parameter prefix for filters (default: "filter") */
+    filterPrefix?: string;
+}
+interface QueryPluginOptions {
+    pagination?: PaginationOptions;
+    sorting?: SortingOptions;
+    filtering?: FilteringOptions;
+}
+export declare function queryPlugin(options: QueryPluginOptions): Schmock.Plugin;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,UAAU,iBAAiB;IACzB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,cAAc;IACtB,iCAAiC;IACjC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,yBAAyB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC9B,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,gBAAgB;IACxB,mCAAmC;IACnC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,kBAAkB;IAC1B,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAoCvE"}

package/dist/index.js

@@ -0,0 +1,102 @@
+/// <reference path="../../../types/schmock.d.ts" />
+export function queryPlugin(options) {
+    return {
+        name: "query",
+        version: "1.0.0",
+        process(context, response) {
+            // Only process array responses
+            if (!Array.isArray(response)) {
+                return { context, response };
+            }
+            let items = [...response];
+            const query = context.query || {};
+            // Apply filtering
+            if (options.filtering) {
+                items = applyFiltering(items, query, options.filtering);
+            }
+            // Apply sorting
+            if (options.sorting) {
+                items = applySorting(items, query, options.sorting);
+            }
+            // Apply pagination
+            if (options.pagination) {
+                const result = applyPagination(items, query, options.pagination);
+                return { context, response: result };
+            }
+            return { context, response: items };
+        },
+    };
+}
+function applyFiltering(items, query, options) {
+    const prefix = options.filterPrefix ?? "filter";
+    let result = items;
+    for (const field of options.allowed) {
+        // Support filter[field]=value format
+        const bracketKey = `${prefix}[${field}]`;
+        // Support filter.field=value format
+        const dotKey = `${prefix}.${field}`;
+        // Support plain field=value format as fallback
+        const value = query[bracketKey] ?? query[dotKey] ?? query[field];
+        if (value !== undefined) {
+            result = result.filter((item) => {
+                const itemValue = item[field];
+                if (itemValue === undefined)
+                    return false;
+                return String(itemValue) === value;
+            });
+        }
+    }
+    return result;
+}
+function applySorting(items, query, options) {
+    const sortParam = options.sortParam ?? "sort";
+    const orderParam = options.orderParam ?? "order";
+    const sortField = query[sortParam] ?? options.default;
+    const rawOrder = query[orderParam] ?? options.defaultOrder ?? "asc";
+    const sortOrder = rawOrder === "desc" ? "desc" : "asc";
+    if (!sortField)
+        return items;
+    // Only sort by allowed fields
+    if (!options.allowed.includes(sortField))
+        return items;
+    return items.sort((a, b) => {
+        const aVal = a[sortField];
+        const bVal = b[sortField];
+        if (aVal === bVal)
+            return 0;
+        if (aVal === undefined)
+            return 1;
+        if (bVal === undefined)
+            return -1;
+        let comparison;
+        if (typeof aVal === "number" && typeof bVal === "number") {
+            comparison = aVal - bVal;
+        }
+        else {
+            comparison = String(aVal).localeCompare(String(bVal));
+        }
+        return sortOrder === "desc" ? -comparison : comparison;
+    });
+}
+function applyPagination(items, query, options) {
+    const pageParam = options.pageParam ?? "page";
+    const limitParam = options.limitParam ?? "limit";
+    const defaultLimit = options.defaultLimit ?? 10;
+    const maxLimit = options.maxLimit ?? 100;
+    const page = Math.max(1, Number.parseInt(query[pageParam] || "1", 10) || 1);
+    const limit = Math.min(maxLimit, Math.max(1, Number.parseInt(query[limitParam] || String(defaultLimit), 10) ||
+        defaultLimit));
+    const total = items.length;
+    const totalPages = Math.ceil(total / limit);
+    const start = (page - 1) * limit;
+    const data = items.slice(start, start + limit);
+    return {
+        data,
+        pagination: {
+            page,
+            limit,
+            total,
+            totalPages,
+        },
+    };
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@schmock/query",
+  "description": "Pagination, filtering, and sorting plugin for Schmock",
+  "version": "1.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "bun build:lib && bun build:types",
+    "build:lib": "bun build --minify --outdir=dist src/index.ts",
+    "build:types": "tsc -p tsconfig.json",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:bdd": "vitest run --config vitest.config.bdd.ts",
+    "lint": "biome check src/*.ts",
+    "lint:fix": "biome check --write --unsafe src/*.ts"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@schmock/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@amiceli/vitest-cucumber": "^6.2.0",
+    "@types/node": "^25.1.0",
+    "vitest": "^4.0.15"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import { queryPlugin } from "./index";
+
+describe("queryPlugin", () => {
+  it("creates a plugin with correct name", () => {
+    const plugin = queryPlugin({ pagination: {} });
+    expect(plugin.name).toBe("query");
+    expect(plugin.version).toBe("1.0.0");
+  });
+
+  it("passes through non-array responses", async () => {
+    const plugin = queryPlugin({ pagination: {} });
+    const result = await plugin.process(
+      {
+        path: "/test",
+        route: {},
+        method: "GET",
+        params: {},
+        query: {},
+        headers: {},
+        state: new Map(),
+      },
+      { message: "not an array" },
+    );
+
+    expect(result.response).toEqual({ message: "not an array" });
+  });
+
+  it("paginates array responses", async () => {
+    const plugin = queryPlugin({
+      pagination: { defaultLimit: 2, maxLimit: 10 },
+    });
+
+    const items = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
+    const result = await plugin.process(
+      {
+        path: "/test",
+        route: {},
+        method: "GET",
+        params: {},
+        query: { page: "2", limit: "2" },
+        headers: {},
+        state: new Map(),
+      },
+      items,
+    );
+
+    expect(result.response).toEqual({
+      data: [{ id: 3 }, { id: 4 }],
+      pagination: { page: 2, limit: 2, total: 5, totalPages: 3 },
+    });
+  });
+
+  it("sorts array responses", async () => {
+    const plugin = queryPlugin({
+      sorting: { allowed: ["name"], default: "name" },
+    });
+
+    const items = [
+      { id: 3, name: "Charlie" },
+      { id: 1, name: "Alice" },
+      { id: 2, name: "Bob" },
+    ];
+
+    const result = await plugin.process(
+      {
+        path: "/test",
+        route: {},
+        method: "GET",
+        params: {},
+        query: { sort: "name", order: "asc" },
+        headers: {},
+        state: new Map(),
+      },
+      items,
+    );
+
+    expect(result.response.map((i: any) => i.name)).toEqual([
+      "Alice",
+      "Bob",
+      "Charlie",
+    ]);
+  });
+
+  it("filters array responses", async () => {
+    const plugin = queryPlugin({
+      filtering: { allowed: ["role"] },
+    });
+
+    const items = [
+      { id: 1, name: "Alice", role: "admin" },
+      { id: 2, name: "Bob", role: "user" },
+      { id: 3, name: "Charlie", role: "admin" },
+    ];
+
+    const result = await plugin.process(
+      {
+        path: "/test",
+        route: {},
+        method: "GET",
+        params: {},
+        query: { "filter[role]": "admin" },
+        headers: {},
+        state: new Map(),
+      },
+      items,
+    );
+
+    expect(result.response).toHaveLength(2);
+    expect(result.response.every((i: any) => i.role === "admin")).toBe(true);
+  });
+
+  it("respects maxLimit", async () => {
+    const plugin = queryPlugin({
+      pagination: { defaultLimit: 5, maxLimit: 3 },
+    });
+
+    const items = Array.from({ length: 10 }, (_, i) => ({ id: i }));
+    const result = await plugin.process(
+      {
+        path: "/test",
+        route: {},
+        method: "GET",
+        params: {},
+        query: { limit: "100" },
+        headers: {},
+        state: new Map(),
+      },
+      items,
+    );
+
+    expect(result.response.data).toHaveLength(3);
+  });
+});

package/src/index.ts

@@ -0,0 +1,185 @@
+/// <reference path="../../../types/schmock.d.ts" />
+
+interface PaginationOptions {
+  /** Default items per page (default: 10) */
+  defaultLimit?: number;
+  /** Maximum items per page (default: 100) */
+  maxLimit?: number;
+  /** Query parameter name for page number (default: "page") */
+  pageParam?: string;
+  /** Query parameter name for limit (default: "limit") */
+  limitParam?: string;
+}
+
+interface SortingOptions {
+  /** Fields allowed for sorting */
+  allowed: string[];
+  /** Default sort field */
+  default?: string;
+  /** Default sort order (default: "asc") */
+  defaultOrder?: "asc" | "desc";
+  /** Query parameter name for sort field (default: "sort") */
+  sortParam?: string;
+  /** Query parameter name for sort order (default: "order") */
+  orderParam?: string;
+}
+
+interface FilteringOptions {
+  /** Fields allowed for filtering */
+  allowed: string[];
+  /** Query parameter prefix for filters (default: "filter") */
+  filterPrefix?: string;
+}
+
+interface QueryPluginOptions {
+  pagination?: PaginationOptions;
+  sorting?: SortingOptions;
+  filtering?: FilteringOptions;
+}
+
+export function queryPlugin(options: QueryPluginOptions): Schmock.Plugin {
+  return {
+    name: "query",
+    version: "1.0.0",
+
+    process(
+      context: Schmock.PluginContext,
+      response?: any,
+    ): Schmock.PluginResult {
+      // Only process array responses
+      if (!Array.isArray(response)) {
+        return { context, response };
+      }
+
+      let items = [...response];
+      const query = context.query || {};
+
+      // Apply filtering
+      if (options.filtering) {
+        items = applyFiltering(items, query, options.filtering);
+      }
+
+      // Apply sorting
+      if (options.sorting) {
+        items = applySorting(items, query, options.sorting);
+      }
+
+      // Apply pagination
+      if (options.pagination) {
+        const result = applyPagination(items, query, options.pagination);
+        return { context, response: result };
+      }
+
+      return { context, response: items };
+    },
+  };
+}
+
+function applyFiltering(
+  items: any[],
+  query: Record<string, string>,
+  options: FilteringOptions,
+): any[] {
+  const prefix = options.filterPrefix ?? "filter";
+  let result = items;
+
+  for (const field of options.allowed) {
+    // Support filter[field]=value format
+    const bracketKey = `${prefix}[${field}]`;
+    // Support filter.field=value format
+    const dotKey = `${prefix}.${field}`;
+    // Support plain field=value format as fallback
+    const value = query[bracketKey] ?? query[dotKey] ?? query[field];
+
+    if (value !== undefined) {
+      result = result.filter((item) => {
+        const itemValue = item[field];
+        if (itemValue === undefined) return false;
+        return String(itemValue) === value;
+      });
+    }
+  }
+
+  return result;
+}
+
+function applySorting(
+  items: any[],
+  query: Record<string, string>,
+  options: SortingOptions,
+): any[] {
+  const sortParam = options.sortParam ?? "sort";
+  const orderParam = options.orderParam ?? "order";
+  const sortField = query[sortParam] ?? options.default;
+  const rawOrder = query[orderParam] ?? options.defaultOrder ?? "asc";
+  const sortOrder = rawOrder === "desc" ? "desc" : "asc";
+
+  if (!sortField) return items;
+
+  // Only sort by allowed fields
+  if (!options.allowed.includes(sortField)) return items;
+
+  return items.sort((a, b) => {
+    const aVal = a[sortField];
+    const bVal = b[sortField];
+
+    if (aVal === bVal) return 0;
+    if (aVal === undefined) return 1;
+    if (bVal === undefined) return -1;
+
+    let comparison: number;
+    if (typeof aVal === "number" && typeof bVal === "number") {
+      comparison = aVal - bVal;
+    } else {
+      comparison = String(aVal).localeCompare(String(bVal));
+    }
+
+    return sortOrder === "desc" ? -comparison : comparison;
+  });
+}
+
+interface PaginatedResult {
+  data: any[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}
+
+function applyPagination(
+  items: any[],
+  query: Record<string, string>,
+  options: PaginationOptions,
+): PaginatedResult {
+  const pageParam = options.pageParam ?? "page";
+  const limitParam = options.limitParam ?? "limit";
+  const defaultLimit = options.defaultLimit ?? 10;
+  const maxLimit = options.maxLimit ?? 100;
+
+  const page = Math.max(1, Number.parseInt(query[pageParam] || "1", 10) || 1);
+  const limit = Math.min(
+    maxLimit,
+    Math.max(
+      1,
+      Number.parseInt(query[limitParam] || String(defaultLimit), 10) ||
+        defaultLimit,
+    ),
+  );
+
+  const total = items.length;
+  const totalPages = Math.ceil(total / limit);
+  const start = (page - 1) * limit;
+  const data = items.slice(start, start + limit);
+
+  return {
+    data,
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages,
+    },
+  };
+}

package/src/steps/query-plugin.steps.ts

@@ -0,0 +1,241 @@
+import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
+import { schmock } from "@schmock/core";
+import { expect } from "vitest";
+import { queryPlugin } from "../index";
+
+const feature = await loadFeature("../../features/query-plugin.feature");
+
+describeFeature(feature, ({ Scenario }) => {
+  let mock: any;
+  let response: any;
+
+  // Generate test data
+  const generateItems = (count: number) =>
+    Array.from({ length: count }, (_, i) => ({ id: i + 1, name: `Item ${i + 1}` }));
+
+  const namedItems = [
+    { id: 1, name: "Charlie" },
+    { id: 2, name: "Alice" },
+    { id: 3, name: "Bob" },
+  ];
+
+  const categorizedItems = [
+    { id: 1, name: "Alice", role: "admin" },
+    { id: 2, name: "Bob", role: "user" },
+    { id: 3, name: "Charlie", role: "admin" },
+    { id: 4, name: "Dave", role: "user" },
+    { id: 5, name: "Eve", role: "moderator" },
+  ];
+
+  Scenario("Basic pagination with default settings", ({ Given, When, Then, And }) => {
+    Given("I create a mock with 25 items and pagination plugin", () => {
+      mock = schmock();
+      mock("GET /items", generateItems(25))
+        .pipe(queryPlugin({
+          pagination: { defaultLimit: 10, maxLimit: 100 },
+        }));
+    });
+
+    When("I request page 1", async () => {
+      response = await mock.handle("GET", "/items", {
+        query: { page: "1" },
+      });
+    });
+
+    Then("I should receive {int} items", (_, count: number) => {
+      expect(response.body.data).toHaveLength(count);
+    });
+
+    And("the pagination total should be {int}", (_, total: number) => {
+      expect(response.body.pagination.total).toBe(total);
+    });
+
+    And("the pagination totalPages should be {int}", (_, totalPages: number) => {
+      expect(response.body.pagination.totalPages).toBe(totalPages);
+    });
+  });
+
+  Scenario("Pagination with custom limit", ({ Given, When, Then, And }) => {
+    Given("I create a mock with 25 items and pagination plugin", () => {
+      mock = schmock();
+      mock("GET /items", generateItems(25))
+        .pipe(queryPlugin({
+          pagination: { defaultLimit: 10, maxLimit: 100 },
+        }));
+    });
+
+    When("I request page 1 with limit 5", async () => {
+      response = await mock.handle("GET", "/items", {
+        query: { page: "1", limit: "5" },
+      });
+    });
+
+    Then("I should receive {int} items", (_, count: number) => {
+      expect(response.body.data).toHaveLength(count);
+    });
+
+    And("the pagination totalPages should be {int}", (_, totalPages: number) => {
+      expect(response.body.pagination.totalPages).toBe(totalPages);
+    });
+  });
+
+  Scenario("Pagination beyond last page returns empty", ({ Given, When, Then, And }) => {
+    Given("I create a mock with 25 items and pagination plugin", () => {
+      mock = schmock();
+      mock("GET /items", generateItems(25))
+        .pipe(queryPlugin({
+          pagination: { defaultLimit: 10, maxLimit: 100 },
+        }));
+    });
+
+    When("I request page 10", async () => {
+      response = await mock.handle("GET", "/items", {
+        query: { page: "10" },
+      });
+    });
+
+    Then("I should receive {int} items", (_, count: number) => {
+      expect(response.body.data).toHaveLength(count);
+    });
+
+    And("the pagination total should be {int}", (_, total: number) => {
+      expect(response.body.pagination.total).toBe(total);
+    });
+  });
+
+  Scenario("Sort items ascending by name", ({ Given, When, Then, And }) => {
+    Given("I create a mock with named items and sorting plugin", () => {
+      mock = schmock();
+      mock("GET /items", namedItems)
+        .pipe(queryPlugin({
+          sorting: { allowed: ["name", "id"], default: "id" },
+        }));
+    });
+
+    When("I request with sort {string} order {string}", async (_, sort: string, order: string) => {
+      response = await mock.handle("GET", "/items", {
+        query: { sort, order },
+      });
+    });
+
+    Then("the first item name should be {string}", (_, name: string) => {
+      expect(response.body[0].name).toBe(name);
+    });
+
+    And("the last item name should be {string}", (_, name: string) => {
+      expect(response.body[response.body.length - 1].name).toBe(name);
+    });
+  });
+
+  Scenario("Sort items descending by name", ({ Given, When, Then, And }) => {
+    Given("I create a mock with named items and sorting plugin", () => {
+      mock = schmock();
+      mock("GET /items", namedItems)
+        .pipe(queryPlugin({
+          sorting: { allowed: ["name", "id"], default: "id" },
+        }));
+    });
+
+    When("I request with sort {string} order {string}", async (_, sort: string, order: string) => {
+      response = await mock.handle("GET", "/items", {
+        query: { sort, order },
+      });
+    });
+
+    Then("the first item name should be {string}", (_, name: string) => {
+      expect(response.body[0].name).toBe(name);
+    });
+
+    And("the last item name should be {string}", (_, name: string) => {
+      expect(response.body[response.body.length - 1].name).toBe(name);
+    });
+  });
+
+  Scenario("Filter items by field value", ({ Given, When, Then, And }) => {
+    Given("I create a mock with categorized items and filtering plugin", () => {
+      mock = schmock();
+      mock("GET /items", categorizedItems)
+        .pipe(queryPlugin({
+          filtering: { allowed: ["role"] },
+        }));
+    });
+
+    When("I request with filter role {string}", async (_, role: string) => {
+      response = await mock.handle("GET", "/items", {
+        query: { "filter[role]": role },
+      });
+    });
+
+    Then("I should receive {int} filtered items", (_, count: number) => {
+      expect(response.body).toHaveLength(count);
+    });
+
+    And("all items should have role {string}", (_, role: string) => {
+      for (const item of response.body) {
+        expect(item.role).toBe(role);
+      }
+    });
+  });
+
+  Scenario("Combined pagination, sorting, and filtering", ({ Given, When, Then, And }) => {
+    const users = [
+      { id: 1, name: "Dave", role: "admin" },
+      { id: 2, name: "Alice", role: "user" },
+      { id: 3, name: "Charlie", role: "admin" },
+      { id: 4, name: "Bob", role: "admin" },
+      { id: 5, name: "Eve", role: "user" },
+      { id: 6, name: "Frank", role: "admin" },
+      { id: 7, name: "Grace", role: "user" },
+      { id: 8, name: "Hank", role: "admin" },
+      { id: 9, name: "Ivy", role: "user" },
+      { id: 10, name: "Jack", role: "admin" },
+      { id: 11, name: "Karen", role: "user" },
+      { id: 12, name: "Leo", role: "admin" },
+      { id: 13, name: "Mona", role: "user" },
+      { id: 14, name: "Nate", role: "admin" },
+      { id: 15, name: "Olivia", role: "user" },
+      { id: 16, name: "Paul", role: "admin" },
+      { id: 17, name: "Quinn", role: "user" },
+      { id: 18, name: "Rose", role: "admin" },
+      { id: 19, name: "Sam", role: "user" },
+      { id: 20, name: "Tina", role: "admin" },
+    ];
+
+    Given("I create a mock with 20 users and full query plugin", () => {
+      mock = schmock();
+      mock("GET /users", users)
+        .pipe(queryPlugin({
+          pagination: { defaultLimit: 10, maxLimit: 100 },
+          sorting: { allowed: ["name", "id"] },
+          filtering: { allowed: ["role"] },
+        }));
+    });
+
+    When("I request page 1 with limit 2 filter role {string} and sort {string}", async (_, role: string, sort: string) => {
+      response = await mock.handle("GET", "/users", {
+        query: { page: "1", limit: "2", "filter[role]": role, sort },
+      });
+    });
+
+    Then("I should receive {int} items", (_, count: number) => {
+      expect(response.body.data).toHaveLength(count);
+    });
+
+    And("the items should be sorted by name ascending", () => {
+      const names = response.body.data.map((item: any) => item.name);
+      const sorted = [...names].sort();
+      expect(names).toEqual(sorted);
+    });
+
+    And("all items should have role {string}", (_, role: string) => {
+      for (const item of response.body.data) {
+        expect(item.role).toBe(role);
+      }
+    });
+
+    And("the pagination total should reflect filtered count", () => {
+      // 11 admins in the dataset
+      expect(response.body.pagination.total).toBe(11);
+    });
+  });
+});