@smess/networking 1.0.28 → 1.0.30

package/dist/src/services/storefront.cart.service.js

@@ -0,0 +1,167 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+import { BehaviorSubject } from "rxjs";
+import { tap } from "rxjs/operators";
+export class StorefrontCartProvider {
+    constructor(config, target, $sessionToken, $authToken) {
+        this.config = config;
+        this.target = target;
+        this.$sessionToken = $sessionToken;
+        this.$authToken = $authToken;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "cart-add-item":
+                return "/storefront/cart/items";
+            case "cart-get":
+                return "/storefront/cart";
+            case "cart-update-item":
+                return "/storefront/cart/items/${id}";
+            case "cart-remove-item":
+                return "/storefront/cart/items/${id}";
+            case "cart-calculate-shipping":
+                return "/storefront/cart/calculate-shipping";
+            default:
+                return "/storefront/cart";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case "cart-add-item":
+                return "POST";
+            case "cart-get":
+                return "GET";
+            case "cart-update-item":
+                return "PUT";
+            case "cart-remove-item":
+                return "DELETE";
+            case "cart-calculate-shipping":
+                return "POST";
+            default:
+                return "GET";
+        }
+    }
+    get headers() {
+        let headers = SmessService.getHeaders(Accept.V1, this.$authToken.value);
+        if (this.config.clientId) {
+            headers[SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            headers[SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        const filteredHeaders = SmessService.filterHeaders(headers);
+        // Add X-Session-Token header if sessionToken is available and not authenticated
+        if (!this.$authToken.value && this.$sessionToken.value) {
+            filteredHeaders["X-Session-Token"] = this.$sessionToken.value;
+        }
+        return filteredHeaders;
+    }
+    getPath(...queryParams) {
+        let definedPath = this.path;
+        const params = definedPath.match(/\$\{(.+?)\}/g);
+        params?.forEach((value, index) => {
+            definedPath = definedPath.replace(value, String(queryParams[index]));
+        });
+        return definedPath;
+    }
+}
+export class StorefrontCartService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+        this.$sessionToken = new BehaviorSubject(null);
+    }
+    provider(target) {
+        const targetWrapper = new StorefrontCartProvider(this.config, target, this.$sessionToken, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * Add item to cart
+     * POST /storefront/cart/items
+     */
+    addToCart(payload) {
+        // If sessionToken is provided in payload, use it
+        if (payload.sessionToken) {
+            this.setSessionToken(payload.sessionToken);
+        }
+        return this.provider("cart-add-item")
+            .request(payload)
+            .pipe(tap((response) => {
+            if (response.response) {
+                this.extractAndStoreSessionToken(response.response);
+            }
+        }));
+    }
+    /**
+     * Get current cart
+     * GET /storefront/cart
+     */
+    getCart() {
+        return this.provider("cart-get")
+            .request()
+            .pipe(tap((response) => {
+            if (response.response) {
+                this.extractAndStoreSessionToken(response.response);
+            }
+        }));
+    }
+    /**
+     * Update cart item quantity
+     * PUT /storefront/cart/items/{cartItemId}
+     */
+    updateCartItem(cartItemId, payload) {
+        return this.provider("cart-update-item")
+            .request(payload, undefined, cartItemId)
+            .pipe(tap((response) => {
+            if (response.response) {
+                this.extractAndStoreSessionToken(response.response);
+            }
+        }));
+    }
+    /**
+     * Remove cart item
+     * DELETE /storefront/cart/items/{cartItemId}
+     */
+    removeCartItem(cartItemId) {
+        return this.provider("cart-remove-item")
+            .request(null, undefined, cartItemId)
+            .pipe(tap((response) => {
+            if (response.response) {
+                this.extractAndStoreSessionToken(response.response);
+            }
+        }));
+    }
+    /**
+     * Calculate shipping costs
+     * POST /storefront/cart/calculate-shipping
+     */
+    calculateShipping(payload) {
+        return this.provider("cart-calculate-shipping").request(payload);
+    }
+    /**
+     * Set the session token
+     */
+    setSessionToken(token) {
+        this.$sessionToken.next(token);
+    }
+    /**
+     * Get the current session token
+     */
+    get currentSessionToken() {
+        return this.$sessionToken.value;
+    }
+    /**
+     * Extract and store session token from cart responses
+     */
+    extractAndStoreSessionToken(response) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const data = response.data;
+        if (data && data.sessionToken) {
+            this.setSessionToken(data.sessionToken);
+        }
+    }
+}

package/dist/src/services/storefront.cart.service.test.d.ts

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

package/dist/src/services/storefront.cart.service.test.js

@@ -0,0 +1,211 @@
+import { StorefrontCartService, StorefrontCartProvider, } from "./storefront.cart.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of, BehaviorSubject } from "rxjs";
+describe("StorefrontCartService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        version: "api/v1",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        service = new StorefrontCartService(config, $authToken);
+    });
+    describe("StorefrontCartProvider", () => {
+        it("should generate correct path for cart-add-item", () => {
+            const $sessionToken = new BehaviorSubject(null);
+            const provider = new StorefrontCartProvider(config, "cart-add-item", $sessionToken, $authToken);
+            expect(provider.path).toBe("/storefront/cart/items");
+            expect(provider.method).toBe("POST");
+        });
+        it("should generate correct path for cart-get", () => {
+            const $sessionToken = new BehaviorSubject(null);
+            const provider = new StorefrontCartProvider(config, "cart-get", $sessionToken, $authToken);
+            expect(provider.path).toBe("/storefront/cart");
+            expect(provider.method).toBe("GET");
+        });
+        it("should generate correct path for cart-update-item", () => {
+            const $sessionToken = new BehaviorSubject(null);
+            const provider = new StorefrontCartProvider(config, "cart-update-item", $sessionToken, $authToken);
+            expect(provider.path).toBe("/storefront/cart/items/${id}");
+            expect(provider.method).toBe("PUT");
+            expect(provider.getPath(123)).toBe("/storefront/cart/items/123");
+        });
+        it("should include session token in headers when not authenticated", () => {
+            const $sessionToken = new BehaviorSubject("test-session");
+            const provider = new StorefrontCartProvider(config, "cart-get", $sessionToken, $authToken);
+            const headers = provider.headers;
+            expect(headers["X-Session-Token"]).toBe("test-session");
+        });
+        it("should include auth token in headers when authenticated", () => {
+            $authToken.next("test-auth-token");
+            const $sessionToken = new BehaviorSubject("test-session");
+            const provider = new StorefrontCartProvider(config, "cart-get", $sessionToken, $authToken);
+            const headers = provider.headers;
+            expect(headers["Authorization"]).toBe("Bearer test-auth-token");
+            expect(headers["X-Session-Token"]).toBeUndefined();
+        });
+    });
+    describe("addToCart", () => {
+        it("should add to cart successfully", async () => {
+            const payload = {
+                productId: 123,
+                quantity: 2,
+            };
+            const response = {
+                data: { sessionToken: "new-session-token", items: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.addToCart(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+            expect(service.currentSessionToken).toBe("new-session-token");
+        });
+        it("should handle add to cart error", async () => {
+            const payload = {
+                productId: 123,
+                quantity: 2,
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.addToCart(payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+        it("should use provided session token", async () => {
+            const payload = {
+                productId: 123,
+                quantity: 2,
+                sessionToken: "provided-token",
+            };
+            const response = {
+                data: { items: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            await service.addToCart(payload).toPromise();
+            expect(service.currentSessionToken).toBe("provided-token");
+        });
+    });
+    describe("getCart", () => {
+        it("should get cart successfully", async () => {
+            const response = {
+                data: { sessionToken: "session-token", items: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getCart().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle get cart error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.getCart().toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("updateCartItem", () => {
+        it("should update cart item successfully", async () => {
+            const payload = {
+                quantity: 5,
+            };
+            const response = {
+                data: { items: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, cartItemId) => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.updateCartItem(123, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle update cart item error", async () => {
+            const payload = {
+                quantity: 5,
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, cartItemId) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.updateCartItem(123, payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("removeCartItem", () => {
+        it("should remove cart item successfully", async () => {
+            const response = {
+                data: { items: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, cartItemId) => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.removeCartItem(123).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle remove cart item error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, cartItemId) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.removeCartItem(123).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("calculateShipping", () => {
+        it("should calculate shipping successfully", async () => {
+            const payload = {
+                postalCode: "12345",
+                deliveryType: "delivery",
+            };
+            const response = {
+                data: { shippingFee: 10.0, isAvailable: true },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.calculateShipping(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle calculate shipping error", async () => {
+            const payload = {
+                postalCode: "12345",
+                deliveryType: "pickup",
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.calculateShipping(payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("session token management", () => {
+        it("should set session token", () => {
+            service.setSessionToken("test-token");
+            expect(service.currentSessionToken).toBe("test-token");
+        });
+        it("should get current session token", () => {
+            service.setSessionToken("test-token");
+            expect(service.currentSessionToken).toBe("test-token");
+        });
+        it("should clear session token", () => {
+            service.setSessionToken("test-token");
+            service.setSessionToken(null);
+            expect(service.currentSessionToken).toBeNull();
+        });
+    });
+});

package/dist/src/services/storefront.checkout.service.d.ts

@@ -0,0 +1,62 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type StorefrontCheckoutTarget = "checkout-validate" | "checkout-process";
+export type PaymentMethod = "cash" | "card" | "bank_transfer" | "check";
+export interface StorefrontBillingInformation {
+    email?: string;
+    phone_number?: string;
+    street?: string;
+    city?: string;
+    postal_code?: string;
+    state?: string;
+    country?: string;
+    [key: string]: unknown;
+}
+export interface StorefrontShippingInformation {
+    email?: string;
+    phone_number?: string;
+    street?: string;
+    city?: string;
+    postal_code?: string;
+    state?: string;
+    country?: string;
+    [key: string]: unknown;
+}
+export interface CheckoutRequest {
+    billingInformation: StorefrontBillingInformation;
+    shippingInformation: StorefrontShippingInformation;
+    paymentMethod: PaymentMethod;
+    paymentDetails?: Record<string, unknown>;
+    customerNote?: string;
+    deliveryType: "pickup" | "delivery";
+}
+export declare class StorefrontCheckoutProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $sessionToken;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: StorefrontCheckoutTarget, $sessionToken: BehaviorSubject<string | null>, $authToken: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export declare class StorefrontCheckoutService {
+    private readonly config;
+    private readonly $authToken;
+    private readonly $sessionToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>, $sessionToken: BehaviorSubject<string | null>);
+    provider(target: StorefrontCheckoutTarget): SmessService<StorefrontCheckoutProvider>;
+    /**
+     * Validate cart before checkout
+     * POST /storefront/checkout/validate
+     */
+    validateCheckout(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Process checkout
+     * POST /storefront/checkout/process
+     */
+    processCheckout(payload: CheckoutRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

package/dist/src/services/storefront.checkout.service.js

@@ -0,0 +1,75 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+export class StorefrontCheckoutProvider {
+    constructor(config, target, $sessionToken, $authToken) {
+        this.config = config;
+        this.target = target;
+        this.$sessionToken = $sessionToken;
+        this.$authToken = $authToken;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "checkout-validate":
+                return "/storefront/checkout/validate";
+            case "checkout-process":
+                return "/storefront/checkout/process";
+            default:
+                return "/storefront/checkout/validate";
+        }
+    }
+    get method() {
+        return "POST";
+    }
+    get headers() {
+        let headers = SmessService.getHeaders(Accept.V1, this.$authToken.value);
+        if (this.config.clientId) {
+            headers[SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            headers[SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        const filteredHeaders = SmessService.filterHeaders(headers);
+        // Add X-Session-Token header if sessionToken is available and not authenticated
+        if (!this.$authToken.value && this.$sessionToken.value) {
+            filteredHeaders["X-Session-Token"] = this.$sessionToken.value;
+        }
+        return filteredHeaders;
+    }
+    getPath(...queryParams) {
+        let definedPath = this.path;
+        const params = definedPath.match(/\$\{(.+?)\}/g);
+        params?.forEach((value, index) => {
+            definedPath = definedPath.replace(value, String(queryParams[index]));
+        });
+        return definedPath;
+    }
+}
+export class StorefrontCheckoutService {
+    constructor(config, $authToken, $sessionToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+        this.$sessionToken = $sessionToken;
+    }
+    provider(target) {
+        const targetWrapper = new StorefrontCheckoutProvider(this.config, target, this.$sessionToken, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * Validate cart before checkout
+     * POST /storefront/checkout/validate
+     */
+    validateCheckout() {
+        return this.provider("checkout-validate").request();
+    }
+    /**
+     * Process checkout
+     * POST /storefront/checkout/process
+     */
+    processCheckout(payload) {
+        return this.provider("checkout-process").request(payload);
+    }
+}

package/dist/src/services/storefront.checkout.service.test.d.ts

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

package/dist/src/services/storefront.checkout.service.test.js

@@ -0,0 +1,158 @@
+import { StorefrontCheckoutService, StorefrontCheckoutProvider, } from "./storefront.checkout.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of, BehaviorSubject } from "rxjs";
+describe("StorefrontCheckoutService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        version: "api/v1",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    let $authToken;
+    let $sessionToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        $sessionToken = new BehaviorSubject(null);
+        service = new StorefrontCheckoutService(config, $authToken, $sessionToken);
+    });
+    describe("StorefrontCheckoutProvider", () => {
+        it("should generate correct path for checkout-validate", () => {
+            const provider = new StorefrontCheckoutProvider(config, "checkout-validate", $sessionToken, $authToken);
+            expect(provider.path).toBe("/storefront/checkout/validate");
+            expect(provider.method).toBe("POST");
+        });
+        it("should generate correct path for checkout-process", () => {
+            const provider = new StorefrontCheckoutProvider(config, "checkout-process", $sessionToken, $authToken);
+            expect(provider.path).toBe("/storefront/checkout/process");
+            expect(provider.method).toBe("POST");
+        });
+        it("should include session token in headers when not authenticated", () => {
+            $sessionToken.next("test-session");
+            const provider = new StorefrontCheckoutProvider(config, "checkout-validate", $sessionToken, $authToken);
+            const headers = provider.headers;
+            expect(headers["X-Session-Token"]).toBe("test-session");
+        });
+        it("should include auth token in headers when authenticated", () => {
+            $authToken.next("test-auth-token");
+            $sessionToken.next("test-session");
+            const provider = new StorefrontCheckoutProvider(config, "checkout-validate", $sessionToken, $authToken);
+            const headers = provider.headers;
+            expect(headers["Authorization"]).toBe("Bearer test-auth-token");
+            expect(headers["X-Session-Token"]).toBeUndefined();
+        });
+    });
+    describe("validateCheckout", () => {
+        it("should validate checkout successfully", async () => {
+            const response = {
+                data: { isValid: true, errors: [], warnings: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.validateCheckout().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle validate checkout error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.validateCheckout().toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("processCheckout", () => {
+        it("should process checkout successfully", async () => {
+            const payload = {
+                billingInformation: {
+                    email: "test@example.com",
+                    street: "123 Main St",
+                    city: "Test City",
+                    postal_code: "12345",
+                },
+                shippingInformation: {
+                    email: "test@example.com",
+                    street: "123 Main St",
+                    city: "Test City",
+                    postal_code: "12345",
+                },
+                paymentMethod: "card",
+                deliveryType: "delivery",
+            };
+            const response = {
+                data: { orderId: 123, status: "completed" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.processCheckout(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle process checkout error", async () => {
+            const payload = {
+                billingInformation: {
+                    email: "test@example.com",
+                },
+                shippingInformation: {
+                    email: "test@example.com",
+                },
+                paymentMethod: "cash",
+                deliveryType: "pickup",
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.processCheckout(payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+        it("should process checkout with guest session token", async () => {
+            $sessionToken.next("guest-session-token");
+            const payload = {
+                billingInformation: {
+                    email: "guest@example.com",
+                },
+                shippingInformation: {
+                    email: "guest@example.com",
+                },
+                paymentMethod: "card",
+                deliveryType: "delivery",
+            };
+            const response = {
+                data: { orderId: 456, status: "completed" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.processCheckout(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should process checkout with authenticated user", async () => {
+            $authToken.next("auth-token");
+            const payload = {
+                billingInformation: {
+                    email: "user@example.com",
+                },
+                shippingInformation: {
+                    email: "user@example.com",
+                },
+                paymentMethod: "bank_transfer",
+                deliveryType: "pickup",
+            };
+            const response = {
+                data: { orderId: 789, status: "completed" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.processCheckout(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+});