@nathapp/na-cli 1.0.0-rc.4 → 1.0.0-rc.41

package/dist/templates/k8s-deployment/services/charts/tests/charts/e2e-test-js/tests/hub.ts

@@ -0,0 +1,372 @@
+'use strict';
+
+import path from "path";
+import { it } from 'mocha';
+import chai, { expect } from 'chai';
+import chaihttp from 'chai-http';
+import { errors, throwError } from "mxw-libs-errors";
+import { bigNumberify, hexlify, isUndefinedOrNullOrEmpty } from 'mxw-libs-utils';
+import { mxw, utils } from "mxw-sdk-js";
+
+chai.use(chaihttp);
+
+let indent = "     ";
+
+export class User {
+    code: string;
+    id?: number
+
+    username?: string
+    password?: string
+    domain?: string
+
+    wallet?: mxw.Wallet
+    loginWallet?: mxw.Wallet
+
+    jwt?: string
+    mxwJwt?: string
+
+    kyc: {
+        kycId?: number
+        idType?: number
+        flow?: string
+        ocrAlter?: boolean
+        status?: number
+    } = {};
+
+    profile?: {
+        gender?: string
+        country?: string
+        language?: string
+        religion?: string
+        dob?: number
+        address?: {
+            value: string
+            street: string
+            postcode: string
+            city: string
+            state: string
+            province: string
+            country: string
+        },
+        alias?: string
+    } = {}
+
+    constructor(code: string) {
+        this.code = code;
+    }
+
+    public get email() {
+        return this.username + "@" + this.domain;
+    }
+}
+
+export default class HubService {
+    private static self: HubService;
+
+    public users: {
+        [code: string]: User
+    } = {};
+
+    public static get Instance(): HubService {
+        return this.self || (this.self = new this());
+    }
+
+    public silent: boolean = false;
+    public appId: number;
+
+    public init(silent: boolean = true): HubService {
+        this.silent = silent;
+
+        let i = hexlify(utils.randomBytes(1));
+        this.appId = bigNumberify(hexlify(utils.randomBytes(1))).toNumber();
+
+        if (process.env.CI_DEBUG === "true") {
+            process.env.SERVICE_BASE_SCHEMA = "https";
+            process.env.SERVICE_BASE_DOMAIN = "dev-hk-service.usdp.io";
+            process.env.SERVICE_BASE_NAME = "bdss";
+            process.env.SERVICE_DOMAIN = "BDSS";
+
+            process.env.MXW_V1_SERVICE_BASE_SCHEMA = "https";
+            process.env.MXW_V1_SERVICE_BASE_DOMAIN = "dev-hk-api-mxw.usdp.io";
+            process.env.MXW_V1_SERVICE_BASE_NAME = "";
+            process.env.MXW_V1_SERVICE_DOMAIN = "MXW";
+
+            process.env.MXW_SERVICE_BASE_SCHEMA = "https";
+            process.env.MXW_SERVICE_BASE_DOMAIN = "dev-hk-service.usdp.io";
+            process.env.MXW_SERVICE_BASE_NAME = "mxw";
+            process.env.MXW_SERVICE_DOMAIN = "MXW";
+
+            process.env.EMAIL_SERVER_URL = "https://dev-hk-mail.usdp.io";
+        }
+
+        return this;
+    }
+
+    public term() {
+        return Promise.resolve();
+    }
+}
+
+HubService.Instance.init();
+
+export function challengeIt(topic: string, func, emptyParams, challenge: boolean) {
+    if (!challenge) {
+        return;
+    }
+
+    for (let loop of [
+        {
+            message: "challenge missing request",
+            params: undefined
+        },
+        {
+            message: "challenge empty request",
+            params: {}
+        },
+        {
+            message: "challenge null params",
+            params: null
+        },
+        {
+            message: "challenge empty params",
+            params: ""
+        }
+    ]) {
+        it(topic + " - " + loop.message, function () {
+            if (null === loop.params) {
+                loop.params = nullObject(emptyParams);
+            }
+            else if ("" === loop.params) {
+                loop.params = emptyParams;
+            }
+
+            return func.apply(this, loop.params);
+        });
+    }
+}
+
+function nullObject(obj) {
+    if ("object" == typeof obj) {
+        let ret = (Array.isArray(obj)) ? [] : {};
+
+        Object.keys(obj).forEach(function (key) {
+            if (null == obj[key]) {
+                ret[key] = null;
+            }
+            else if ("object" == typeof obj[key] && 0 < Object.keys(obj[key]).length) {
+                ret[key] = nullObject(obj[key]);
+            }
+            else {
+                if (Array.isArray(ret)) {
+                    ret.push(null);
+                }
+                else {
+                    if ("" === obj[key] || 0 === obj[key]) {
+                        ret[key] = null;
+                    }
+                    else {
+                        ret[key] = obj[key];
+                    }
+                }
+            }
+        });
+        return ret;
+    }
+    return obj;
+}
+
+export function getActivationToken(username: string, prefix: string) {
+    let emailServerUrl = process.env.EMAIL_SERVER_URL;
+
+    return chai.request(emailServerUrl).get("/api/v1/mailbox/" + username)
+        .type("application/json")
+        .retry(3)
+        .then((res) => {
+            goodRes(res);
+            expect(res.body).to.be.an("array").have.length.greaterThan(0);
+            expect(res.body[res.body.length - 1]).have.property("id");
+            return res.body[res.body.length - 1].id;
+        }).then((mailId) => {
+            return chai.request(emailServerUrl).get("/api/v1/mailbox/" + username + "/" + mailId)
+                .type("application/json")
+                .then((res) => {
+                    goodRes(res);
+                    expect(res.body).have.property("body").have.property("text").contains(prefix);
+
+                    let bodyText: string = res.body.body.text;
+                    return bodyText.split(prefix)[1].split(" )")[0];
+                });
+        });
+}
+
+export function getOTP(username: string, prefix: string) {
+    let retry = 5;
+
+    return new Promise<string>((resolve, reject) => {
+        let get = (interval = 500) => {
+            setTimeout(() => {
+                let emailServerUrl = process.env.EMAIL_SERVER_URL;
+
+                return chai.request(emailServerUrl).get("/api/v1/mailbox/" + username)
+                    .type("application/json")
+                    .then((res) => {
+                        goodRes(res);
+                        expect(res.body).to.be.an("array").have.length.greaterThan(0);
+                        expect(res.body[res.body.length - 1]).have.property("id");
+                        return res.body[res.body.length - 1].id;
+                    }).then((mailId) => {
+                        return chai.request(emailServerUrl).get("/api/v1/mailbox/" + username + "/" + mailId)
+                            .type("application/json")
+                            .then((res) => {
+                                goodRes(res);
+                                expect(res.body).have.property("body").have.property("text").contains(prefix);
+
+                                let bodyText: string = res.body.body.text;
+                                let raw = bodyText.split(prefix)[1].split(".")[0];
+                                let otp: string = "";
+
+                                for (let i = 0; 20 > i; i++) {
+                                    let char = raw.charAt(i);
+                                    if (isUndefinedOrNullOrEmpty(char) || ! /[0-9]/.test(char)) {
+                                        break;
+                                    }
+                                    otp += char;
+                                }
+                                return resolve(otp);
+                            });
+                    }).catch(error => {
+                        if (0 >= --retry) {
+                            return reject(error);
+                        }
+                        get();
+                    });
+            }, interval);
+        }
+        return get(0);
+    });
+}
+
+export function uploadOSS(user: User, serviceUrl: string, servicePath: string, params: any, file: string, mime: string) {
+    return chai.request(serviceUrl).get(servicePath)
+        .type("application/json")
+        .set("Authorization", "Bearer " + user.mxwJwt)
+        .query(params)
+        .then((res) => {
+            goodRet(res);
+            expect(res.body).have.property("data").property("host").is.a("string").lengthOf.greaterThan(0);
+            expect(res.body).have.property("data").property("accessid").is.a("string").lengthOf.greaterThan(0);
+            expect(res.body).have.property("data").property("policy").is.a("string").lengthOf.greaterThan(0);
+            expect(res.body).have.property("data").property("dir").is.a("string").lengthOf.greaterThan(0);
+            expect(res.body).have.property("data").property("callback").is.a("string").lengthOf.greaterThan(0);
+            expect(res.body).have.property("data").property("signature").is.a("string").lengthOf.greaterThan(0);
+
+            return {
+                host: res.body.data.host as string,
+                policy: res.body.data.policy as string,
+                accessid: res.body.data.accessid as string,
+                success_action_status: '200',
+                callback: res.body.data.callback as string,
+                signature: res.body.data.signature as string,
+                dir: res.body.data.dir as string
+            };
+        }).then((credential) => {
+            let extName = path.extname(file);
+            let filename = credential.dir + extName;
+
+            return chai.request(credential.host).post("")
+                .type("application/x-www-form-urlencoded")
+                .field("name", credential.signature)
+                .field("policy", credential.policy)
+                .field("OSSAccessKeyId", credential.accessid)
+                .field("success_action_status", credential.success_action_status)
+                .field("callback", credential.callback)
+                .field("signature", credential.signature)
+                .field("key", filename)
+                .attach("file", file, { filename, contentType: mime })
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("readCredential").is.a("string").lengthOf.greaterThan(0);
+                    return res.body.readCredential as string;
+                });
+        });
+}
+
+export function isKycPassed(status: number) {
+    return (1 /* Approved */ == status || 18 /* In Review */ == status);
+}
+
+export function isKycSubmitted(status: number) {
+    return (10 /* Submitted */ == status || isKycPassed(status));
+}
+
+export function goodRes(res) {
+    expect(res).to.have.status(200);
+    expect(res).is.json;
+}
+
+export function goodRet(res) {
+    goodRes(res);
+    expect(res.body).have.property("ret").is.satisfy(function (value) {
+        if ("0" === value) {
+            return true;
+        }
+        else {
+            if (0 === value) {
+                console.log("\x1b[33m%s", indent, "WARNING: Response ret is numeric!", "\x1b[0m");
+                return true;
+            }
+        }
+        if (res.body.msg) {
+            throwError(errors.INVALID_RESPONSE, res.body.ret + ": " + res.body.msg, { body: res.body });
+        }
+        throwError(errors.INVALID_RESPONSE, "Failed response", { body: res.body });
+    })
+}
+
+export function badRet(res, ret?: string, msg?: string) {
+    goodRes(res);
+    if (isUndefinedOrNullOrEmpty(ret)) {
+        expect(res.body).have.property("ret").is.a("string").is.not.eq("0");
+    }
+    else {
+        expect(res.body).have.property("ret").is.a("string").eq(ret);
+
+        if (!isUndefinedOrNullOrEmpty(msg)) {
+            expect(res.body).have.property("msg").is.a("string").eq(msg);
+        }
+    }
+}
+
+export function serviceUrl(path: string) {
+    let url = (process.env.SERVICE_BASE_SCHEMA ? process.env.SERVICE_BASE_SCHEMA : "https") + "://" + process.env.SERVICE_BASE_DOMAIN;
+
+    if (process.env.SERVICE_BASE_NAME) {
+        url += "/" + process.env.SERVICE_BASE_NAME;
+    }
+    url += path;
+
+    return url;
+}
+
+export function mxwV1ServiceUrl(path: string) {
+    let url = (process.env.MXW_V1_SERVICE_BASE_SCHEMA ? process.env.MXW_V1_SERVICE_BASE_SCHEMA : "https") + "://" + process.env.MXW_V1_SERVICE_BASE_DOMAIN;
+
+    if (process.env.MXW_V1_SERVICE_BASE_NAME) {
+        url += "/" + process.env.MXW_V1_SERVICE_BASE_NAME;
+    }
+    url += path;
+
+    return url;
+}
+
+export function mxwServiceUrl(path: string) {
+    let url = (process.env.MXW_SERVICE_BASE_SCHEMA ? process.env.MXW_SERVICE_BASE_SCHEMA : "https") + "://" + process.env.MXW_SERVICE_BASE_DOMAIN;
+
+    if (process.env.MXW_SERVICE_BASE_NAME) {
+        url += "/" + process.env.MXW_SERVICE_BASE_NAME;
+    }
+    url += path;
+
+    return url;
+}

