@smess/networking 1.0.2 → 1.0.4

package/README.md

@@ -26,12 +26,12 @@ const configB = {
 
 ### 2. Create providers/services with config
 ```typescript
-import { ProductService } from './core/product.service';
-import { UserService } from './core/user.service';
+import { ProductService, UserService, AuthService } from '@smess/networking';
 
 const productServiceA = new ProductService(configA);
 const productServiceB = new ProductService(configB);
 const userServiceA = new UserService(configA);
+const authServiceA = new AuthService(configA);
 ```
 
 ### 3. Use services independently
@@ -39,12 +39,12 @@ const userServiceA = new UserService(configA);
 productServiceA.fetchAllProducts().subscribe(...);
 productServiceB.createProduct({ name: 'X', price: 10 }).subscribe(...);
 userServiceA.fetchUserById(1).subscribe(...);
+authServiceA.login({ identifier: 'user', password: 'pass' }).subscribe(...);
 ```
 
 ### 4. Example: Custom Provider
 ```typescript
-import { BaseProvider } from './core/base.provider';
-import { SmessService } from './services/smess.service';
+import { BaseProvider, SmessService } from '@smess/networking';
 
 const config = {
   baseUrl: 'https://custom-api',
@@ -72,27 +72,6 @@ service.request().subscribe(result => {
 });
 ```
 
-### 4. Example: Custom CustomerProvider
-
-```typescript
-import { CustomerProvider, CustomerTarget } from './core/customer.provider';
-import { SmessService } from './services/smess.service';
-
-const config = {
-  baseUrl: 'https://api.example.com',
-  isProd: false,
-  clientId: 'customer-client',
-  apiKey: 'customer-key',
-};
-
-const provider = new CustomerProvider(config, 'get-profile');
-const service = new SmessService(provider);
-
-service.request().subscribe(result => {
-  // handle result
-});
-```
-
 ---
 
 ## Private Package Usage

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export * from './src/domain/user.service';
-export * from './src/domain/product.service';
-export * from './src/domain/auth.provider';
-export * from './src/domain/smess.service';
+export * from './src/services/user.service';
+export * from './src/services/product.service';
+export * from './src/services/auth.service';
+export * from './src/services/smess.service';
 export * from './src/core/base.provider';
 export * from './src/core/base.service.wrapper';
 export * from './src/core/axios.observable';

package/dist/index.js

@@ -15,10 +15,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiVersion = exports.baseURL = exports.$logger = void 0;
-__exportStar(require("./src/domain/user.service"), exports);
-__exportStar(require("./src/domain/product.service"), exports);
-__exportStar(require("./src/domain/auth.provider"), exports);
-__exportStar(require("./src/domain/smess.service"), exports);
+__exportStar(require("./src/services/user.service"), exports);
+__exportStar(require("./src/services/product.service"), exports);
+__exportStar(require("./src/services/auth.service"), exports);
+__exportStar(require("./src/services/smess.service"), exports);
 __exportStar(require("./src/core/base.provider"), exports);
 __exportStar(require("./src/core/base.service.wrapper"), exports);
 __exportStar(require("./src/core/axios.observable"), exports);

package/dist/scripts/real-test.js

@@ -3,42 +3,207 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const user_service_js_1 = require("../src/domain/user.service.js");
+const user_service_1 = require("../src/services/user.service");
 const rxjs_1 = require("rxjs");
 const axios_1 = __importDefault(require("axios"));
+const auth_service_1 = require("../src/services/auth.service");
+const customer_service_1 = require("../src/services/customer.service");
+const store_service_1 = require("../src/services/store.service");
+const logger_service_1 = require("../src/services/logger.service");
+function isNetworkingUIEventWrapped(val) {
+    return (typeof val === 'object' &&
+        val !== null &&
+        'hasSuccess' in val &&
+        'hasFailed' in val &&
+        'response' in val);
+}
+async function testAuthService() {
+    const config = {
+        baseUrl: 'https://api.smeservices.cloud',
+        version: 'api/v1',
+        isProd: true,
+        clientId: '665e188a-cdb0-11ef-b5bd-470a5caf5cbc',
+    };
+    const $authToken = new rxjs_1.BehaviorSubject(null);
+    const authService = new auth_service_1.AuthService(config, $authToken);
+    let emitted = false;
+    try {
+        const obs$ = authService.login({ identifier: 'test@email.org', password: 'PassWord123' }).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
+            logger_service_1.$logger.error('❌ AuthService observable error', err, 'real-test');
+            return (0, rxjs_1.of)(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            obs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    logger_service_1.$logger.info('AuthService emission', val, 'real-test');
+                    if (isNetworkingUIEventWrapped(val) && val.hasSuccess && val.response) {
+                        logger_service_1.$logger.info('✅ AuthService real API test succeeded', val.response, 'real-test');
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        logger_service_1.$logger.error('❌ AuthService real API test failed', val.alertModel || val, 'real-test');
+                        reject(new Error('AuthService failed'));
+                    }
+                },
+                error: (err) => {
+                    logger_service_1.$logger.error('❌ AuthService observable error', err, 'real-test');
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        logger_service_1.$logger.error('❌ AuthService observable completed without emission', undefined, 'real-test');
+                        reject(new Error('No emission'));
+                    }
+                }
+            });
+        });
+    }
+    catch (err) {
+        logger_service_1.$logger.error('❌ AuthService test error', err, 'real-test');
+        process.exit(2);
+    }
+}
 async function testUserService() {
     const config = {
         baseUrl: 'https://jsonplaceholder.typicode.com',
         isProd: false,
     };
-    const userService = new user_service_js_1.UserService(config);
+    const userService = new user_service_1.UserService(config);
     let emitted = false;
     try {
         const obs$ = userService.fetchUserById(1).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
-            console.error('❌ UserService observable error:', err);
+            logger_service_1.$logger.error('❌ UserService observable error', err, 'real-test');
             return (0, rxjs_1.of)(undefined);
         }));
         await new Promise((resolve, reject) => {
             obs$.subscribe({
                 next: (val) => {
                     emitted = true;
-                    console.log('UserService emission:', val);
-                    if (val && val.hasSuccess && val.response) {
-                        console.log('✅ UserService real API test succeeded:', val.response);
+                    logger_service_1.$logger.info('UserService emission', val, 'real-test');
+                    if (isNetworkingUIEventWrapped(val) && val.hasSuccess && val.response) {
+                        logger_service_1.$logger.info('✅ UserService real API test succeeded', val.response, 'real-test');
                         resolve(undefined);
                     }
-                    else if (val && val.hasFailed) {
-                        console.error('❌ UserService real API test failed:', val.alertModel || val);
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        logger_service_1.$logger.error('❌ UserService real API test failed', val.alertModel || val, 'real-test');
                         reject(new Error('UserService failed'));
                     }
                 },
                 error: (err) => {
-                    console.error('❌ UserService observable error:', err);
+                    logger_service_1.$logger.error('❌ UserService observable error', err, 'real-test');
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        logger_service_1.$logger.error('❌ UserService observable completed without emission', undefined, 'real-test');
+                        reject(new Error('No emission'));
+                    }
+                }
+            });
+        });
+    }
+    catch (err) {
+        logger_service_1.$logger.error('❌ UserService test error', err, 'real-test');
+        process.exit(2);
+    }
+}
+async function testCustomerRegister() {
+    const config = {
+        baseUrl: 'https://api.smeservices.cloud',
+        version: 'api/v1',
+        isProd: true,
+        clientId: '665e188a-cdb0-11ef-b5bd-470a5caf5cbc',
+    };
+    const $authToken = new rxjs_1.BehaviorSubject(null);
+    const customerService = new customer_service_1.CustomerService(config, $authToken);
+    const random = Math.floor(Math.random() * 1000000);
+    const payload = {
+        email: `realtest+${random}@email.org`,
+        password: `PassWord${random}`,
+        phone_number: `+83${random}`,
+        client_id: config.clientId,
+    };
+    let emitted = false;
+    try {
+        const obs$ = customerService.register(payload).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
+            logger_service_1.$logger.error('❌ CustomerService observable error', err, 'real-test');
+            return (0, rxjs_1.of)(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            obs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    logger_service_1.$logger.info('CustomerService emission', val, 'real-test');
+                    if (isNetworkingUIEventWrapped(val) && val.hasSuccess && val.response) {
+                        logger_service_1.$logger.info('✅ CustomerService real API test succeeded', val.response, 'real-test');
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        logger_service_1.$logger.error('❌ CustomerService real API test failed', val.alertModel || val, 'real-test');
+                        reject(new Error('CustomerService failed'));
+                    }
+                },
+                error: (err) => {
+                    logger_service_1.$logger.error('❌ CustomerService observable error', err, 'real-test');
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        logger_service_1.$logger.error('❌ CustomerService observable completed without emission', undefined, 'real-test');
+                        reject(new Error('No emission'));
+                    }
+                }
+            });
+        });
+    }
+    catch (err) {
+        logger_service_1.$logger.error('❌ CustomerService test error', err, 'real-test');
+        process.exit(2);
+    }
+}
+async function testStoreProductCollection() {
+    const config = {
+        baseUrl: 'https://api.smeservices.cloud',
+        version: 'api/v1',
+        isProd: true,
+        clientId: '665e188a-cdb0-11ef-b5bd-470a5caf5cbc',
+    };
+    const $authToken = new rxjs_1.BehaviorSubject(null);
+    const storeService = new store_service_1.StoreService(config, $authToken);
+    const storeId = 'f1df6e9a-0160-11f0-82c2-6cac1a7e2953'; // Use a real or test store id as appropriate
+    const payload = {
+        page: 1,
+        per_page: 10,
+        search: 'bia',
+    };
+    let emitted = false;
+    try {
+        const obs$ = storeService.productCollection(storeId, payload).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
+            logger_service_1.$logger.error('❌ StoreService.productCollection observable error', err, 'real-test');
+            return (0, rxjs_1.of)(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            obs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    logger_service_1.$logger.info('StoreService.productCollection emission', val, 'real-test');
+                    if (isNetworkingUIEventWrapped(val) && val.hasSuccess && val.response) {
+                        logger_service_1.$logger.info('✅ StoreService.productCollection real API test succeeded', val.response, 'real-test');
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        logger_service_1.$logger.error('❌ StoreService.productCollection real API test failed', val.alertModel || val, 'real-test');
+                        reject(new Error('StoreService.productCollection failed'));
+                    }
+                },
+                error: (err) => {
+                    logger_service_1.$logger.error('❌ StoreService.productCollection observable error', err, 'real-test');
                     reject(err);
                 },
                 complete: () => {
                     if (!emitted) {
-                        console.error('❌ UserService observable completed without emission');
+                        logger_service_1.$logger.error('❌ StoreService.productCollection observable completed without emission', undefined, 'real-test');
                         reject(new Error('No emission'));
                     }
                 }
@@ -46,7 +211,7 @@ async function testUserService() {
         });
     }
     catch (err) {
-        console.error('❌ UserService test error:', err);
+        logger_service_1.$logger.error('❌ StoreService.productCollection test error', err, 'real-test');
         process.exit(2);
     }
 }
@@ -54,21 +219,29 @@ async function testAxiosDirect() {
     try {
         const response = await axios_1.default.get('https://jsonplaceholder.typicode.com/users/1');
         if (response && response.data && response.data.id === 1) {
-            console.log('✅ Direct axios test succeeded:', response.data);
+            logger_service_1.$logger.info('✅ Direct axios test succeeded', response.data, 'real-test');
         }
         else {
-            console.error('❌ Direct axios test failed:', response.data);
+            logger_service_1.$logger.error('❌ Direct axios test failed', response.data, 'real-test');
             process.exit(3);
         }
     }
     catch (err) {
-        console.error('❌ Direct axios test error:', err);
+        logger_service_1.$logger.error('❌ Direct axios test error', err, 'real-test');
         process.exit(4);
     }
 }
 (async () => {
     await testAxiosDirect();
+    logger_service_1.$logger.info('✅ Direct axios test passed!', undefined, 'real-test');
+    await testAuthService();
+    logger_service_1.$logger.info('✅ AuthService real API tests passed!', undefined, 'real-test');
     await testUserService();
-    console.log('🎉 All real API tests passed!');
+    logger_service_1.$logger.info('✅ UserService real API tests passed!', undefined, 'real-test');
+    await testCustomerRegister();
+    logger_service_1.$logger.info('✅ CustomerService real API register test passed!', undefined, 'real-test');
+    await testStoreProductCollection();
+    logger_service_1.$logger.info('✅ StoreService.productCollection real API test passed!', undefined, 'real-test');
+    logger_service_1.$logger.info('🎉 All real API tests passed!', undefined, 'real-test');
     process.exit(0);
 })();

package/dist/src/core/base.service.wrapper.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseServiceWrapper = void 0;
-const smess_service_1 = require("../domain/smess.service");
+const smess_service_1 = require("../services/smess.service");
 class BaseServiceWrapper {
     constructor(provider) {
         this.provider = provider;

package/dist/src/core/base.service.wrapper.test.js

@@ -4,7 +4,7 @@ const base_service_wrapper_1 = require("./base.service.wrapper");
 const types_1 = require("../types/types");
 const rxjs_1 = require("rxjs");
 // Mock SmessService for testing
-jest.mock('../domain/smess.service', () => ({
+jest.mock('../services/smess.service', () => ({
     SmessService: jest.fn().mockImplementation(() => ({
         request: jest.fn(() => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 'bar' })))
     }))

package/dist/src/services/auth.service.d.ts

@@ -0,0 +1,57 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types';
+import { SmessService } from './smess.service';
+import { BehaviorSubject, Observable } from "rxjs";
+export interface AuthLoginRequest {
+    identifier: string;
+    password: string;
+}
+export interface ForgotPasswordRequest {
+    identifier: string;
+}
+export interface AuthChangePasswordRequest {
+    old_password: string;
+    password: string;
+}
+export interface ResetPasswordRequest {
+    token: string;
+    password: string;
+}
+export type AuthLoginResponse = {
+    token_type: unknown;
+    expires_in: unknown;
+    token: unknown;
+    refresh_token: unknown;
+};
+export type AuthTarget = 'login' | 'logout' | 'change-password' | 'password-forgot' | 'reset-password' | 'verify-reset-password-token';
+export declare class AuthProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: AuthTarget, $authToken: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface AuthServiceType {
+    provider(target: AuthTarget): SmessService<AuthProvider>;
+    login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+    logout(): Observable<NetworkingUIEventWrapped<void>>;
+    forgotPassword(payload: ForgotPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    changePassword(payload: AuthChangePasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    resetPassword(payload: ResetPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    verifyResetPasswordToken(token: string): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+}
+export declare class AuthService implements AuthServiceType {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: AuthTarget): SmessService<AuthProvider>;
+    login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+    logout(): Observable<NetworkingUIEventWrapped<void>>;
+    forgotPassword(payload: ForgotPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    changePassword(payload: AuthChangePasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    resetPassword(payload: ResetPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    verifyResetPasswordToken(token: string): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+}

package/dist/src/services/auth.service.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = exports.AuthProvider = void 0;
+const smess_service_1 = require("./smess.service");
+class AuthProvider {
+    constructor(config, target, $authToken) {
+        this.config = config;
+        this.target = target;
+        this.$authToken = $authToken;
+    }
+    get baseURL() {
+        return this.config.version ? `${this.config.baseUrl}/${this.config.version}` : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case 'login':
+                return '/authentication/login_check';
+            case 'password-forgot':
+                return '/authentication/forgot-password';
+            case 'reset-password':
+                return '/authentication/reset-password';
+            case 'verify-reset-password-token':
+                return '/authentication/verify-reset-password-token';
+            case 'logout':
+                return '/authentication/logout';
+            case 'change-password':
+                return '/authentication/change-password';
+            default:
+                return '/authentication';
+        }
+    }
+    get method() {
+        switch (this.target) {
+            default:
+                return 'POST';
+        }
+    }
+    get headers() {
+        let authHeaders = {};
+        switch (this.target) {
+            case 'login':
+            case 'password-forgot':
+            case 'reset-password':
+            case 'verify-reset-password-token':
+                authHeaders = smess_service_1.SmessService.getHeaders(smess_service_1.Accept.V1);
+                break;
+            default:
+                authHeaders = smess_service_1.SmessService.getHeaders(smess_service_1.Accept.V1, this.$authToken.value);
+        }
+        if (this.config.clientId) {
+            authHeaders[smess_service_1.SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            authHeaders[smess_service_1.SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        return smess_service_1.SmessService.filterHeaders(authHeaders);
+    }
+    getPath(...queryParams) {
+        let definedPath = this.path;
+        const params = definedPath.match(/\$\{(.+?)\}/g);
+        params === null || params === void 0 ? void 0 : params.forEach((value, index) => {
+            definedPath = definedPath.replace(value, String(queryParams[index]));
+        });
+        return definedPath;
+    }
+}
+exports.AuthProvider = AuthProvider;
+class AuthService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new AuthProvider(this.config, target, this.$authToken);
+        return new smess_service_1.SmessService(targetWrapper);
+    }
+    login(payload) {
+        return this.provider('login').request(payload);
+    }
+    logout() {
+        return this.provider('logout').request();
+    }
+    forgotPassword(payload) {
+        return this.provider('password-forgot').request(payload);
+    }
+    changePassword(payload) {
+        return this.provider('change-password').request(payload);
+    }
+    resetPassword(payload) {
+        return this.provider('reset-password').request(payload);
+    }
+    verifyResetPasswordToken(token) {
+        return this.provider('verify-reset-password-token').request({ token });
+    }
+}
+exports.AuthService = AuthService;

package/dist/src/services/auth.service.test.d.ts

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

package/dist/src/services/auth.service.test.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_service_1 = require("./auth.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+describe('AuthService', () => {
+    const config = {
+        baseUrl: 'https://api.example.com',
+        isProd: false,
+        clientId: 'test-client-id',
+        apiKey: 'test-api-key',
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new rxjs_1.BehaviorSubject(null);
+        service = new auth_service_1.AuthService(config, $authToken);
+    });
+    it('login success', async () => {
+        const payload = { identifier: 'user', password: 'pass' };
+        const response = {
+            token_type: 'Bearer',
+            expires_in: 3600,
+            token: 'token',
+            refresh_token: 'refresh',
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.login(payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('login error', async () => {
+        const payload = { identifier: 'user', password: 'wrong' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.login(payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+    it('logout success', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(undefined)),
+        });
+        const result = await service.logout().toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+    });
+    it('forgotPassword success', async () => {
+        const payload = { identifier: 'user' };
+        const response = { data: 'ok' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.forgotPassword(payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('changePassword success', async () => {
+        const payload = { old_password: 'old', password: 'new' };
+        const response = { data: 'changed' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.changePassword(payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('resetPassword success', async () => {
+        const payload = { token: 'token', password: 'newpass' };
+        const response = { data: 'reset' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.resetPassword(payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('verifyResetPasswordToken success', async () => {
+        const token = 'token';
+        const response = {
+            token_type: 'Bearer',
+            expires_in: 3600,
+            token: 'token',
+            refresh_token: 'refresh',
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.verifyResetPasswordToken(token).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('forgotPassword error', async () => {
+        const payload = { identifier: 'user' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.forgotPassword(payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+    it('changePassword error', async () => {
+        const payload = { old_password: 'old', password: 'bad' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.changePassword(payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+    it('resetPassword error', async () => {
+        const payload = { token: 'bad', password: 'bad' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.resetPassword(payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+    it('verifyResetPasswordToken error', async () => {
+        const token = 'bad';
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.verifyResetPasswordToken(token).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+});