openflow/test/DBHelper.test.ts at master · ITCSsDeveloper/openflow · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
const path = require("path");
const env = path.join(process.cwd(), 'config', '.env');
require("dotenv").config({ path: env }); // , debug: false
import { suite, test, timeout } from '@testdeck/mocha';
import { Config } from "../OpenFlow/src/Config";
import { DatabaseConnection } from '../OpenFlow/src/DatabaseConnection';
import assert = require('assert');
import { Logger } from '../OpenFlow/src/Logger';
import { FederationId, NoderedUtil, TokenUser, User, WellknownIds } from '@openiap/openflow-api';
import { Crypt } from '../OpenFlow/src/Crypt';

@suite class dbhelper_test {
    private rootToken: string;
    private testUser: User;
    private userToken: string;
    @timeout(10000)
    async before() {
        Config.workitem_queue_monitoring_enabled = false;
        Config.disablelogging();
        Logger.configure(true, true);
        Config.db = new DatabaseConnection(Config.mongodb_url, Config.mongodb_db, false);
        await Config.db.connect(null);
        this.rootToken = Crypt.rootToken();
        this.testUser = await Logger.DBHelper.FindByUsername("testuser", this.rootToken, null)
        this.userToken = Crypt.createToken(this.testUser, Config.shorttoken_expires_in);
    }
    async after() {
        await Logger.shutdown();
    }
    @test async 'FindByUsername'() {
        var user = await Logger.DBHelper.FindByUsername("testuser", this.rootToken, null);
        assert.notStrictEqual(user, null, "Failed locating test user as root")
        user = await Logger.DBHelper.FindByUsername("testuser", this.userToken, null);
        assert.notStrictEqual(user, null, "Failed locating test user as self")
        user = await Logger.DBHelper.FindByUsername(null, this.rootToken, null);
        assert.strictEqual(user, null, "Returned user with null as username")
        // await assert.rejects(DBHelper.FindByUsername(null, this.rootToken, null));
    }
    @test async 'FindById'() {
        var user = await Logger.DBHelper.FindById(this.testUser._id, this.rootToken, null);
        assert.notStrictEqual(user, null, "Failed locating test user as root")
        user = await Logger.DBHelper.FindById(this.testUser._id, this.userToken, null);
        assert.notStrictEqual(user, null, "Failed locating test user as self")
        user = await Logger.DBHelper.FindById("nonexisting", this.userToken, null);
        assert.strictEqual(user, null, "returned something with illegal id")
        user = await Logger.DBHelper.FindById(null, this.rootToken, null);
        assert.strictEqual(user, null, "Returned user with null as id")
        // await assert.rejects(DBHelper.FindById(null, this.rootToken, null));
    }
    @test async 'FindByUsernameOrFederationid'() {
        var user = await Logger.DBHelper.FindByUsernameOrFederationid(this.testUser.username, null, null);
        assert.notStrictEqual(user, null, "Failed locating user by username")
        user = await Logger.DBHelper.FindByUsernameOrFederationid("test@federation.id", 'google', null);
        assert.notStrictEqual(user, null, "Failed locating user by federation id")
        user = await Logger.DBHelper.FindByUsernameOrFederationid(null, null, null)
        assert.strictEqual(user, null, "Returned user with null as username and Federationid")
        // await assert.rejects(DBHelper.FindByUsernameOrFederationid(null, null));
    }
    @test async 'DecorateWithRoles'() {
        var tuser = TokenUser.From(this.testUser);
        tuser.roles = [];
        tuser = await Logger.DBHelper.DecorateWithRoles(tuser, null);
        assert.notStrictEqual(tuser.roles.length, 0, "No roles added to user")
        Config.decorate_roles_fetching_all_roles = !Config.decorate_roles_fetching_all_roles;
        tuser.roles = [];
        tuser = await Logger.DBHelper.DecorateWithRoles(tuser, null);
        assert.notStrictEqual(tuser.roles.length, 0, "No roles added to user")
        tuser = await Logger.DBHelper.DecorateWithRoles(null, null)
        assert.strictEqual(tuser, null, "DecorateWithRoles Returned user with null argument")
        // await assert.rejects(DBHelper.DecorateWithRoles(null, null));
    }
    @test async 'FindRoleByName'() {
        var role = await Logger.DBHelper.FindRoleByName(this.testUser.username, null, null);
        assert.strictEqual(role, null, "returned something with illegal name")
        role = await Logger.DBHelper.FindRoleByName("users", null, null);
        assert.notStrictEqual(role, null, "Failed locating role users")
    }
    @test async 'FindRoleByNameOrId'() {
        var role = await Logger.DBHelper.FindRoleByName(this.testUser.username, null, null);
        assert.strictEqual(role, null, "returned something with illegal name")
        role = await Logger.DBHelper.FindRoleByName("users", null, null);
        assert.notStrictEqual(role, null, "Failed locating role users")
        role = await Logger.DBHelper.FindRoleById(WellknownIds.users, null, null);
        assert.notStrictEqual(role, null, "Failed locating role users")
        role = await Logger.DBHelper.FindRoleByName(null, null, null);
        assert.strictEqual(role, null, "Returned role with null as username")
        role = await Logger.DBHelper.FindRoleById(null, null, null);
        assert.strictEqual(role, null, "Returned userrole with null as id")

        // await assert.rejects(DBHelper.FindRoleByName(null, null));
        // await assert.rejects(DBHelper.FindRoleById(null, null, null));
    }
    @timeout(5000)
    @test async 'EnsureUser'() {
        var name = "dummytestuser" + NoderedUtil.GetUniqueIdentifier();
        let extraoptions = {
            federationids: [new FederationId("test@federation.id", 'google')],
            emailvalidated: true,
            formvalidated: true,
            validated: true
        }
        var dummyuser: User = await Logger.DBHelper.EnsureUser(this.rootToken, name, name, null, "RandomPassword", extraoptions, null);
        var result = await Crypt.ValidatePassword(dummyuser, "RandomPassword", null);

        await Logger.DBHelper.EnsureNoderedRoles(dummyuser, this.rootToken, true, null);

        dummyuser = await Logger.DBHelper.DecorateWithRoles(dummyuser, null);
        assert.ok(dummyuser.roles.filter(x => x.name.endsWith("noderedadmins")), "EnsureNoderedRoles did not make dummy user member of noderedadmins");
        assert.ok(dummyuser.roles.filter(x => x.name.endsWith("nodered api users")), "EnsureNoderedRoles did not make dummy user member of nodered api users");


        assert.ok(result, "Failed validating with the correct password");
        await Config.db.DeleteOne(dummyuser._id, "users", this.rootToken, null);

        await assert.rejects(Logger.DBHelper.EnsureUser(this.rootToken, null, null, null, null, null, null));
    }
    @test async 'EnsureRole'() {
        var name = "dummytestrole" + NoderedUtil.GetUniqueIdentifier();
        var dummyrole = await Logger.DBHelper.EnsureRole(this.rootToken, name, null, null);
        await Config.db.DeleteOne(dummyrole._id, "users", this.rootToken, null);
        await assert.rejects(Logger.DBHelper.EnsureRole(null, null, null, null));
    }
}
// cls | ./node_modules/.bin/_mocha 'test/**/DBHelper.test.ts'