test.txt

import supertest from "supertest";
import { app, server, connectToDatabase } from "./index.test";
import { User } from "../Models/UserModel";
import bcrypt from "bcryptjs";

const request = supertest(app);
beforeAll(async () => {
  await connectToDatabase();
});

// Delete all data from the database
afterAll(async () => {
  await User.deleteMany({});
  server.close();
});

describe("User Signup", () => {
  // Test for createUser function
  it("creates a new user with valid data", async () => {
    // Test data
    const userData = {
      fullName: "John Doe",
      email: "johndoe@example.com",
      gender: "male",
      password: "password123",
      confirmPassword: "password123",
      userRole: "user",
    };

    // Make a request to create user
    const response = await request.post("/api/user/signup").send(userData);

    // Assertions
    expect(response.status).toBe(201);
    expect(response.body).toHaveProperty("token");
    expect(response.body).toHaveProperty("user");
    expect(response.body.message).toBe("User successfully added");
  });

  // Test for createUser function with invalid data
  it("returns 400 with error message for invalid user data", async () => {
    // Invalid test data
    const invalidUserData = {
      fullName: "John Doe",
      email: "invalidemail",
      gender: "male",
      password: "pass",
      confirmPassword: "pass",
    };

    // Make a request to create user with invalid data
    const response = await request
      .post("/api/user/signup")
      .send(invalidUserData);

    // Assertions
    expect(response.status).toBe(400);
    expect(response.text).toContain("must be a valid email");
  });

  // Test for createUser function with existing user
  it("returns 409 with error message for existing user", async () => {
    // Existing user test data
    const existingUserData = {
      fullName: "Existing User",
      email: "johndoe@example.com",
      gender: "female",
      password: "password123",
      confirmPassword: "password123",
    };

    // Make a request to create existing user
    const response = await request
      .post("/api/user/signup")
      .send(existingUserData);

    // Assertions
    expect(response.status).toBe(409);
    expect(response.body.message).toBe("This user already exists");
  });

  // Test for getAllUsers function
  it("gets all users", async () => {
    // Make a request to get all users
    const response = await request.get("/api/user/all");

    // Assertions
    expect(response.status).toBe(200);
    expect(response.body.data).toBeInstanceOf(Array);
  });

  // Test for getUserById function
  it("gets single user by ID", async () => {
    // Assuming there is a user created in the database already
    const existingUser = await User.findOne({});
    if (!existingUser) {
      throw new Error("No user found in the database");
    }

    // Make a request to get user by ID
    const response = await request.get(`/api/user/${existingUser._id}`);

    // Assertions
    expect(response.status).toBe(200);
    expect(response.body.data).toHaveProperty("fullName", existingUser.fullName);
    expect(response.body.data).toHaveProperty("email", existingUser.email);
    expect(response.body.data).toHaveProperty("gender", existingUser.gender);
    expect(response.body.data).toHaveProperty("userRole", existingUser.userRole);
  });

  // Test for updateUser function
  it("updates user data", async () => {
    // Assuming there is a user created in the database already
    const existingUser = await User.findOne({});
    if (!existingUser) {
      throw new Error("No user found in the database");
    }

    // Updated data
    const updatedData = {
      fullName: "Updated Name",
      email: "updatedemail@example.com",
      gender: "other",
      password: "newpassword123",
      confirmPassword: "newpassword123",
      userRole: "admin",
    };

    // Make a request to update user
    const response = await request
      .put(`/api/user/${existingUser._id}`)
      .send(updatedData);

    // Assertions
    expect(response.status).toBe(200);
    expect(response.body.data).toHaveProperty("fullName", updatedData.fullName);
    expect(response.body.data).toHaveProperty("email", updatedData.email);
    expect(response.body.data).toHaveProperty("gender", updatedData.gender);
    expect(response.body.data).toHaveProperty("userRole", updatedData.userRole);
  });

  // Test for deleteUser function
  it("deletes user", async () => {
    // Assuming there is a user created in the database already
    const existingUser = await User.findOne({});
    if (!existingUser) {
      throw new Error("No user found in the database");
    }

    // Make a request to delete user
    const response = await request.delete(`/api/user/${existingUser._id}`);

    // Assertions
    expect(response.status).toBe(204);

    // Verify if the user was actually deleted from the database
    const deletedUser = await User.findById(existingUser._id);
    expect(deletedUser).toBeNull();
  });

  // Test for loginUser function
  it("should log in a user", async () => {
    // Create a user first
    const userData = {
      fullName: "John Doe",
      email: "johndoe@example.com",
      gender: "male",
      password: "password123",
      confirmPassword: "password123",
      userRole: "user",
    };

    await request.post("/api/user/signup").send(userData);

    // Make a request to login
    const res = await request.post("/api/user/login").send({
      email: "johndoe@example.com",
      password: "password123"
    });

    // Assertions
    expect(res.status).toEqual(200); 
    expect(res.body).toHaveProperty("message", "Login successful");
    expect(res.body).toHaveProperty("token");
  });

  // Test for invalid credentials
  it("should return 401 for Invalid credentials", async () => {
    // Make a request with invalid password
    const res = await request.post("/api/user/login").send({
      email: "johndoe@example.com",
      password: "invalid"
    });

    // Assertions
    expect(res.status).toEqual(401);
    expect(res.body).toHaveProperty("message", "Invalid credentials");
  });

  // Test for email not found
  it("should return 404 when an email not found", async () => {
    // Make a request with non-existing email
    const res = await request.post("/api/user/login").send({
      email: "invalid@test.com",
      password: "password"
    });

    // Assertions
    expect(res.status).toEqual(404);
    expect(res.body).toHaveProperty("message", "User not found");
  });

  // Test for password does not match
  it("should return 404 when a password does not match", async () => {
    // Make a request with wrong password
    const res = await request.post("/api/user/login").send({
      email: "johndoe@example.com",
      password: "wrongpassword"
    });

    // Assertions
    expect(res.status).toEqual(401);
    expect(res.body).toHaveProperty("message", "Invalid credentials");
  });
});




