first commit: mongo db,express and user tests

.env

+MONGO_URI=mongodb+srv://admin-h:pass99data@cluster0.nv2rd.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0
+PORT=3000
\ No newline at end of file

.gitignore

+/node_modules

models/User.js

+// const mongoose = require("mongoose");
+
+// const UserSchema = new mongoose.Schema({
+//     name: { type: String, required: true },
+//     email: { type: String, required: true, unique: true },
+//     age: { type: Number },
+// });
+
+// module.exports = mongoose.model("User", UserSchema);
+
+const mongoose = require("mongoose");
+
+const UserSchema = new mongoose.Schema({
+  name: String,
+  email: String,
+  age: Number,
+});
+
+// Prevents overwriting the model when tests run multiple times
+const User = mongoose.models.User || mongoose.model("User", UserSchema);
+
+module.exports = User;
+

package.json

+{
+  "name": "express-mongo-testing",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2",
+    "mongodb": "^6.14.0",
+    "mongoose": "^8.11.0",
+    "morgan": "^1.10.0",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "supertest": "^7.0.0"
+  }
+}

routes/userRoutes.js

+const express = require("express");
+const User = require("../models/User");
+
+const router = express.Router();
+
+// Create User
+router.post("/", async (req, res) => {
+    try {
+        const user = new User(req.body);
+        await user.save();
+        res.status(201).json(user);
+    } catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+
+// Update User
+router.put("/:id", async (req, res) => {
+    try {
+        const user = await User.findByIdAndUpdate(req.params.id, req.body, { new: true });
+        if (!user) return res.status(404).json({ message: "User not found" });
+        res.json(user);
+    } catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+
+// Get Users List
+router.get("/", async (req, res) => {
+    try {
+        const users = await User.find();
+        res.json(users);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+module.exports = router;

server.js

+// const express = require("express");
+// const mongoose = require("mongoose");
+// const dotenv = require("dotenv");
+// const morgan = require("morgan");
+
+// // Load environment variables
+// dotenv.config();
+
+// const app = express();
+// const PORT = process.env.PORT || 3000;
+
+// // Middleware
+// app.use(express.json()); // Parse JSON request body
+// app.use(morgan("dev")); // Logging middleware
+
+// // Connect to MongoDB Atlas
+// mongoose
+//   .connect(process.env.MONGO_URI, {
+//     useNewUrlParser: true,
+//     useUnifiedTopology: true,
+//   })
+//   .then(() => console.log("MongoDB Connected Successfully!"))
+//   .catch((err) => console.error("MongoDB Connection Error:", err));
+
+// // User Schema & Model
+// const userSchema = new mongoose.Schema({
+//   name: String,
+//   email: String,
+//   age: Number,
+// });
+// const User = mongoose.model("User", userSchema);
+
+// // Routes
+
+// // Create a new user (POST)
+// app.post("/users", async (req, res) => {
+//   try {
+//     const newUser = new User(req.body);
+//     await newUser.save();
+//     res.status(201).json(newUser);
+//   } catch (err) {
+//     res.status(500).json({ error: err.message });
+//   }
+// });
+
+// // Get all users (GET)
+// app.get("/users", async (req, res) => {
+//   try {
+//     const users = await User.find();
+//     res.json(users);
+//   } catch (err) {
+//     res.status(500).json({ error: err.message });
+//   }
+// });
+
+// // Update a user (PUT)
+// app.put("/users/:id", async (req, res) => {
+//   try {
+//     const updatedUser = await User.findByIdAndUpdate(req.params.id, req.body, {
+//       new: true,
+//     });
+//     res.json(updatedUser);
+//   } catch (err) {
+//     res.status(500).json({ error: err.message });
+//   }
+// });
+
+// // Start the server
+// app.listen(PORT, () => {
+//   console.log(`Server running on http://localhost:${PORT}`);
+// });
+
+
+const express = require("express");
+const mongoose = require("mongoose");
+const dotenv = require("dotenv");
+const morgan = require("morgan");
+
+// Load environment variables
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// Middleware
+app.use(express.json()); // Parse JSON request body
+app.use(morgan("dev")); // Logging middleware
+
+// Connect to MongoDB Atlas
+mongoose
+  .connect(process.env.MONGO_URI, {
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
+  })
+  .then(() => console.log("MongoDB Connected Successfully!"))
+  .catch((err) => console.error("MongoDB Connection Error:", err));
+
+// User Schema & Model
+const userSchema = new mongoose.Schema({
+  name: String,
+  email: String,
+  age: Number,
+});
+const User = mongoose.model("User", userSchema);
+
+// Routes
+
+// Create a new user (POST)
+app.post("/users", async (req, res) => {
+  try {
+    const newUser = new User(req.body);
+    await newUser.save();
+    res.status(201).json(newUser);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Get all users (GET)
+app.get("/users", async (req, res) => {
+  try {
+    const users = await User.find();
+    res.json(users);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Update a user (PUT)
+app.put("/users/:id", async (req, res) => {
+  try {
+    const updatedUser = await User.findByIdAndUpdate(req.params.id, req.body, {
+      new: true,
+    });
+    res.json(updatedUser);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Start the server and export it for testing
+const server = app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});
+
+// Export both app and server for testing
+module.exports = { app, server };
+

tests/user.test.js

+// const request = require("supertest");
+// const app = require("../server"); // Import your Express server
+// const mongoose = require("mongoose");
+
+// // Sample user data
+// const userData = { name: "Rahul", email: "Rahul@example.com", age: 25 };
+
+// describe("User API Tests", () => {
+//   // Close the DB connection after tests
+//   afterAll(async () => {
+//     await mongoose.connection.close();
+//   });
+
+//   // Test: Create a new user
+//   it("should create a new user", async () => {
+//     const res = await request(app).post("/users").send(userData);
+//     expect(res.status).toBe(201);
+//     expect(res.body).toHaveProperty("_id");
+//     expect(res.body.name).toBe(userData.name);
+//   });
+
+//   // Test: Get all users
+//   it("should return a list of users", async () => {
+//     const res = await request(app).get("/users");
+//     expect(res.status).toBe(200);
+//     expect(res.body).toBeInstanceOf(Array);
+//   });
+
+//   // Test: Update a user
+//   it("should update a user", async () => {
+//     const newUser = await request(app).post("/users").send(userData);
+//     const userId = newUser.body._id;
+
+//     const updatedData = { name: "Rahul", age: 30 };
+//     const res = await request(app).put(`/users/${userId}`).send(updatedData);
+
+//     expect(res.status).toBe(200);
+//     expect(res.body.name).toBe(updatedData.name);
+//   });
+// });
+
+
+// const request = require("supertest");
+// const mongoose = require("mongoose");
+// const app = require("../server");
+// require("dotenv").config(); // Load env variables
+// const User = require("../models/User"); // Ensure path is correct
+
+// describe("User API Tests", () => {
+//   beforeAll(async () => {
+//     await mongoose.connect(process.env.MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true });
+//   });
+
+//   beforeEach(async () => {
+//     await User.deleteMany({}); // Clear database before each test
+//   });
+
+//   afterAll(async () => {
+//     await mongoose.connection.close();
+//   });
+
+//   it("should create a new user", async () => {
+//     const res = await request(app).post("/users").send({ name: "John Doe", email: "john@example.com", age: 25 });
+//     expect(res.status).toBe(201);
+//     expect(res.body).toHaveProperty("_id");
+//   });
+
+//   it("should return a list of users", async () => {
+//     await request(app).post("/users").send({ name: "Alice", email: "alice@example.com", age: 22 });
+
+//     const res = await request(app).get("/users");
+//     expect(res.status).toBe(200);
+//     expect(res.body.length).toBeGreaterThan(0);
+//   });
+
+//   it("should update a user", async () => {
+//     const newUser = await request(app).post("/users").send({ name: "John Doe", email: "john@example.com", age: 25 });
+//     const userId = newUser.body._id;
+
+//     const res = await request(app).put(`/users/${userId}`).send({ name: "Jane Doe", age: 30 });
+
+//     expect(res.status).toBe(200);
+//     expect(res.body.name).toBe("Jane Doe");
+//   });
+// });
+
+const request = require("supertest");
+const mongoose = require("mongoose");
+const { app, server } = require("../server"); // Import the server instance
+require("dotenv").config();
+const User = require("../models/User");
+
+describe("User API Tests", () => {
+  beforeAll(async () => {
+    await mongoose.connect(process.env.MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true });
+  });
+
+  beforeEach(async () => {
+    await User.deleteMany({});
+  });
+
+  afterAll(async () => {
+    await mongoose.connection.close();
+    server.close(); // Properly close the server after tests
+  });
+
+  it("should create a new user", async () => {
+    const res = await request(app).post("/users").send({ name: "John Doe", email: "john@example.com", age: 25 });
+    expect(res.status).toBe(201);
+    expect(res.body).toHaveProperty("_id");
+  });
+
+  it("should return a list of users", async () => {
+    await request(app).post("/users").send({ name: "Alice", email: "alice@example.com", age: 22 });
+
+    const res = await request(app).get("/users");
+    expect(res.status).toBe(200);
+    expect(res.body.length).toBeGreaterThan(0);
+  });
+
+  it("should update a user", async () => {
+    const newUser = await request(app).post("/users").send({ name: "John Doe", email: "john@example.com", age: 25 });
+    const userId = newUser.body._id;
+
+    const res = await request(app).put(`/users/${userId}`).send({ name: "Jane Doe", age: 30 });
+
+    expect(res.status).toBe(200);
+    expect(res.body.name).toBe("Jane Doe");
+  });
+});
+
+