@smess/networking 1.1.5 → 2.0.0

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

@@ -1,167 +0,0 @@
-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

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

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

@@ -1,211 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

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

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

@@ -1,158 +0,0 @@
-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);
-        });
-    });
-});