universal_bot-ts

1
import {mmApp, UsersData, isFile, unlink} from '../../src';
2

3
interface IData {
4
    userId?: string;
5
    meta?: string;
6
    data?: any;
7
}
8

9
const FILE_NAME = 'UsersData.json';
10

11
describe('Db file connect', () => {
12
    let data: any;
13
    const userData = new UsersData();
14

15
    beforeEach(() => {
16
        mmApp.params.utm_text = '';
17
        mmApp.config.json = __dirname;
18
        data = {
19
            userId1: {
20
                userId: 'userId1',
21
                meta: 'user meta 1',
22
                data: {
23
                    name: 'user 1'
24
                }
25
            },
26
            userId2: {
27
                userId: 'userId2',
28
                meta: 'user meta 2',
29
                data: {
30
                    name: 'user 2'
31
                }
32
            },
33
            userId3: {
34
                userId: 'userId3',
35
                meta: 'user meta 3',
36
                data: {
37
                    name: 'user 3'
38
                }
39
            },
40
            userId13: {
41
                userId: 'userId3',
42
                meta: 'user meta 1',
43
                data: {
44
                    name: 'user 3'
45
                }
46
            }
47
        };
48
        mmApp.saveJson(FILE_NAME, data);
49
    });
50

51
    it('Where string', async () => {
52
        let query = '`userId`="userId1"';
53
        let uData = (await userData.where(query)).data;
54
        expect(uData.length === 1).toBe(true);
55
        expect(uData[0]).toEqual(data.userId1);
56

57
        query = '`userId`="userId3" AND `meta`="user meta 1"';
58
        uData = (await userData.where(query)).data;
59
        expect(uData.length === 1).toBe(true);
60
        expect(uData[0]).toEqual(data.userId13);
61

62
        query = '`meta`="user meta 1"';
63
        uData = (await userData.where(query)).data;
64
        expect(uData.length === 2).toBe(true);
65
        expect(uData[0]).toEqual(data.userId1);
66
        expect(uData[1]).toEqual(data.userId13);
67

68
        query = '`userId`="NotFound"';
69
        expect((await userData.where(query)).status).toBe(false);
70
    });
71
    it('Where object', async () => {
72
        let query: IData = {
73
            userId: 'userId1'
74
        };
75
        let uData = (await userData.where(query)).data;
76
        expect(uData.length === 1).toBe(true);
77
        expect(uData[0]).toEqual(data.userId1);
78

79
        query = {
80
            userId: 'userId3',
81
            meta: 'user meta 1'
82
        };
83
        uData = (await userData.where(query)).data;
84
        expect(uData.length === 1).toBe(true);
85
        expect(uData[0]).toEqual(data.userId13);
86

87
        query = {
88
            meta: 'user meta 1'
89
        };
90
        uData = (await userData.where(query)).data;
91
        expect(uData.length === 2).toBe(true);
92
        expect(uData[0]).toEqual(data.userId1);
93
        expect(uData[1]).toEqual(data.userId13);
94

95
        query = {
96
            userId: 'NotFound'
97
        };
98
        expect((await userData.where(query)).status === false).toBe(true);
99
    });
100

101
    it('Where one', async () => {
102
        let query = '`userId`="userId1"';
103
        expect(await userData.whereOne(query)).toBe(true);
104
        expect(userData.data).toEqual(data.userId1.data);
105

106
        query = '`userId`="userId3" AND `meta`="user meta 1"';
107
        expect(await userData.whereOne(query)).toBe(true);
108
        expect(userData.data).toEqual(data.userId13.data);
109

110
        query = '`userId`="NotFound"';
111
        expect(await userData.whereOne(query)).toBe(false);
112
    });
113
    it('Where one Object', async () => {
114
        let query: IData = {
115
            userId: 'userId1'
116
        };
117
        expect(await userData.whereOne(query)).toBe(true);
118
        expect(userData.data).toEqual(data.userId1.data);
119

120
        query = {
121
            userId: 'userId3',
122
            meta: 'user meta 1'
123
        };
124
        expect(await userData.whereOne(query)).toBe(true);
125
        expect(userData.data).toEqual(data.userId13.data);
126

127
        query = {
128
            userId: 'NotFound'
129
        };
130
        expect(await userData.whereOne(query)).toBe(false);
131
    });
132

133
    it('Delete data', async () => {
134
        let query = '`userId`="userId1"';
135
        userData.userId = 'userId1';
136
        expect(await userData.remove()).toBe(true);
137

138
        expect(await userData.whereOne(query)).toBe(false);
139
    });
140

141
    it('Update data', async () => {
142
        let query = '`meta`="meta"';
143
        expect(await userData.whereOne(query)).toBe(false);
144
        userData.userId = 'userId1';
145
        userData.meta = 'meta';
146
        expect(await userData.update()).toBe(true);
147

148
        expect(await userData.whereOne(query)).toBe(true);
149
    });
150

151
    it('Save data', async () => {
152
        let query = '`meta`="meta"';
153
        expect(await userData.whereOne(query)).toBe(false);
154
        userData.userId = 'userId5';
155
        userData.meta = 'meta';
156
        userData.data = {name: 'user 5'};
157
        expect(await userData.save()).toBe(true);
158

159
        expect(await userData.whereOne(query)).toBe(true);
160
        expect(userData.userId === 'userId5').toBe(true);
161
        expect(userData.data).toEqual({name: 'user 5'});
162
    });
163

164
    it('Delete file db', () => {
165
        expect(isFile(__dirname + '/' + FILE_NAME)).toBe(true);
166
        unlink(__dirname + '/' + FILE_NAME);
167
        expect(isFile(__dirname + '/' + FILE_NAME)).toBe(false);
168
    })
169
});
170

