Skip to content

Commit b2def34

Browse files
edwinlnyedwinlny
authored
Merge pull request #5 from HEET-Group/eisha/testing
Eisha/testing
2 parents 26059fe + 7ff9034 commit b2def34

File tree

8 files changed

+594
-23
lines changed

8 files changed

+594
-23
lines changed

‎__backend-tests__/controllers/alert.test.js

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
// const mongoose = require('mongoose');
2+
// const alert = require('../../chronos_npm_package/controllers/alert');
3+
// const axios = require('axios');
4+
// const MockAdapter = require('axios-mock-adapter');
5+
6+
// const mockAxios = new MockAdapter(axios);
7+
8+
// const consoleLogSpy = jest.spyOn(console, 'log');
9+
// jest.spyOn(console, 'error').mockImplementation(() => {});
10+
// // jest.mock('axios', () => {
11+
// // return {
12+
// // post: jest.fn(),
13+
// // };
14+
// // });
15+
16+
17+
18+
// describe('alert.sendSlack', () => {
19+
// beforeEach(() => {
20+
// mockAxios.reset();
21+
// jest.clearAllMocks();
22+
// });
23+
24+
// test('should send Slack message with the correct data', async () => {
25+
// const code = 500;
26+
// const slackSettings = {
27+
// webhook: 'https://example.com/slack-webhook',
28+
// };
29+
// const message = 'Internal server error';
30+
// const expectedData = { text: `${code}, ${message}, ${Date.now()}` };
31+
// mockAxios.onPost(slackSettings.webhook).reply(200, 'Status Code >= 400...\nError message sent');
32+
// await alert.sendSlack(code, message, slackSettings);
33+
34+
// expect(axios.post).toHaveBeenCalledWith(slackSettings.webhook, expectedData, expect.any(Object));
35+
// expect(consoleLogSpy).toHaveBeenCalledWith('Status Code >= 400...\nError message sent');
36+
// });
37+
// });

‎__backend-tests__/controllers/mongo.test.js

Lines changed: 210 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,46 +1,239 @@
1-
//const mongoose = require('mongoose');
1+
const mongoose = require('mongoose');
22
const mongo = require('../../chronos_npm_package/controllers/mongo');
33
const ServicesModel = require('../../chronos_npm_package/models/ServicesModel');
4+
const CommunicationModel = require('../../chronos_npm_package/models/CommunicationModel');
5+
const { connectDB, dropDB, dropCollections } = require('./testdbsetup');
6+
const alert = require('../../chronos_npm_package/controllers/alert');
7+
const ContainerInfo = require('../../chronos_npm_package/models/ContainerInfo');
8+
49
require('dotenv').config();
510

