@nathapp/na-cli 1.0.8 → 1.0.9

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

@@ -0,0 +1,493 @@
+'use strict';
+
+import { describe, it } from 'mocha';
+import chai, { expect } from 'chai';
+import chaihttp from 'chai-http';
+
+import HubService, { User, challengeIt, goodRet, badRet, serviceUrl, getActivationToken, isKycPassed } from "./hub";
+import { checkFormat, checkNumber, checkString, hexlify, isUndefinedOrNullOrEmpty, notAllowNullOrEmpty } from 'mxw-libs-utils';
+import { utils } from 'mxw-sdk-js';
+import { stringify } from 'querystring';
+import md5 from 'md5';
+
+chai.use(chaihttp);
+
+let indent = "     ";
+
+export function webOnboard(user: User, challenge: boolean) {
+    describe('Suite: Individual Web Onboard: ' + user.code + " (" + user.email + ")", function () {
+        let activationToken: string;
+
+        challengeIt("Check email address before register: " + user.email, function (params) {
+            let url = serviceUrl("/auth-web/api");
+
+            return chai.request(url).post("/register/verify/email")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send(params).then((res) => {
+                    badRet(res);
+                });
+        }, {
+            email: ""
+        }, challenge);
+
+        it("Check email address before register: " + user.email, function () {
+            let url = serviceUrl("/auth-web/api");
+
+            return chai.request(url).post("/register/verify/email")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send({
+                    email: user.email
+                }).then((res) => {
+                    if (0 < user.id) {
+                        badRet(res, "3201"); // A user with the specified email already exists
+                    }
+                    else {
+                        goodRet(res);
+                    }
+                });
+        });
+
+        challengeIt("Register", function (params) {
+            let url = serviceUrl("/auth-web/api");
+
+            return chai.request(url).post("/register")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send(params).then((res) => {
+                    badRet(res);
+                });
+        }, {
+            email: "",
+            pwd: ""
+        }, challenge);
+
+        it("Register", function () {
+            let url = serviceUrl("/auth-web/api");
+
+            return chai.request(url).post("/register")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send({
+                    email: user.email,
+                    pwd: user.password
+                }).then((res) => {
+                    if (0 < user.id) {
+                        badRet(res, "3201"); // A user with the specified email already exists
+                    }
+                    else {
+                        goodRet(res);
+                        if (!HubService.Instance.silent) { console.log(indent, "Registered with", user.email, ":", user.password) }
+                    }
+                });
+        });
+
+        it("Check activation email", function () {
+            if (0 < user.id) {
+                this.skip();
+            }
+            return getActivationToken(user.username, "/bdss/u/activation/").then((token) => {
+                activationToken = token;
+                if (!HubService.Instance.silent) { console.log(indent, "Activation token:", activationToken) }
+            });
+        });
+
+        challengeIt("Activation", function (params) {
+            if (isUndefinedOrNullOrEmpty(activationToken)) {
+                this.skip();
+            }
+            let url = serviceUrl("/auth-web/api");
+
+            return chai.request(url).post("/register/verify/activate")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send(params)
+                .then((res) => {
+                    badRet(res);
+                });
+        }, {
+            accessKey: ""
+        }, challenge);
+
+        it("Activation", function () {
+            let url = serviceUrl("/auth-web/api");
+
+            return chai.request(url).post("/register/verify/activate")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send({
+                    accessKey: activationToken
+                })
+                .then((res) => {
+                    if (0 < user.id) {
+                        badRet(res, "ParameterMissing");
+                    }
+                    else {
+                        goodRet(res);
+                        expect(res.body).have.property("data").have.property("userId").is.a("number");
+                        expect(res.body).have.property("data").have.property("usrLogin").is.eq(user.email);
+                        expect(res.body).have.property("data").have.property("token").is.a("string").lengthOf.greaterThan(0);
+
+                        user.id = res.body.data.userId;
+                        if (!HubService.Instance.silent) { console.log(indent, "Activated userId:", user.id, "username:", user.email, "password:", user.password) }
+                    }
+                });
+        });
+
+        if (challenge) {
+            it("Register - should not allowed re-register", function () {
+                let url = serviceUrl("/auth-web/api");
+
+                return chai.request(url).post("/register")
+                    .type("application/json")
+                    .set("no-captcha", "true")
+                    .send({
+                        email: user.email,
+                        pwd: user.password
+                    }).then((res) => {
+                        badRet(res);
+                    });
+            });
+        }
+
+        challengeIt("Login", function (params) {
+            let url = serviceUrl("/auth-web/api");
+
+            return chai.request(url).post("/login")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send(params)
+                .then((res) => {
+                    badRet(res);
+                });
+        }, {
+            username: "",
+            pwd: ""
+        }, challenge);
+
+        if (challenge) {
+            it("Login - challenge wrong password", function () {
+                let url = serviceUrl("/auth-web/api");
+
+                return chai.request(url).post("/login")
+                    .type("application/json")
+                    .set("no-captcha", "true")
+                    .send({
+                        username: user.email,
+                        pwd: hexlify(utils.randomBytes(5)).substr(2)
+                    }).then((res) => {
+                        badRet(res);
+                    });
+            });
+
+            it("Login - challenge wrong useername", function () {
+                let url = serviceUrl("/auth-web/api");
+
+                return chai.request(url).post("/login")
+                    .type("application/json")
+                    .set("no-captcha", "true")
+                    .send({
+                        username: hexlify(utils.randomBytes(5)).substr(2) + user.email,
+                        pwd: user.password
+                    }).then((res) => {
+                        badRet(res);
+                    });
+            });
+        }
+
+        it("Login", function () {
+            let url = serviceUrl("/auth-web/api");
+
+            return chai.request(url).post("/login")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send({
+                    username: user.email,
+                    pwd: user.password
+                })
+                .then((res) => {
+                    if (isUndefinedOrNullOrEmpty(activationToken)) {
+                        badRet(res, "3211"); // Set Password
+
+                        return getActivationToken(user.username, "/bdss/u/first-login/").then((token) => {
+                            return chai.request(url).post("/first-time/login")
+                                .type("application/json")
+                                .set("no-captcha", "true")
+                                .send({
+                                    type: 1,
+                                    pwd: user.password,
+                                    accessKey: token
+                                });
+                        });
+                    }
+                    return res;
+                }).then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").have.property("userId").is.eq(user.id);
+                    expect(res.body).have.property("data").have.property("usrLogin").is.eq(user.email);
+                    expect(res.body).have.property("data").have.property("token").is.a("string").lengthOf.greaterThan(0);
+
+                    user.jwt = res.body.data.token;
+
+                    if (!HubService.Instance.silent) { console.log(indent, "Login with username:", user.email, "password:", user.password) }
+                    if (!HubService.Instance.silent) { console.log(indent, "JWT:", user.jwt) }
+                });
+        });
+    });
+}
+
+export function webReauth(user: User, challenge: boolean) {
+    describe('Suite: Individual Web Reauth: ' + user.code + " (" + user.email + ")", function () {
+        let activationToken: string;
+        let secAnswer: string;
+
+        challenge = false; // TODO
+
+        it("Brute force login", function () {
+            let promises = Promise.resolve();
+
+            for (let i = 0; 3 > i; i++) {
+                promises = promises.then(() => {
+                    return chai.request(serviceUrl("/auth-web/api")).post("/login")
+                        .type("application/json")
+                        .set("no-captcha", "true")
+                        .send({
+                            username: user.email,
+                            pwd: utils.sha256(utils.toUtf8Bytes(hexlify(utils.randomBytes(5)).substr(2)))
+                        })
+                        .then((res) => {
+                            badRet(res, "1102", "Incorrect username or password"); // Incorrect username or password
+                        });
+                });
+            }
+
+            return promises.then(() => {
+                return chai.request(serviceUrl("/auth-web/api")).post("/login")
+                    .type("application/json")
+                    .set("no-captcha", "true")
+                    .send({
+                        username: user.email,
+                        pwd: utils.sha256(utils.toUtf8Bytes(hexlify(utils.randomBytes(5)).substr(2)))
+                    })
+                    .then((res) => {
+                        badRet(res, "1105", "Your Account Is Locked"); // Your Account Is Locked
+                    });
+            });
+        });
+
+        it("Check Reauth activation email", function () {
+            return getActivationToken(user.username, "/bdss/u/re-auth/").then((token) => {
+                activationToken = token;
+                if (!HubService.Instance.silent) { console.log(indent, "Reauth activation token:", activationToken) }
+            });
+        });
+
+        it("Reauth security answer", function () {
+            let token: {
+                email: string,
+                userId: number,
+                expiry: number,
+                kyc: number,
+                twoFa: number,
+                apiKey: string
+            } = checkFormat({
+                email: notAllowNullOrEmpty(checkString),
+                userId: checkNumber,
+                expiry: checkNumber,
+                kyc: checkNumber,
+                twoFa: checkNumber,
+                apiKey: notAllowNullOrEmpty(checkString),
+            }, JSON.parse(utils.toUtf8String(utils.base64.decode(activationToken))));
+
+            expect(token.kyc).is.eq(isKycPassed(user.kyc.status) ? 1 : 0, "KYC status mismatched");
+
+            if (0 == token.kyc) {
+                this.skip();
+            }
+
+            secAnswer = md5((6 <= user.username.length) ? user.username.substr(user.username.length - 6) : user.username);
+
+            return chai.request(serviceUrl("/auth-web/api")).post("/verify/scrt/answer")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send({
+                    accessKey: activationToken,
+                    answer: secAnswer
+                })
+                .then((res) => {
+                    goodRet(res);
+                });
+        });
+
+        if (challenge) {
+            it("Reauth configure password - challenge wrong security answer", function () {
+                let newPwd = utils.sha256(utils.toUtf8Bytes(hexlify(utils.randomBytes(5)).substr(2)));
+
+                return chai.request(serviceUrl("/auth-web/api")).post("/reauth/pwd")
+                    .type("application/json")
+                    .set("no-captcha", "true")
+                    .send({
+                        accessKey: activationToken,
+                        pwd: newPwd,
+                        answer: hexlify(utils.randomBytes(3)).substr(2)
+                    })
+                    .then((res) => {
+                        badRet(res);
+                    });
+            });
+        }
+
+        it("Reauth configure password", function () {
+            let newPwd = utils.sha256(utils.toUtf8Bytes(hexlify(utils.randomBytes(5)).substr(2)));
+
+            return chai.request(serviceUrl("/auth-web/api")).post("/reauth/pwd")
+                .type("application/json")
+                .set("no-captcha", "true")
+                .send({
+                    accessKey: activationToken,
+                    pwd: newPwd,
+                    answer: secAnswer
+                })
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("userId").is.a("number").is.eq(user.id);
+                    expect(res.body).have.property("data").property("usrLogin").is.a("string").is.eq(user.email);
+                    expect(res.body).have.property("data").property("token").is.a("string").lengthOf.greaterThan(0);
+
+                    user.password = newPwd;
+                    user.jwt = res.body.data.token;
+                    if (!HubService.Instance.silent) { console.log(indent, "Reauth changed password:", user.password) }
+                });
+        });
+    });
+}
+
+export function changePassword(user: User, challenge: boolean) {
+    describe('Suite: Individual Web Change Password', function () {
+        challengeIt("Change password", function (params) {
+            let url = serviceUrl("/user/api");
+
+            return chai.request(url).put("/chg/pwd")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .send(params)
+                .then((res) => {
+                    badRet(res);
+                });
+        }, {
+            oldPwd: "",
+            newPwd: ""
+        }, challenge);
+
+        if (challenge) {
+            it("Change password - challenge without JWT", function () {
+                let url = serviceUrl("/user/api");
+                let newPwd = utils.sha256(utils.toUtf8Bytes(hexlify(utils.randomBytes(5)).substr(2)));
+
+                return chai.request(url).put("/chg/pwd")
+                    .type("application/json")
+                    .send({
+                        oldPwd: user.password,
+                        newPwd
+                    })
+                    .then((res) => {
+                        badRet(res, "Unauthorised");
+                    });
+            });
+
+            it("Change password - challenge with non existing password", function () {
+                let url = serviceUrl("/user/api");
+
+                return chai.request(url).put("/chg/pwd")
+                    .type("application/json")
+                    .set("Authorization", "Bearer " + user.jwt)
+                    .send({
+                        oldPwd: utils.sha256(utils.toUtf8Bytes(user.password + hexlify(utils.randomBytes(2)).substr(2))),
+                        newPwd: utils.sha256(utils.toUtf8Bytes(hexlify(utils.randomBytes(5)).substr(2)))
+                    })
+                    .then((res) => {
+                        badRet(res, "1102"); // Incorrect username or password
+                    });
+            });
+
+            it("Change password - challenge with empty existing password", function () {
+                let url = serviceUrl("/user/api");
+
+                return chai.request(url).put("/chg/pwd")
+                    .type("application/json")
+                    .set("Authorization", "Bearer " + user.jwt)
+                    .send({
+                        oldPwd: "",
+                        newPwd: utils.sha256(utils.toUtf8Bytes(hexlify(utils.randomBytes(5)).substr(2)))
+                    })
+                    .then((res) => {
+                        badRet(res, "InvalidFormat");
+                    });
+            });
+
+            it("Change password - challenge with empty new password", function () {
+                let url = serviceUrl("/user/api");
+
+                return chai.request(url).put("/chg/pwd")
+                    .type("application/json")
+                    .set("Authorization", "Bearer " + user.jwt)
+                    .send({
+                        oldPwd: user.password,
+                        newPwd: ""
+                    })
+                    .then((res) => {
+                        badRet(res, "InvalidFormat");
+                    });
+            });
+
+            it("Change password - challenge with new short password", function () {
+                let url = serviceUrl("/user/api");
+
+                return chai.request(url).put("/chg/pwd")
+                    .type("application/json")
+                    .set("Authorization", "Bearer " + user.jwt)
+                    .send({
+                        oldPwd: user.password,
+                        newPwd: hexlify(utils.randomBytes(1)).substr(2)
+                    })
+                    .then((res) => {
+                        badRet(res, "InvalidFormat");
+                    });
+            });
+
+            it("Change password - challenge with new long password", function () {
+                let url = serviceUrl("/user/api");
+
+                return chai.request(url).put("/chg/pwd")
+                    .type("application/json")
+                    .set("Authorization", "Bearer " + user.jwt)
+                    .send({
+                        oldPwd: user.password,
+                        newPwd: hexlify(utils.randomBytes(100)).substr(2)
+                    })
+                    .then((res) => {
+                        badRet(res, "InvalidFormat");
+                    });
+            });
+        }
+
+        it("Change password", function () {
+            let url = serviceUrl("/user/api");
+            let newPwd = utils.sha256(utils.toUtf8Bytes(hexlify(utils.randomBytes(5)).substr(2)));
+
+            return chai.request(url).put("/chg/pwd")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .send({
+                    oldPwd: user.password,
+                    newPwd
+                })
+                .then((res) => {
+                    goodRet(res);
+                    user.password = newPwd;
+                    if (!HubService.Instance.silent) { console.log(indent, "Changed password:", user.password) }
+                });
+        });
+    });
+}