171
describe('Db is MongoDb', () => {
172
    let isConnected: boolean = true;
173
    beforeEach(() => {
174
        mmApp.setIsSaveDb(true);
175
        mmApp.setConfig({
176
            db: {
177
                host: 'mongodb://127.0.0.1:27017/',
178
                database: 'test'
179
            }
180
        });
181
    });
182
    it('MongoDb Save data', async () => {
183
        if (isConnected) {
184
            const usersData = new UsersData();
185
            if (await usersData.isConnected()) {
186
                usersData.userId = 'test';
187
                usersData.type = UsersData.T_ALISA;
188
                usersData.data = {};
189
                usersData.meta = {};
190
                expect(await usersData.save()).toBe(true);
191
                expect(await usersData.whereOne({userId: 'test'})).toBe(true);
192
                usersData.destroy();
193
            } else {
194
                isConnected = false;
195
            }
196
            mmApp.setIsSaveDb(false);
197
        }
198
    });
199
    it('MongoDb Update data', async () => {
200
        if (isConnected) {
201
            const usersData = new UsersData();
202
            if (await usersData.isConnected()) {
203
                usersData.userId = 'test';
204
                usersData.type = UsersData.T_ALISA;
205
                usersData.data = 'data';
206
                usersData.meta = {};
207
                expect(await usersData.save()).toBe(true);
208
                expect(await usersData.whereOne({data: 'data'})).toBe(true);
209
                usersData.destroy();
210
            } else {
211
                isConnected = false;
212
            }
213
            mmApp.setIsSaveDb(false);
214
        }
215
    });
216
    it('MongoDb Remove data', async () => {
217
        if (isConnected) {
218
            const usersData = new UsersData();
219
            if (await usersData.isConnected()) {
220
                usersData.userId = 'test';
221
                usersData.type = UsersData.T_ALISA;
222
                usersData.data = 'data';
223
                usersData.meta = {};
224
                expect(await usersData.remove()).toBe(true);
225
                expect(await usersData.whereOne({userId: 'test'})).toBe(false);
226
                usersData.destroy();
227
            } else {
228
                isConnected = false;
229
            }
230
            mmApp.setIsSaveDb(false);
231
        }
232
    });
233
});
234