@justair/justair-library 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justair/justair-library",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "JustAir Internal Library",
   "main": "index.js",
   "type": "module",

package/src/models/tests/admin.test.js

@@ -0,0 +1,42 @@
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Admin from '../admins.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+  const mongoUri = mongoServer.getUri();
+  mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create admin and fetch it from the database', async () => {
+  const adminData = {
+    name: 'John Doe',
+    phone: '1234567890',
+    email: 'john@example.com',
+    password: 'password123',
+    orgId: mongoose.Types.ObjectId(), // Generate a new ObjectId for orgId
+  };
+
+  // Create a new admin document
+  const createdAdmin = await Admin.create(adminData);
+
+  // Fetch the admin from the database
+  const fetchedAdmin = await Admin.findById(createdAdmin._id);
+
+  expect(fetchedAdmin).toMatchObject(adminData);
+});

package/src/models/tests/configurations.test.js

@@ -0,0 +1,44 @@
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Configurations from '../configurations.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create configuration and fetch it from the database', async () => {
+  const configurationData = {
+    type: 'flag',
+    name: 'FeatureA',
+    properties: {
+      enabled: true,
+      percentage: 50,
+    },
+    isActive: true,
+  };
+
+  // Create a new configuration document
+  const createdConfiguration = await Configurations.create(configurationData);
+
+  // Fetch the configuration from the database
+  const fetchedConfiguration = await Configurations.findById(createdConfiguration._id);
+
+  expect(fetchedConfiguration).toMatchObject(configurationData);
+});

package/src/models/tests/measurements.test.js

@@ -0,0 +1,46 @@
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Measurements from '../measurements.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create measurement and fetch it from the database', async () => {
+  const measurementData = {
+    monitorId: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorId
+    orgId: mongoose.Types.ObjectId(), // Generate a new ObjectId for orgId
+    timeUpdated: new Date(),
+    measurements: {
+      temperature: 25,
+      humidity: 60,
+    },
+    alert: 'Good',
+    alertMessage: 'High temperature detected',
+  };
+
+  // Create a new measurement document
+  const createdMeasurement = await Measurements.create(measurementData);
+
+  // Fetch the measurement from the database
+  const fetchedMeasurement = await Measurements.findById(createdMeasurement._id);
+
+  expect(fetchedMeasurement).toMatchObject(measurementData);
+});

package/src/models/tests/monitorRequests.test.js

@@ -0,0 +1,46 @@
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import MonitorRequests from '../monitorRequests.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create monitor request and fetch it from the database', async () => {
+  const monitorRequestData = {
+    monitorOwnerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorOwnerOrg
+    monitorOwnerOrgName: 'Organization A',
+    monitorSharerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorSharerOrg
+    monitorSharerOrgName: 'Organization B',
+    monitorList: [
+      mongoose.Types.ObjectId(), // Generate a new ObjectId for each monitor in the list
+      mongoose.Types.ObjectId(),
+    ],
+    status: 'Requested',
+  };
+
+  // Create a new monitor request document
+  const createdMonitorRequest = await MonitorRequests.create(monitorRequestData);
+
+  // Fetch the monitor request from the database
+  const fetchedMonitorRequest = await MonitorRequests.findById(createdMonitorRequest._id);
+
+  expect(fetchedMonitorRequest).toMatchObject(monitorRequestData);
+});

package/src/models/tests/monitors.test.js

@@ -0,0 +1,62 @@
+import { Decimal128 } from 'bson';
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Monitors from '../monitors.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create monitor and fetch it from the database', async () => {
+  const monitorData = {
+    monitorCode: 'ABC123',
+    monitorSupplier: 'clarity',
+    monitorIdFromSupplier: '123456',
+    measurementUpdate: new Date(),
+    monitorProperties: {
+      property1: 'value1',
+      property2: 'value2',
+    },
+    isPrivate: false,
+    monitorState: 'Collocation',
+    sponsor: mongoose.Types.ObjectId(), // Generate a new ObjectId for sponsor
+    sponsorName: 'Organization A',
+    monitorLatitude: 37.7749,
+    monitorLongitude: -122.4194,
+    location: {
+      city: 'San Francisco',
+      country: 'United States',
+    },
+    context: ['School'],
+    colocationDate: new Date(),
+    parameters: ['NO2', 'PM2.5', 'Temperature'],
+    latestPM2_5: Decimal128.fromString('10.5'), // Use Decimal128 for decimal values
+    latestAQI_PM2_5: 75,
+    isActive: true,
+  };
+
+  // Create a new monitor document
+  const createdMonitor = await Monitors.create(monitorData);
+
+  // Fetch the monitor from the database
+  const fetchedMonitor = await Monitors.findById(createdMonitor._id);
+
+  expect(fetchedMonitor).toMatchObject(monitorData);
+});

package/src/models/tests/organizations.test.js

@@ -0,0 +1,51 @@
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Organizations from '../organizations.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create organization and fetch it from the database', async () => {
+  const organizationData = {
+    name: 'Acme Corp',
+    website: 'https://www.example.com',
+    location: {
+      city: 'San Francisco',
+      country: 'United States',
+    },
+    authorized: false,
+    orgAPIKey: [{ key: 'ABC123' }],
+    orgCode: 'ACME123',
+    orgDescription: 'A sample organization',
+    orgLogo: 'https://www.example.com/logo.png',
+    connectedMonitors: [mongoose.Types.ObjectId()], // Generate a new ObjectId for each connected monitor
+    communityMessages: [{ message: 'Welcome to our community!' }],
+    isActive: true,
+  };
+
+  // Create a new organization document
+  const createdOrganization = await Organizations.create(organizationData);
+
+  // Fetch the organization from the database
+  const fetchedOrganization = await Organizations.findById(createdOrganization._id);
+
+  expect(fetchedOrganization).toMatchObject(organizationData);
+});

package/src/models/tests/users.test.js

@@ -0,0 +1,54 @@
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Users from '../users.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create user and fetch it from the database', async () => {
+  const userData = {
+    name: 'John Doe',
+    phone: '1234567890',
+    email: 'john.doe@example.com',
+    zipCode: '12345',
+    location: {
+      city: 'San Francisco',
+      country: 'United States',
+    },
+    organizations: [mongoose.Types.ObjectId()], // Generate a new ObjectId for each organization
+    alertPhone: '9876543210',
+    alertCount: 0,
+    subscribedMonitors: [mongoose.Types.ObjectId()], // Generate a new ObjectId for each subscribed monitor
+    currentAlertMode: 'Good',
+    latestAlerts: [{ message: 'Alert 1' }],
+    optInPhone: true,
+    optInEmail: true,
+    isActive: true,
+  };
+
+  // Create a new user document
+  const createdUser = await Users.create(userData);
+
+  // Fetch the user from the database
+  const fetchedUser = await Users.findById(createdUser._id);
+
+  expect(fetchedUser).toMatchObject(userData);
+});