import supertest from "supertest";
import { app, server, connectToDatabase } from "./index.test";
import { User } from "../Models/UserModel";
import bcrypt from "bcryptjs";
import { Blog } from "../Models/BlogModel";
const request = supertest(app);
import { Authorization } from "../Middlewares/Authorization";
import jwt from "jsonwebtoken";
import path from "path";
import fs from 'fs';
beforeAll(async () => {
  await connectToDatabase();
});

// Delete all data from the database
afterAll(async () => {
  await User.deleteMany({});
  await Blog.deleteMany({});

  server.close();
});
describe("User Signup", () => {


  it("creates a new user with valid data", async () => {
    const userData = {
      fullName: "John Doe",
      email: "johndoe@example.com",
      gender: "male",
      password: "password123",
      confirmPassword: "password123",
      userRole: "user",
    };

    const response = await request.post("/api/user/signup").send(userData);

    expect(response.status).toBe(201);
    expect(response.body).toHaveProperty("token");
    expect(response.body).toHaveProperty("user");
    expect(response.body.message).toBe("User successfully added");

    // Verify if the user was actually saved in the database
    const savedUser = await User.findOne({ email: userData.email });
    expect(savedUser).toBeDefined();
    expect(savedUser!.fullName).toBe(userData.fullName);
    expect(savedUser!.email).toBe(userData.email);
    expect(savedUser!.gender).toBe(userData.gender);
    expect(savedUser!.userRole).toBe(userData.userRole);

    // Verify password encryption
    const isPasswordValid = await bcrypt.compare(
      userData.password,
      savedUser!.password
    );
    expect(isPasswordValid).toBe(true);
  });

  it("returns 400 with error message for invalid user data", async () => {
    const invalidUserData = {
      fullName: "John Doe",
      email: "invalidemail",
      gender: "male",
      password: "pass",
      confirmPassword: "pass",
    };

    const response = await request
      .post("/api/user/signup")
      .send(invalidUserData);

    expect(response.status).toBe(400);
    expect(response.text).toContain("must be a valid email");
  });

  it("returns 409 with error message for existing user", async () => {
    const existingUserData = {
      fullName: "Existing User",
      email: "johndoe@example.com",
      gender: "female",
      password: "password123",
      confirmPassword: "password123",
    };

    const response = await request
      .post("/api/user/signup")
      .send(existingUserData);

    expect(response.status).toBe(409);
    expect(response.body.message).toBe("This user already exists");
  });

  // Test for getting all users
  it("gets all users", async () => {
    const response = await request.get("/api/user/all");

    expect(response.status).toBe(200);
    expect(response.body.data).toBeInstanceOf(Array);
  });

  // Test for getting single user by ID
  it("gets single user by ID", async () => {
    // Assuming there is a user created in the database already
    const existingUser = await User.findOne({});
    if (!existingUser) {
      throw new Error("No user found in the database");
    }

    const response = await request.get(`/api/user/${existingUser._id}`);

    expect(response.status).toBe(200);
    expect(response.body.data).toHaveProperty("fullName", existingUser.fullName);
    expect(response.body.data).toHaveProperty("email", existingUser.email);
    expect(response.body.data).toHaveProperty("gender", existingUser.gender);
    expect(response.body.data).toHaveProperty("userRole", existingUser.userRole);
  });

// Test for getting single user by ID when user is not found
it("returns 404 when user is not found", async () => {
  // Generate a random non-existing user ID
  const nonExistingUserId = "609df8e15715ab2374e0e29f";

  // Make a request to get user by non-existing ID
  const response = await request.get(`/api/user/${nonExistingUserId}`);

  // Assertions
  expect(response.status).toBe(404);
  expect(response.body).toHaveProperty("message", "User not found");
});
// Test for updating user
it("updates user data", async () => {
  // Assuming there is a user created in the database already
  const existingUser = await User.findOne({});
  if (!existingUser) {
    throw new Error("No user found in the database");
  }

  const updatedData = {
    fullName: "Updated Name",
    email: "updatedemail@example.com",
    gender: "other",
    password: "newpassword123",
    confirmPassword: "newpassword123",
    userRole: "admin",
  };

  const response = await request
    .put(`/api/user/${existingUser._id}`)
    .send(updatedData);

  expect(response.status).toBe(200);
  expect(response.body.data).toHaveProperty("fullName", updatedData.fullName);
  expect(response.body.data).toHaveProperty("email", updatedData.email);
  expect(response.body.data).toHaveProperty("gender", updatedData.gender);
  expect(response.body.data).toHaveProperty("userRole", updatedData.userRole);

  // Verify that no validation errors occur
  expect(response.body).not.toHaveProperty("error");

  // Verify that the user is found and updated successfully
  const updatedUser = await User.findById(existingUser._id);
  expect(updatedUser).toBeTruthy();
  expect(updatedUser!.fullName).toBe(updatedData.fullName);
  expect(updatedUser!.email).toBe(updatedData.email);
  expect(updatedUser!.gender).toBe(updatedData.gender);
  expect(updatedUser!.userRole).toBe(updatedData.userRole);
});

// Test for updating user with invalid data
it("returns 400 with error message for invalid user data during update", async () => {
  // Assuming there is a user created in the database already
  const existingUser = await User.findOne({});
  if (!existingUser) {
    throw new Error("No user found in the database");
  }

  const invalidData = {
    fullName: "", // invalid data
    email: "updatedemail@example.com",
    gender: "other",
    password: "newpassword123",
    confirmPassword: "newpassword123",
    userRole: "admin",
  };

  const response = await request
    .put(`/api/user/${existingUser._id}`)
    .send(invalidData);

  expect(response.status).toBe(400);
  expect(response.text).toContain("\"fullName\" is not allowed to be empty");

  // Verify that no user is updated with invalid data
  const userAfterUpdate = await User.findById(existingUser._id);
  expect(userAfterUpdate).toBeTruthy();
  expect(userAfterUpdate!.fullName).not.toBe("");
});

// Test for updating user that doesn't exist
it("returns 404 when updating non-existing user", async () => {
  // Generate a random non-existing user ID
  const nonExistingUserId = "609df8e15715ab2374e0e29f";

  const updatedData = {
    fullName: "Updated Name",
    email: "updatedemail@example.com",
    gender: "other",
    password: "newpassword123",
    confirmPassword: "newpassword123",
    userRole: "admin",
  };

  const response = await request
    .put(`/api/user/${nonExistingUserId}`)
    .send(updatedData);

  expect(response.status).toBe(404);
  expect(response.body).toHaveProperty("message", "User not found");
});

// it("returns 404 when user is not found", async () => {
//   // Generate a random non-existing user ID
//   const nonExistingUserId = "609df8e15715ab2374e0e29f";

//   // Make a request to get user by non-existing ID
//   const response = await request.get(`/api/user/${nonExistingUserId}`);

//   // Assertions
//   expect(response.status).toBe(404);
//   expect(response.body).toHaveProperty("message", "User not found");
// });

it("deletes user", async () => {
  // Assuming there is a user created in the database already
  const existingUser = await User.findOne({});
  if (!existingUser) {
    throw new Error("No user found in the database");
  }

  const response = await request.delete(`/api/user/${existingUser._id}`);

  expect(response.status).toBe(204);

  // Verify if the user was actually deleted from the database
  const deletedUser = await User.findById(existingUser._id);
  expect(deletedUser).toBeNull();
});

// Test for attempting to delete a user that doesn't exist
it("returns 404 when attempting to delete non-existing user", async () => {
  // Generate a random non-existing user ID
  const nonExistingUserId = "609df8e15715ab2374e0e29f";

  const response = await request.delete(`/api/user/${nonExistingUserId}`);

  expect(response.status).toBe(404);
  expect(response.body).toHaveProperty("message", "User not found");
});
    let token:string;
    // const existingUser = await User.findOne({ email: "johndoe@example.com" });
    it("should log in a user", async () => {
    // Create a user first
    const userData = {
      fullName: "John Doe",
      email: "johndoe@example.com",
      gender: "male",
      password: "password123",
      confirmPassword: "password123",
      userRole: "user",
    };

    await request.post("/api/user/signup").send(userData);

    const res = await request.post("/api/user/login").send({
      email: "johndoe@example.com",
      password: "password123"
    });
    console.log("Login Response:", res.body);
    expect(res.status).toEqual(200); 
    expect(res.body).toHaveProperty("message", "Login successful");
    expect(res.body).toHaveProperty("token");
  });
    
    
    it("should return 401 for Invalid credentials", async () => {
      const res = await request.post("/api/user/login").send({
        email: "johndoe@example.com",
        password: "invalid"
      });
      console.log("Invalid Credentials Response:", res.body);
      expect(res.status).toEqual(401);
      expect(res.body).toHaveProperty("message", "Invalid credentials");
    });
    
    it("should return 404 when an email not found", async () => {
      const res = await request.post("/api/user/login").send({
        email: "invalid@test.com",
        password: "password"
      });
      console.log("Email Not Found Response:", res.body);
      expect(res.status).toEqual(404);
      expect(res.body).toHaveProperty("message", "User not found");
    });
    
    it("should return 404 when a password does not match", async () => {
      const res = await request.post("/api/user/login").send({
        email: "johndoe@example.com",
        password: "wrongpassword"
      });
      console.log("Password Does Not Match Response:", res.body);
      expect(res.status).toEqual(401);
      expect(res.body).toHaveProperty("message", "Invalid credentials");
    });
    
    
  })
  
   describe("Blog API Testing", () => {
    let adminToken:string;
     let existingBlog: any;
    beforeAll(async () => {
       // Create an admin user
       const adminUser = new User({
         email: "admin@example.com",
         fullName: "Admin User",
         gender:"male",
         password: "admin123",
         userRole: "admin",
       });
       await adminUser.save();
   
       // Generate a JWT token for the admin user
       adminToken = jwt.sign({ id: adminUser._id }, process.env.JWT_SECRET || "", {
         expiresIn: "20h",
       });
       
  // Create an example blog
  existingBlog = new Blog({
    blogTitle: "Example Blog",
    blogDescription: "This is an example blog",
    blogDate: new Date().toISOString(),
    blogImage: "example.png",
  });
  await existingBlog.save();
    });
   
    it("should create a new blog with valid data when user is an admin", async () => {
       const blogData = {
         blogTitle: "Test Blog",
         blogDescription: "This is a test blog",
         blogDate: new Date().toISOString(),
         blogImage: "test.png",
       };
   
       // Ensure the file exists at the specified path
       const filePath = path.join(__dirname, "test.png");
       if (!fs.existsSync(filePath)) {
         throw new Error("Test file not found");
       }
   
       const response = await request
         .post("/api/blog/post-blog")
         .set("Authorization", `${adminToken}`)
         .field("blogTitle", blogData.blogTitle)
         .field("blogDescription", blogData.blogDescription)
         .field("blogDate", blogData.blogDate)
         .attach("blogImage", filePath);
   
       expect(response.status).toBe(201);
       expect(response.body).toHaveProperty("message", "Blog successfully created");
       expect(response.body).toHaveProperty("data");
       expect(response.body.data).toHaveProperty("blogTitle", blogData.blogTitle);
       expect(response.body.data).toHaveProperty("blogDescription", blogData.blogDescription);
       expect(response.body.data).toHaveProperty("blogDate", new Date(blogData.blogDate).toISOString());
       expect(response.body.data).toHaveProperty("blogImage", expect.stringContaining("https://res.cloudinary.com"));
                  // Find an existing blog in the database

       
    });


    // Test for updating a blog
    // it("should update a blog with valid data", async () => {
    //   const blogData = {
    //      blogTitle: "Updated Blog",
    //      blogDescription: "This is an updated blog",
    //      blogDate: new Date().toISOString(),
    //      blogImage: "updatedTest.png",
    //   };
     
    //   const filePath = path.join(__dirname, "updatedTest.jpg");
    //   if (!fs.existsSync(filePath)) {
    //      throw new Error("Test file not found");
    //   }
     
    //   const response = await request
    //      .put(`/api/blog/update-blog/${existingBlog._id}`)
    //      .set("Authorization", `${adminToken}`)
    //      .field("blogTitle", blogData.blogTitle)
    //      .field("blogDescription", blogData.blogDescription)
    //      .field("blogDate", blogData.blogDate)
    //      .attach("blogImage", filePath);
     
    //   expect(response.status).toBe(200);
    //   expect(response.body).toHaveProperty("message", "Blog successfully updated");
    //   expect(response.body).toHaveProperty("data");
    //   expect(response.body.data).toHaveProperty("blogTitle", blogData.blogTitle);
    //   expect(response.body.data).toHaveProperty("blogDescription", blogData.blogDescription);
    //   expect(response.body.data).toHaveProperty("blogDate", new Date(blogData.blogDate).toISOString());
    //   expect(response.body.data).toHaveProperty("blogImage", expect.stringContaining("https://res.cloudinary.com"));
    //  }, 30000); 
     // Increase timeout to 30 seconds
     
// Test for getting all blogs
it("should retrieve all blogs and return success", async () => {
  const response = await request.get("/api/blog/getall-blog");
  expect(response.status).toBe(200);
  expect(response.body).toHaveProperty("data");
  expect(response.body.data).toBeInstanceOf(Array);
});

// Test for getting a single blog by ID
it("should retrieve a single blog and return success", async () => {
  const response = await request.get(`/api/blog/getone-blog/${existingBlog._id}`);
  expect(response.status).toBe(200);
  expect(response.body).toHaveProperty("data");
  expect(response.body.data).toHaveProperty("blogTitle");
  expect(response.body.data).toHaveProperty("blogDescription");
  expect(response.body.data).toHaveProperty("blogDate");
  expect(response.body.data).toHaveProperty("blogImage");
});

it("should delete a blog and return success", async () => {
  const response = await request.delete(`/api/blog/delete-blog/${existingBlog._id}`)
     .set("Authorization", `${adminToken}`);
  expect(response.status).toBe(204);
 }, 30000); 
 
 it("should return 400 if blog data is invalid", async () => {
  const invalidBlogData = {
    blogTitle: "", // Invalid data
    blogDescription: "This is an invalid blog",
    blogDate: new Date().toISOString(),
    blogImage: "invalid.png",
  };

  const filePath = path.join(__dirname, "invalid.png");
  if (!fs.existsSync(filePath)) {
    throw new Error("Invalid file not found");
  }

  const response = await request
    .post("/api/blog/post-blog")
    .set("Authorization", `${adminToken}`)
    .field("blogTitle", invalidBlogData.blogTitle)
    .field("blogDescription", invalidBlogData.blogDescription)
    .field("blogDate", invalidBlogData.blogDate)
    .attach("blogImage", filePath);

  expect(response.status).toBe(400);
  expect(response.text).toContain("\"blogTitle\" is not allowed to be empty");
});

it("should return 400 if no file is uploaded", async () => {
  const blogData = {
    blogTitle: "Test Blog",
    blogDescription: "This is a test blog",
    blogDate: new Date().toISOString(),
    blogImage: "test.png",
  };

  const response = await request
    .post("/api/blog/post-blog")
    .set("Authorization", `${adminToken}`)
    .field("blogTitle", blogData.blogTitle)
    .field("blogDescription", blogData.blogDescription)
    .field("blogDate", blogData.blogDate);

  expect(response.status).toBe(400);
  expect(response.body).toHaveProperty("message", "Please upload a file");
});

// Error handling test
it("should return 500 for internal server error", async () => {
  jest.spyOn(console, "error").mockImplementation(() => {}); 
  jest.spyOn(Blog.prototype, "save").mockRejectedValue(new Error("Internal Server Error"));

  const blogData = {
    blogTitle: "Test Blog",
    blogDescription: "This is a test blog",
    blogDate: new Date().toISOString(),
    blogImage: "test.png",
  };

  const filePath = path.join(__dirname, "test.png");
  if (!fs.existsSync(filePath)) {
    throw new Error("Test file not found");
  }

  const response = await request
    .post("/api/blog/post-blog")
    .set("Authorization", `${adminToken}`)
    .field("blogTitle", blogData.blogTitle)
    .field("blogDescription", blogData.blogDescription)
    .field("blogDate", blogData.blogDate)
    .attach("blogImage", filePath);

  expect(response.status).toBe(500);
  expect(response.body).toHaveProperty("error", "Internal Server Error");
});

  });