package/dist/templates/k8s-deployment/services/charts/tests/charts/e2e-test-js/tests/individual-contact.ts

@@ -0,0 +1,158 @@
+'use strict';
+
+import { describe, it } from 'mocha';
+import chai, { expect } from 'chai';
+import chaihttp from 'chai-http';
+
+import HubService, { User, goodRet, mxwServiceUrl, serviceUrl, challengeIt, badRet } from "./hub";
+import { toUtf8Bytes, sortObject, hexlify, checkSafeBigNumberString } from 'mxw-libs-utils';
+import { utils, Wallet, auth } from 'mxw-sdk-js';
+import { JsonRpcProvider } from 'mxw-sdk-js/dist/providers';
+import moment from "moment";
+import { throwError, errors } from 'mxw-libs-errors';
+
+chai.use(chaihttp);
+
+let indent = "     ";
+let silent = true;
+
+export function createContact(user: User, target: User, challenge: boolean) {
+    describe('Suite: Contact: ' + user.code, function () {
+        let contactId: number;
+        let dialCode = hexlify(utils.randomBytes(2)).substr(2);
+        let phoneNo = hexlify(utils.randomBytes(8)).substr(2);
+
+        if (challenge) {
+            it("Create contact - challenge without JWT", function () {
+                return chai.request(serviceUrl("/user/api")).post("/set/contact")
+                    .type("application/json")
+                    .send({
+                        name: target.username,
+                        email: target.email,
+                        company: target.domain,
+                        dialCode: dialCode,
+                        phoneNo: phoneNo
+                    })
+                    .then((res) => {
+                        badRet(res, "Unauthorised");
+                    });
+            });
+        }
+
+        it("Create contact", function () {
+            return chai.request(serviceUrl("/user/api")).post("/set/contact")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .send({
+                    name: target.username + target.username,
+                    email: target.email + target.email,
+                    company: target.domain + target.domain,
+                    dialCode: dialCode + dialCode,
+                    phoneNo: phoneNo + phoneNo
+                })
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("id").is.a("number").greaterThan(0);
+
+                    contactId = res.body.data.id;
+                });
+        });
+
+        if (challenge) {
+            it("List contact - challenge without JWT", function () {
+                return chai.request(serviceUrl("/user/api")).get("/contact/list")
+                    .type("application/json")
+                    .then((res) => {
+                        badRet(res, "Unauthorised");
+                    });
+            });
+        }
+
+        it("Verify created contact", function () {
+            return chai.request(serviceUrl("/user/api")).get("/contact/list")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").is.an("array").lengthOf.greaterThan(0);
+                    expect(res.body.data[0]).have.property("id").is.a("number").greaterThan(0).is.eq(contactId);
+                    expect(res.body.data[0]).have.property("name").is.a("string").is.eq(target.username + target.username);
+                    expect(res.body.data[0]).have.property("userId").is.a("number").is.eq(0);
+                    expect(res.body.data[0]).have.property("email").is.a("string").is.eq(target.email + target.email);
+                    expect(res.body.data[0]).have.property("company").is.a("string").is.eq(target.domain + target.domain);
+                    expect(res.body.data[0]).have.property("dialCode").is.a("string").is.eq(dialCode + dialCode);
+                    expect(res.body.data[0]).have.property("phoneNo").is.a("string").is.eq(phoneNo + phoneNo);
+                });
+        });
+
+        if (challenge) {
+            it("Update contact - challenge without JWT", function () {
+                return chai.request(serviceUrl("/user/api")).put("/upd/contact")
+                    .type("application/json")
+                    .send({
+                        id: contactId,
+                        name: target.username,
+                        email: target.email,
+                        company: target.domain,
+                        dialCode: dialCode,
+                        phoneNo: phoneNo
+                    })
+                    .then((res) => {
+                        badRet(res, "Unauthorised");
+                    });
+            });
+
+            it("Update contact - challenge contact not belong to me", function () {
+                return chai.request(serviceUrl("/user/api")).put("/upd/contact")
+                    .type("application/json")
+                    .set("Authorization", "Bearer " + user.jwt)
+                    .send({
+                        id: 1,
+                        name: target.username,
+                        email: target.email,
+                        company: target.domain,
+                        dialCode: dialCode,
+                        phoneNo: phoneNo
+                    })
+                    .then((res) => {
+                        badRet(res, "2201", "User Not Found");
+                    });
+            });
+        }
+
+        it("Update contact", function () {
+            return chai.request(serviceUrl("/user/api")).put("/upd/contact")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .send({
+                    id: contactId,
+                    name: target.username,
+                    email: target.email,
+                    company: target.domain,
+                    dialCode: dialCode,
+                    phoneNo: phoneNo
+                })
+                .then((res) => {
+                    goodRet(res);
+                });
+        });
+
+        it("Verify updated contact", function () {
+            return chai.request(serviceUrl("/user/api")).get("/contact/list")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").is.an("array").lengthOf.greaterThan(0);
+                    expect(res.body.data[0]).have.property("id").is.a("number").greaterThan(0).is.eq(contactId);
+                    expect(res.body.data[0]).have.property("name").is.a("string").is.eq(target.username);
+                    expect(res.body.data[0]).have.property("userId").is.a("number").is.eq(target.id);
+                    expect(res.body.data[0]).have.property("email").is.a("string").is.eq(target.email);
+                    expect(res.body.data[0]).have.property("company").is.a("string").is.eq(target.domain);
+                    expect(res.body.data[0]).have.property("dialCode").is.a("string").is.eq(dialCode);
+                    expect(res.body.data[0]).have.property("phoneNo").is.a("string").is.eq(phoneNo);
+                });
+        });
+
+    });
+}