6-
jest.mock('mongoose', () => {
7-
return {
8-
connect: jest.fn().mockResolvedValue(undefined),
9-
};
11+
const db = process.env.DB_URI;
12+
13+
beforeAll(async () => {
14+
await connectDB();
15+
});
16+
17+
afterAll(async () => {
18+
await dropDB();
1019
});
1120

1221
jest.spyOn(console, 'log').mockImplementation(() => {});
1322

23+
jest.mock('../../chronos_npm_package/controllers/alert');
24+
25+
jest.useFakeTimers();
26+
27+
jest.spyOn(global, 'setInterval');
28+
29+
jest.mock('../../chronos_npm_package/controllers/healthHelpers', () => {
30+
return [
31+
{
32+
time: Date.now(),
33+
metric: 'testMetric',
34+
value: 10,
35+
category: 'testCategory',
36+
},
37+
{
38+
time: Date.now(),
39+
metric: 'testMetric2',
40+
value: 12,
41+
category: 'testCategory2',
42+
},
43+
];
44+
});
45+
46+
jest.mock('../../chronos_npm_package/controllers/mongo', () => ({
47+
...jest.requireActual('../../chronos_npm_package/controllers/mongo'),
48+
addMetrics: jest.fn(),
49+
getSavedMetricsLength: jest.fn(),
50+
}));
51+
52+
const HealthModel = {
53+
insertMany: jest.fn(() => Promise.resolve()),
54+
};
55+
56+
const HealthModelFunc = jest.fn(() => HealthModel);
57+
1458
describe('mongo.connect', () => {
1559
beforeEach(() => {
1660
jest.clearAllMocks();
1761
});
62+
beforeEach(() => {
63+
jest.clearAllMocks();
64+
});
1865

1966
test('should connect to MongoDB database', async () => {
20-
const databaseURI = 'mongodb://localhost:27017/testdb';
21-
await mongo.connect({ databaseURI });
22-
expect(mongoose.connect).toHaveBeenCalledWith(databaseURI);
67+
await mongo.connect({ database: { URI: db } });
68+
69+
//expect(mongoose.connect).toHaveBeenCalledWith(db);
2370
expect(console.log).toHaveBeenCalledWith(
2471
expect.stringContaining('MongoDB database connected at')
2572
);
2673
});
2774

28-
test('should handle connection error', async () => {
29-
const errorMessage = 'Connection failed';
30-
const databaseURI = 'mongodb://localhost:27017/testdb';
75+
test('should handle connection errors', async () => {
76+
const testDb = 'test';
77+
await mongo.connect({ database: { URI: testDb } });
3178

32-
jest.spyOn(mongoose, 'connect').mockRejectedValueOnce(new Error(errorMessage));
33-
34-
await mongo.connect({ databaseURI });
35-
expect(mongoose.connect).toHaveBeenCalledWith(databaseURI);
36-
expect(console.log).toHaveBeenCalledWith(expect.stringContaining(errorMessage));
79+
expect(console.log).toHaveBeenCalledWith(
80+
expect.stringContaining('Error connecting to MongoDB:'),
81+
expect.any(String)
82+
);
3783
});
3884
});
3985

4086
describe('mongo.services', () => {
4187
beforeEach(() => {
4288
jest.clearAllMocks();
4389
});
90+
beforeEach(() => {
91+
jest.clearAllMocks();
92+
});
93+
94+
afterEach(async () => {
95+
await dropCollections();
96+
});
97+
98+
test('should create a new document', async () => {
99+
await mongo.services({ microservice: 'test2', interval: 'test2' });
100+
const savedService = await ServicesModel.findOne({ microservice: 'test2', interval: 'test2' });
101+
expect(savedService).toBeDefined(); // The document should be defined if it exists
102+
});
103+
});
104+
105+
describe('mongo.communications', () => {
106+
afterEach(async () => {
107+
await dropCollections();
108+
});
109+
110+
test('should record request cycle and save communication to the database', async () => {
111+
const req = {};
112+
const res = {
113+
statusCode: 200,
114+
statusMessage: 'OK',
115+
getHeaders: () => ({ 'x-correlation-id': 'correlation-id-123' }),
116+
on: jest.fn((event, callback) => {
117+
if (event === 'finish') {
118+
callback();
119+
}
120+
}),
121+
};
122+
const middleware = mongo.communications({ microservice: 'test3', slack: null, email: null });
123+
await middleware(req, res, () => {});
124+
const savedCommunication = await CommunicationModel.findOne({ microservice: 'test3' });
125+
expect(savedCommunication).toBeDefined(); // The document should be defined if it exists
126+
});
127+
128+
test('should send an alert', async () => {
129+
const req = {};
130+
const res = {
131+
statusCode: 400,
132+
statusMessage: 'Not Found',
133+
getHeaders: () => ({ 'x-correlation-id': 'correlation-id-123' }),
134+
on: jest.fn((event, callback) => {
135+
if (event === 'finish') {
136+
callback();
137+
}
138+
}),
139+
};
140+
const middleware = mongo.communications({
141+
microservice: 'test4',
142+
slack: 'slackTest',
143+
email: 'emailTest',
144+
});
145+
await middleware(req, res, () => {});
146+
expect(alert.sendSlack).toHaveBeenCalledTimes(1);
147+
expect(alert.sendEmail).toHaveBeenCalledTimes(1);
148+
expect(alert.sendSlack).toHaveBeenCalledWith(res.statusCode, res.statusMessage, 'slackTest');
149+
expect(alert.sendEmail).toHaveBeenCalledWith(res.statusCode, res.statusMessage, 'emailTest');
150+
});
151+
});
152+
153+
describe('mongo.health', () => {
154+
beforeEach(() => {
155+
jest.clearAllMocks();
156+
jest.useFakeTimers();
157+
});
44158

45-
test('should create a new document', async () => {});
159+
afterEach(() => {
160+
jest.clearAllTimers();
161+
});
162+
163+
test('should collect data after the set interval', async () => {
164+
await mongo.health({ microservice: 'mongo.health test', interval: 1000, mode: 'testMode' });
165+
jest.advanceTimersByTime(1000);
166+
expect(setInterval).toHaveBeenCalledWith(expect.any(Function), 1000);
167+
expect(collectHealthData).toHaveBeenCalled();
168+
});
169+
170+
test('should save metrics to database', async () => {
171+
const mockData = [
172+
{
173+
time: Date.now(),
174+
metric: 'testMetric',
175+
value: 10,
176+
category: 'testCategory',
177+
},
178+
{
179+
time: Date.now(),
180+
metric: 'testMetric2',
181+
value: 12,
182+
category: 'testCategory2',
183+
},
184+
];
185+
await mongo.health({ microservice: 'mongo.health test', interval: 1000, mode: 'testMode' });
186+
jest.advanceTimersByTime(1000);
187+
expect(collectHealthData).toHaveReturnedWith(mockData);
188+
expect(HealthModelFunc).toHaveBeenCalled();
189+
expect(HealthModel).toHaveBeenCalled();
190+
});
46191
});
192+
193+
describe('mongo.docker', () => {
194+
beforeEach(async () => {
195+
jest.clearAllMocks();
196+
jest.useFakeTimers();
197+
});
198+
199+
afterEach(async () => {
200+
await dropCollections();
201+
jest.clearAllTimers();
202+
});
203+
204+
test('should collect docker container information', async () => {
205+
const microservice = 'mongo.docker test';
206+
const mockContainerData = {
207+
containername: microservice,
208+
containerId: '234',
209+
platform: 'testPlatform',
210+
startime: Date.now(),
211+
};
212+
const mockReadDockerContainerData = {
213+
...mockContainerData,
214+
memoryusage: 234,
215+
memorylimit: 234,
216+
memorypercent: 32,
217+
cpupercent: 45,
218+
networkreceived: 345,
219+
networksent: 345,
220+
processcount: 343,
221+
restartcount: 12,
222+
time: Date.now(),
223+
};
224+
225+
jest.mock('../../chronos_npm_package/controllers/dockerHelper', () => ({
226+
getDockerContainer: jest.fn(() => Promise.resolve(mockContainerData)),
227+
readDockerContainer: jest.fn(() => Promise.resolve(mockReadDockerContainerData)),
228+
}));
229+
230+
await mongo.docker({ microservice: microservice, interval: 1000, mode: 'testMode' });
231+
expect(getDockerContainer).toHaveBeenCalledWith(microservice);
232+
jest.advanceTimersByTime(1000);
233+
expect(readDockerContainer).toHaveBeenCalledWith(mockContainerData);
234+
const savedContainerInfo = await ContainerInfo.findOne({ containername: microservice });
235+
expect(savedContainerInfo).toBeDefined();
236+
expect(savedContainerInfo).toMatchObject(mockReadDockerContainerData);
237+
});
238+
});
239+

‎__backend-tests__/jest.config.js

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,19 @@
11
module.exports = {
22
testEnvironment: 'node', // Use the Node.js environment for testing
3+
<<<<<<< HEAD
4+
roots: ['<rootDir>/controllers'], // Set the root directory for test files
5+
6+
testRegex: '(/tests/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$',
7+
8+
// Code coverage settings
9+
collectCoverage: true,
10+
coverageDirectory: 'coverage',
11+
12+
// Specify the test path patterns to ignore frontend tests
13+
testPathIgnorePatterns: ['/node_modules/', '/__tests__/'],
14+
};
15+
16+
=======
317
roots: ['<rootDir>'], // Set the root directory for test files (adjust this path to your test folder)
418

519
testRegex: '(/tests/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$',
@@ -11,3 +25,4 @@ module.exports = {
1125
// Specify the test path patterns to ignore (frontend tests)
1226
testPathIgnorePatterns: ['/node_modules/', '/__tests__/'],
1327
};
28+
>>>>>>> dev

‎__backend-tests__/mockdbsetup.js

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
const mongoose = require("mongoose");
2+
const { MongoMemoryServer } = require("mongodb-memory-server");
3+
4+
let mongo = null;
5+
6+
const connectDB = async () => {
7+
mongo = await MongoMemoryServer.create();
8+
const uri = mongo.getUri();
9+
10+
await mongoose.connect(uri, {
11+
useNewUrlParser: true,
12+
useUnifiedTopology: true,
13+
});
14+
};
15+
16+
const dropDB = async () => {
17+
if (mongo) {
18+
await mongoose.connection.dropDatabase();
19+
await mongoose.connection.close();
20+
await mongo.stop();
21+
}
22+
};
23+
24+
const dropCollections = async () => {
25+
if (mongo) {
26+
const collections = await mongoose.connection.db.collections();
27+
for (let collection of collections) {
28+
await collection.deleteMany();
29+
}
30+
}
31+
};
32+
33+
34+
module.exports = { connectDB, dropDB, dropCollections}

‎chronos_npm_package/controllers/mongo.js

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -133,7 +133,7 @@ mongo.health = async ({ microservice, interval, mode }) => {
133133
*/
134134
mongo.docker = ({ microservice, interval, mode }) => {
135135
// Create collection using name of microservice
136-
const containerInfo = ContainerInfoFunc(`${microservice}-containerinfo`);
136+
const containerInfo = ContainerInfoFunc(`${microservice}`);
137137
dockerHelper
138138
.getDockerContainer(microservice)
139139
.then(containerData => {
@@ -144,7 +144,7 @@ mongo.docker = ({ microservice, interval, mode }) => {
144144
return containerInfo.create(data);
145145
})
146146
.then(_ =>
147-
console.log(`Docker data recorded in MongoDB collection ${microservice}-containerinfo`)
147+
console.log(`Docker data recorded in MongoDB collection ${microservice}`)
148148
)
149149
.catch(err => {
150150
throw new Error(err);

‎electron/models/DockerModel.ts

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,6 @@ const DockerSchema = new Schema({
5454
});
5555

5656
const DockerModelFunc = (serviceName: any) =>
57-
mongoose.model<any>(`${serviceName}-containerinfos`, DockerSchema);
57+
mongoose.model<any>(`${serviceName}`, DockerSchema);
5858

5959
export default DockerModelFunc;

0 commit comments

Comments
 (0)