mkdir mongodb-testing

cd mongodb-testing

version: "3.7"
services:
  database:
    image: mongo:6.0.2
    ports:
      - 27017:27017
    environment:
      - MONGO_INITDB_ROOT_USERNAME=root
      - MONGO_INITDB_ROOT_PASSWORD=123456
      - MONGO_INITDB_DATABASE=example
      - MONGO_INITDB_USERNAME=kajame
      - MONGO_INITDB_PASSWORD=111111
    volumes:
      - ./init-mongo.sh:/docker-entrypoint-initdb.d/init-mongo.sh
      - ./db:/data/db

mongosh -- "$MONGO_INITDB_DATABASE" <<EOF
  var rootUser = '$MONGO_INITDB_ROOT_USERNAME';
  var rootPassword = '$MONGO_INITDB_ROOT_PASSWORD';
  var admin = db.getSiblingDB('admin');
  admin.auth(rootUser, rootPassword);
  var user = '$MONGO_INITDB_USERNAME';
  var passwd = '$MONGO_INITDB_PASSWORD';

  db.createUser({
    user: user,
    pwd: passwd,
    roles: ["readWrite"]
  });
EOF

docker-compose up

npm init -y

npm install --save express body-parser mongoose

npm install --save-dev jest mongodb-memory-server

const express = require('express')
const mongoose = require('mongoose')
const bodyParser = require('body-parser')

const { getTodos, createTodo } = require('./services/todo')
const app = express()

const PORT = 2000

// parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: false }))

// parse application/json
app.use(bodyParser.json())

app.get('/api/todos', async (req, res) => {
  const todos = await getTodos()

  return res.json(todos)
})

app.post('/api/todo', async (req, res) => {
  const { task } = req.body

  if(!task || task.trim() === '') {
    return res.status(400).json({ success: false, message: 'Bad request' })
  }

  const todo = await createTodo({ task })

  return res.json(todo)
})

app.listen(PORT, () => {
  console.log(`Running on port: ${PORT}`)
})

mongoose.set("strictQuery", true);
mongoose.connect(`mongodb://kajame:111111@localhost:27017/example`)
const db = mongoose.connection

db.on('error', () => {
  console.log(`mongoose connection failed`)
})

db.once('open', () => {
  console.log(`mongoose connected`)
})

const Todo = require("../models/Todo")

async function getTodos() {
  const todos = await Todo.find({})

  return todos
}

async function createTodo({ task, status = 'pending' }) {
  try {
    const todo = await Todo.create({ task, status })

    return { success: true, _id: todo._id }
  } catch(error) {
    return { success: false }
  }
}

module.exports = {
  getTodos,
  createTodo
}

const mongoose = require('mongoose')
const Schema = mongoose.Schema

const TodoSchema = new Schema({
  task: String,
  status: {
    type: String,
    enum: ['pending', 'completed']
  }
}, { timestamps: true })

const Todo = mongoose.model('Todo', TodoSchema)

module.exports = Todo

const mongoose = require('mongoose')

const mockTodos = [
  {
    "_id" : mongoose.Types.ObjectId("63baf3d18f8a71f2531cca60"),
    "task" : "test",
    "status" : "pending",
    "createdAt" : new Date("2023-01-08T23:48:17.103+07:00"),
    "updatedAt" : new Date("2023-01-08T23:48:17.103+07:00"),
    "__v" : 0
  }
]

module.exports = {
  mockTodos
}

const mongoose = require('mongoose')
const { MongoMemoryServer } = require('mongodb-memory-server')

const { getTodos, createTodo } = require('./todo')
const Todo = require('../models/Todo')
const { mockTodos } = require('./__mock__/database')

async function initDefaultData() {
  Todo.create()

  await Promise.all([
    Todo.create(mockTodos),
  ])
}

let mongod = null

beforeAll(async () => {
  mongod = await MongoMemoryServer.create()
  const dbUrl = mongod.getUri()

  await mongoose.connect(dbUrl)

  await initDefaultData()
})

afterAll(async () => {
  await mongoose.connection.close()
  await mongod.stop()
})

describe('getTodos function', () => {
  it('Should return todos length equal 1', async () => {
    const todos = await getTodos()

    expect(todos).toMatchObject(mockTodos)
    expect(todos.length).toEqual(1)
  })
})

describe('createTodo function', () => {
  it('Should return success', async () => {
    const task = 'Test MongoDB'
    const todo = await createTodo({ task })

    expect(todo.success).toEqual(true)
    expect(todo._id).not.toBe(undefined)
  })

  it('Should have todos length equal 2', async () => {
    const todos = await getTodos()

    expect(todos.length).toEqual(2)
  })
})

"scripts": {
  "start": "node server.js",
  "test": "jest"
},

npm run test

npm run start