[mabel] Update mongoose and mongoose testing

Author: mabelleeyanhwa

docs/_sidebar.md

@@ -113,6 +113,7 @@
   - [Mongoose CRUD](backend-web-development/mongoose-crud)
   - [Mongoose virtuals](backend-web-development/mongoose-virtuals)
   - [Mongoose validation](backend-web-development/mongoose-validation)
+  - [Mongoose and express controllers](backend-web-development/mongoose-express)
   - [Mongoose testing](backend-web-development/mongoose-testing)
   - [Security auth](backend-web-development/security-auth)
   - [Security cryptography basics](backend-web-development/security-cryptography-basics)

docs/backend-web-development/mongoose-basics.md

@@ -33,7 +33,7 @@ const mongoOptions = {
 
 // will create a new db if does not exist
 const dbName = "pokedex";
-const dbUrl = global.__MONGO_URI__ || "mongodb://localhost:27017/" + dbName;
+const dbUrl = process.env.MONGODB_URI || "mongodb://localhost:27017/" + dbName;
 mongoose.connect(dbUrl, mongoOptions);
 const db = mongoose.connection;
 
@@ -42,16 +42,16 @@ const db = mongoose.connection;
 // read https://www.tjvantoll.com/2015/12/29/console-error-bind/
 db.on("error", console.error.bind(console, "connection error:"));
 db.once("open", () => {
-  console.log("connected to mongodb");
+  console.log(`connected to mongodb at ${dbUrl}`);
 });
 ```
 
 We put this in a "db.js" file in a utils folder.
 
-To connect to the database:
+To connect to the database, "require" this file in app.js:
 
 ```js
-//index.js
+//app.js
 require("./utils/db");
 ```
 
@@ -89,7 +89,9 @@ We define a property called `name` with a schema type `String` which maps to an
 
 `name` is also a `required` field, which means that a document using this schema must have this field. The value of `name` has to have a length of at least 3.
 
-Note that the `unique` field of `name` does not enforce uniqueness with validation but instead will try to an unique index in your the MongoDB database. If the index is not built correctly, this might not always work.
+The `unique` field of `name` does not enforce uniqueness with validation but instead will try to an unique index in your the MongoDB database. If the index is not built correctly, this might not always work. See the index being created in the database using MongoDB Compass.
+
+(Note that if you try to enforce uniqueness for a field that could be null or empty, you might need to create the unique index as a partial index that ignores null or empty values. See https://stackoverflow.com/questions/52094484/mongodb-create-unique-index-on-a-field-not-in-all-documents for more details.)
 
 The following Schema Types are allowed:
 

docs/backend-web-development/mongoose-express.md

@@ -0,0 +1,15 @@
+# Mongoose with Express.js
+
+When adding a database to Express.js that the backend server will interact with, many of our route handlers will become more like controllers that interact with the database.
+
+For example, route handlers that GET a single resource can be a controller named `findOne` that finds a single resource in the database.
+
+Similarly, when you POST a single resource in a route handler, it can be a controller named `createOne` that creates a single resource in the database.
+
+It is convention to put these controllers into a `controllers` folder. Controllers are these handlers interacting with the database that is linked to the routing in the routers.
+
+Refactor the controllers into the folder.
+
+In the MVC design pattern, controllers is the middleman between Express.js routes and mongoose models.
+
+![MVC diagram](https://mdn.mozillademos.org/files/14456/MVC%20Express.png)

docs/backend-web-development/mongoose-testing.md

@@ -26,35 +26,16 @@ Here is an example on using it with Jest: https://github.com/nodkz/mongodb-memor
 
 before writing any test...
 
+pokemons.route.test.js
+
 ```js
-//pokemons.route.test.js
 const request = require("supertest");
 const app = require("../../src/app");
 const Pokemon = require("../../src/models/pokemon.model");
-const mongoose = require("mongoose");
-const { MongoMemoryServer } = require("mongodb-memory-server");
-
-mongoose.set("useNewUrlParser", true);
-mongoose.set("useFindAndModify", false);
-mongoose.set("useCreateIndex", true);
-mongoose.set("useUnifiedTopology", true);
+const { teardownMongoose } = require("../../test/mongoose");
 
 describe("pokemons", () => {
-  let mongoServer;
-  beforeAll(async () => {
-    try {
-      mongoServer = new MongoMemoryServer();
-      const mongoUri = await mongoServer.getConnectionString();
-      await mongoose.connect(mongoUri);
-    } catch (err) {
-      console.error(err);
-    }
-  });
-
-  afterAll(async () => {
-    await mongoose.disconnect();
-    await mongoServer.stop();
-  });
+  afterAll(async () => await teardownMongoose());
 
   beforeEach(async () => {
     const pokemonData = [
@@ -82,6 +63,49 @@ describe("pokemons", () => {
 
 ```
 
+In package.json:
+
+```json
+"jest": {
+    "globalSetup": "./test/setup.js",
+    "globalTeardown": "./test/teardown.js"
+  }
+```
+
+test/setup.js
+
+```js
+const { MongoMemoryServer } = require("mongodb-memory-server");
+
+module.exports = async () => {
+  const mongoServer = new MongoMemoryServer();
+  const mongoUri = await mongoServer.getConnectionString();
+  process.env.MONGODB_URI = mongoUri;
+  // Set reference to mongo server in order to close the server during teardown
+  global.__MONGOSERVER__ = mongoServer;
+};
+```
+
+test/teardown.js
+
+```js
+module.exports = async () => {
+  await global.__MONGOSERVER__.stop();
+};
+```
+
+test/mongoose.js
+
+```js
+const mongoose = require("mongoose");
+
+const teardownMongoose = async () => {
+  // proper teardown of mongoose to prevent leaks
+  await mongoose.disconnect();
+};
+module.exports = { teardownMongoose };
+```
+
 If you try testing with mongoose now, you will see the following warning
 
 ```sh
@@ -93,6 +117,7 @@ Add this to package.json
 ```json
 //package.json
 "jest": {
+  ...
     "testEnvironment": "node"
   }
 ```
@@ -157,3 +182,7 @@ https://formidable.com/blog/2019/fast-node-testing-mongodb/
 In the example above, we make use of the mongodb-memory-server to automatically give us a fresh database in each test case.
 
 Without that library, another possible solution is to explicitly delete all data in the test database after each test finishes running. That's a bit tedious but still works. Here is a [sample project showing this approach](https://github.com/thoughtworks-jumpstart/express-blog-api-mongoose-and-tests). Check out the test cases in tests/integration-tests to see the sample tests.
+
+## Exercises
+
+Integrate mongoose into your testing for your song routes.

docs/backend-web-development/mongoose-validation.md

@@ -1,6 +1,6 @@
 # Mongoose validation
 
-Previously, we used Joi for validation of our data. With Mongoose, we can still use Joi, but now we want to learn about implementing this validation directly in Mongoose.
+Previously, we used Joi for validation of our data. With Mongoose, we can and should still use Joi, but now we want to learn about implementing this validation directly in Mongoose.
 
 In the schema, you can specify the validators. You have already saw some such as `required`.
 
@@ -39,7 +39,7 @@ How do we add our own custom validator?
 ```js
 // make sure every value is equal to "something"
 function validator(val) {
-  return val == "something";
+  return val === "something";
 }
 
 const nameSchema = new Schema({
@@ -54,3 +54,11 @@ const nameSchema = new Schema({
 var custom = [validator, 'Uh oh, {PATH} does not equal "something".'];
 new Schema({ name: { type: String, validate: custom } });
 ```
+
+## Exercises
+
+Integrate your songs routes with MongoDB and Mongoose!
+
+- Create a schema with validation and a model for your songs
+- Create a database for your songs in your MongoDB
+- Change your controllers