DEV Community: muhammed Lotfy

Testing NodeJs/Express API with Jest and Super test 🐧🐧

muhammed Lotfy — Mon, 21 Dec 2020 22:35:30 +0000

About Testing!
Jest and SuperTest Intro !
Who apply testing?
Conclusion

Testing one of the most important skills you can known as a developer, It's something a lot of people don't teach or focus on but if you known testing, So I had to try and figure it out here in part(2). you can read more in article Testing part(1) in Node JS with Express using Mocha and Chai

About Testing!

Unit Testing
Tests a single fully isolated unity of the application.

Integration Testing
Tests the interaction of a unit along with its dependencies. e.g. A function that calls another function meaning that the test results are also depending on the function being called within the parent function.

End-2-End Testing
Full flow tests. From the front-end button click to the API endpoint consuming.

Jest and SuperTest Introduction

About Jest

Jest is a wonderful testing library created by Facebook to help test JavaScript code, Express APIs, React components, and much more.
What's great about Jest is it not only has a similar syntax to other testing/assertion libraries like Jasmine and Chai.
And with Jest your tests run in parallel so they are executed much faster than other testing frameworks.

About SuperTest

SuperTest is an HTTP assertions library that allows you to test your Node.js HTTP servers.
It is built on top of SuperAgent library, which is an HTTP client for Node.js.

Who apply testing ?!

(1) Getting Started
So, in this article we're going to use the blog REST API I built using Express and Mongoose
which you can fetch Github repo here

To use jest globally we can install it with

$ npm install -g --save-dev jest supertest

Once the packages are installed, we need to setup a test command in our package.json file



{
    // ...
    "scripts": {
        "test": "jest"
    }
    // ...
}

(2) Test preparation

Writing your first test (You can make the test pass by expecting 1 === 1). ```javascript

// This passes because 1 === 1
it('Testing to see if Jest works', () => {
expect(1).toBe(1)
})

**(3) Testing Endpoints**
 - Before you can test endpoints, you need to setup the server so Supertest can use it in your tests.
 - Most tutorials teach you to listen to the Express app in the server file, like this:
```javascript


const express = require('express')
const app = express()

// Middlewares...
// Routes...

app.listen(3000)

This doesn’t work because it starts listening to one port. If you try to write many test files, you will get an error port in use.
So you want to allow each test file to start a server on their own. To do this, you need to export app without listening to it.



const express = require('express')
const app = express()

// Middlewares...
// Routes...

module.exports = app

For development or production purposes, you can listen to your app like normal in a different file like index.js. ```javascript

const app = require("./server");
app.listen(5000, () => {
console.log("Server has started!");
});

**(4) Using Supertest**
 - To use Supertest, you require your app and supertest in the test file.
```javascript


const app = require("../server");
const mongoose = require("mongoose");
const supertest = require("supertest");

beforeEach((done) => {
  mongoose.connect("mongodb://localhost:27017/JestDB",
    { useNewUrlParser: true, useUnifiedTopology: true },
    () => done());
});

afterEach((done) => {
  mongoose.connection.db.dropDatabase(() => {
    mongoose.connection.close(() => done())
  });
});

Those are functions that will be invoked before and after every single test cases. This allows us to connect to MongoDB and remove all the data once a test case is finished
In Jest, these are done using four different functions:
- beforeAll - called once before all tests.
- beforeEach - called before each of these tests (before every test function).
- afterEach - called after each of these tests (after every test function).
- afterAll - called once after all tests.

(5) Using routes

We also want to initialize our Express server in app variable which will be accessible from our test case. Let's create a new test case called GET /api/posts. ```javascript

test("GET /api/posts", async () => {
const post = await Post.create({ title: "Post 1", content: "Lorem ipsum" });

await supertest(app).get("/api/posts")
.expect(200)
.then((response) => {
// Check type and length
expect(Array.isArray(response.body)).toBeTruthy();
expect(response.body.length).toEqual(1);

  // Check data
  expect(response.body[0]._id).toBe(post.id);
  expect(response.body[0].title).toBe(post.title);
  expect(response.body[0].content).toBe(post.content);
});

});

* Here, we're adding a new document to our database so that we won't get an empty response. Then, we send a GET request using SuperTest to the /api/posts endpoint and expect the response status to be 200


which means success. Finally, we check if the response matches the data in the database.


  
  
  We can now run our tests by running npm test




  
  
  Matchers


Jest has quite a few functions used for assertions/expectations. You can see a full list here, but these are some common ones.


toBeDefined
toBeGreaterThan / toBeLessThan

toBe (uses === to compare)

toEqual (for deep object comparison)

toContain (see if a value is inside of a collection)


  
  
  Now, let's test the get single post .




test("GET /api/posts/:id", async () =&gt; {
  const post = await Post.create({ title: "Post 1", content: "Lorem ipsum" });

  await supertest(app).get("/api/posts/" + post.id)
    .expect(200)
    .then((response) =&gt; {
      expect(response.body._id).toBe(post.id);
      expect(response.body.title).toBe(post.title);
      expect(response.body.content).toBe(post.content);
    });
});


</code></pre></div><h3>
  <a name="we-can-now-run-our-tests-again-by-running-raw-npm-test-endraw-" href="#we-can-now-run-our-tests-again-by-running-raw-npm-test-endraw-">
  </a>
  We can now run our tests again by running <code>npm test</code>
</h3>

<p><img src="https://dev-to-uploads.s3.amazonaws.com/i/1mvul58a5uawa4esdljw.PNG" alt="Alt Text"></p>
<h1>
  <a name="conclusion" href="#conclusion">
  </a>
  Conclusion! <a name="chapter-4"></a>
</h1>

<p>I played around with testing lately. One thing I tried to do was to test the endpoints of my Express application.</p>

<p>If you enjoyed this article, please tell a friend about it!<br>
Share it on Twitter. If you spot a typo, I’d appreciate if you can correct it on <a href="https://github.com/mohamedlotfe/unit-testing-api-nodejs-jest">GitHub</a>.<br>
You can contact me through:</p>

<p>Gmail: <a href="mailto:mhmdlotfy9@gmail.com">mhmdlotfy9@gmail.com</a><br>
or <a href="https://www.linkedin.com/in/mohamedlotfybasher/">Linkedin</a><br>
Thank you</p>

Authentication and Authorization Using JWT in Node JS with Express

muhammed Lotfy — Sat, 12 Dec 2020 22:01:32 +0000

What is authentication & authorization ?!
What is (JWT)JSON Web Token?
Why using Authentication & Authorization ?
How apply Authentication ?
How apply Authorization ?
Conclusion

Introduction

User authentication & authorization is one of the important part of any web application.
There are several kinds of way to handle authentication, we can rely on third party service like Passport.
But in this article we will use very simple & self developed approach, which will help us to understand core part of authentication.

Technology Used

Token: JWT
Password Hash: bcryptjs
Database: MongoDB

What is authentication & authorization ?!

In simple words, Authentication is the process of verifying who a user is (who you are), and
Authorization is the process of verifying what they have access to (what you are allowed to do).

What is (JWT)JSON Web Token ?!

JWTs are a good way of securely transmitting information between parties because they can be signed (Information Exchange). Even though we can use JWT with any type of communication method, today JWT is very popular for handling authentication and authorization via HTTP.

Here is the diagram of how JWT works:

Structure of a JWT :-

The first section of the JWT is the header, which is a Base64-encoded string.
which contains the hashing algorithm, which was used to generate the sign and the type of the token.
If you decoded the header it would look something similar to this:
{ "alg": "HS256", "typ": "JWT"}
The second section is the payload that contains the JSON object of user data like (id or id_type) that was sent back to the user.
Since this is only Base64-encoded, it can easily be decoded by anyone.

{"sub": "1234567890", "name": "John Doe", "userId": "1516239022", "user_type_id":1 }

The final section is the signature of the token using the algorithm that is mentioned in the header section

Why using Authentication & Authorization ?!

To protect the data in a security system, administrators should be able to, among other things, implement detailed user access privileges, select the information that can be shared internally with partners and authorities, and control how long data is kept.

A common example is entering a username and password when you log in to a website.
Entering the correct login information lets the website know

1) Who you are and
2) That it is actually you accessing the website.

There will be two types of users (admin & user)

Authentication that all user need to login and register first ,
Authorization that administrators and the regular user. Administrators will be able to view special events
whereas the regular user will be able to view ordinary events

To get started in this trip, I have REST APIs already created (including 4 Routes) GitHub repo

1- POST login route ( everyone has access)
2- POST register route ( everyone has access)
3- GET events array (only regular user has access)
4- GET special events array (only admin user has access)

How apply Authentication ?!

Step (1)

To get started, in your terminal initialize an empty Node.js project with default settings:
$ npm init -y
Then, let's install the Express framework, JWT, bcryptjs and mongoose:
$ npm install --save express jsonwebtoken bcryptjs
Then To create basic structure for different kind of endpoints like registration or login we will use express as router. And we will create a folder for routers (routers/index.js)
Then, let's create a file called (middleware/auth.js), which will be our authentication service and create a file called (controllers/user), which will be our controller for user functions
Now, let's create our Server and use these modules and configure them in the Express app (server.js):

const express = require('express');
const app = express();

app.use(express.json()); 

// Import Routes
const authRoute = require('./routes/index');

// Route Middlewares
app.use('/api', authRoute);

const port = 3000;
app.listen(port, function(){console.log("Server running on localhost:" + port);});

Step (2)

Now go for folder for routers (routers/index.js) to configure express Router import userController

const router = require('express').Router();
const userController = require('../controllers/user');

// Register a new User
router.post('/register', userController.register);

// Login
router.post('/login', userController.login);

module.exports = router;

Step (3)

Now go for folder for routers (controllers/user) to add userController functions
1.Connect to DB

mongoose.connect(db, function(err){
    if(err){
        console.error('Error! ' + err)
    } else {
      console.log('Connected to mongodb')      
    }
});

Create register function
- Hash password using bcrypt module
- Create an user object
- Save User in the database
- Create payload then Generate an access token (if you ask about what is payload go for Structure of a JWT section)

exports.register = async (req, res) => {
    //Hash password
    const salt = await bcrypt.genSalt(10);
    const hasPassword = await bcrypt.hash(req.body.password, salt);

    // Create an user object
    let user = new User({
        email: req.body.email,
        name: req.body.name,
        password: hasPassword,
        user_type_id: req.body.user_type_id
    })

    // Save User in the database
    user.save((err, registeredUser) => {
        if (err) {
            console.log(err)
        } else {
            // create payload then Generate an access token
            let payload = { id: registeredUser._id, user_type_id: req.body.user_type_id || 0 };
            const token = jwt.sign(payload, config.TOKEN_SECRET);
            res.status(200).send({ token })
        }
    })
}

After the authentication service is up and running, let's send a POST request and see if registration works or not.

I will be using the rest-client Postman to do this. Feel free to use any rest-client you prefer or something like Insomnia to do this.
- Let's send a post request to the http://localhost:3000/api/register endpoint with the following JSON: { "email":"d@a.hh", "name" : "lotfy", "password": "123456", "user_type_id":1 }
- You should get the access token as the response: { "Token": "eyJhbGciOiJIUz..." }

Step (4)

Now we register for new user and token receive token as response
we need to login with user credentials

create login function
- compare Hashed password with credentials
- create payload then Generate an access token and return token in headers

exports.login = async (req, res) => {

    User.findOne({ email: req.body.email }, async (err, user) => {
        if (err) {
            console.log(err)
        } else {
            if (user) {
                const validPass = await bcrypt.compare(req.body.password, user.password);
                if (!validPass) return res.status(401).send("Mobile/Email or Password is wrong");

                // Create and assign token
                let payload = { id: user._id, user_type_id: user.user_type_id };
                const token = jwt.sign(payload, config.TOKEN_SECRET);

                res.status(200).header("auth-token", token).send({ "token": token });
            }
            else {
                res.status(401).send('Invalid mobile')
            }

        }
    })
}

let's send a POST request and see if Login works or not.

Let's send a post request to the http://localhost:3000/api/login endpoint with the following JSON: { "email":"d@a.hh", "password": "123456" }
You should get the sucess with 200 code and access token in the header of response: "auth-token": "eyJhbGciOiJIUz..."

How apply Authorization ?!

As we mentioned in Authentication steps (register/login)
We added property called "user_type_id" which is identifier for type of user is request this data

Step (1)

Now we need if the request for logged in user or some hack my APIs
let's move to our auth file in (middleware/auth.js)

Check if request have an access token
Remove Bearer from string which added in header of request
Verify User Token with my token secretKey

exports.verifyUserToken = (req, res, next) => {
    let token = req.headers.authorization;
    if (!token) return res.status(401).send("Access Denied / Unauthorized request");

    try {
        token = token.split(' ')[1] // Remove Bearer from string

        if (token === 'null' || !token) return res.status(401).send('Unauthorized request');

        let verifiedUser = jwt.verify(token, config.TOKEN_SECRET);   // config.TOKEN_SECRET => 'secretKey'
        if (!verifiedUser) return res.status(401).send('Unauthorized request')

        req.user = verifiedUser; // user_id & user_type_id
        next();

    } catch (error) {
        res.status(400).send("Invalid Token");
    }

}

Now we need know type for logged-in user

exports.IsUser = async (req, res, next) => {
    if (req.user.user_type_id === 0) {
        next();
    }
    return res.status(401).send("Unauthorized!");   
}
exports.IsAdmin = async (req, res, next) => {
    if (req.user.user_type_id === 1) {
        next();
    }
    return res.status(401).send("Unauthorized!");

}

Step (2)

Now we verified user but need to know is this route for administrators or regular user
with my authentication middleware to check routes with user type to file (routers/index.js)

If these valid conditions call get user events function

// Auth user only
router.get('/events', verifyUserToken, IsUser, userController.userEvent);

// Auth Admin only
router.get('/special', verifyUserToken, IsAdmin, userController.adminEvent);

let's send a request and see if special route works for admin user with user_type_id == 1.

Let's send a post request to the http://localhost:3000/api/special endpoint with the following authorization header with TYPE Bearer Token and value of token:eyJhbGciOiJIUz...
You should get the success with 200 code and the special events array as a response:
{ "_id": "1", "name": "Auto Expo Special", "description": "lorem ipsum", "date": "2012-04-23T18:25:43.511Z" } .....

Conclusion ?!

In this article, we have introduced you to JWT and how to implement JWT with Express. I hope that now you have a piece of good knowledge about how JWT works

The end Thank you for going through this tutorial. If you notice any errors please report them to me. If you got stuck on any step, please refer to this GitHub repo.

You can contact me through:

Gmail: mhmdlotfy9@gmail.com
or Linkedin

Testing a REST API in Node JS with Express using Mocha and Chai 😎

muhammed Lotfy — Sun, 06 Dec 2020 21:40:06 +0000

What is Unit testing
Why using Unit testing?
Who use Unit testing?
Conclusion

What is Unit testing ?!

Is a software testing method by which individual units of source code and typically automated tests written and run by software developers to ensure that a section of an application (known as the "unit") meets its design and behaves as intended.

Why using Unit testing

Testing is one of those things that people either love or hate. Usually testing is something that is hated

Until you work on a project with good tests and you realize how amazing they are.
I will talk about the code you need in order to write tests in JavaScript using chai and mocha, as well as show you some pitfalls of testing.
At the end of the article I will breakdown the importance of testing and some best practices you can adhere to in order to make your tests amazing.

Who use Unit testing ?!

To get started in this trip, I have simple REST APIs already created (Get, Post, etc.)

And these are very simple server-side Nodejs with Express APIs GitHub repository link
in our case we have a route get all tasks which response with a small array of tasks.
As we mentioned at the beginning of this article we gonna talking about testing and how to test on JavaScript and an the easiest way to that in my opinion is to use both library(chai and mocha)

Chai is an assertion library for NodeJS and browser with three styles [ should, Expect, Assert]

Mocha is a testing framework for JavaScript, each is an incredibly and well-built testing library for JavaScript

1.In order to start this all we need to do is to install two libraries with

`run npm i mocha chai --save--dev`

2.Now that is done downloading we come here where we have test script and we can change this by typing in `"test": "mocha"`

3.So to get started creating first test all need to do is create folder called test and add a new file task.js give it the exact same name as file you want to test in our case we will test

4.Now inside this file all need to do to import routes file (task.js) including all APIs and in order to write test we need to import chai then adding Assertion

5.Now we are able to call our RESTful APIs and in order to use mocha describe our test let's call it `tasks API`, then we define an arrow function so first task to describe Get API let's call it `Get-All-Tasks` then user It to describe what our API do `it should Get all the tasks`

6.Here we use chai with `chai.request(server)` and test our Get API `.get("/api/tasks")` the we expect using `.end((err, response)` which will receive error and response so we expect a successful results so response should have status 200 and body should be an array with 3 tasks

7.finally call `Done()`, and run using `npm test` and the test run successfully

If you need to request wrong route to show API response we make small changes

Test the GET (by Id) route the same steps but we will add task id and in response we will check for returned properties

Conclusion

Testing one of the most important skills you can known as a developer, It's something a lot of people don't teach or focus on but if you known testing, It's gonna set you apart from every other developers that doesn't known testing and give you extra leg up when you applying for jobs

DEV Community: muhammed Lotfy

Testing NodeJs/Express API with Jest and Super test 🐧🐧

Table Of Contents

Testing one of the most important skills you can known as a developer, It's something a lot of people don't teach or focus on but if you known testing, So I had to try and figure it out here in part(2). you can read more in article Testing part(1) in Node JS with Express using Mocha and Chai

About Testing!

Jest and SuperTest Introduction

About Jest

About SuperTest

Who apply testing ?!

We can now run our tests by running npm test

Matchers

Now, let's test the get single post .

Authentication and Authorization Using JWT in Node JS with Express

Table Of Contents

Introduction

Technology Used

What is authentication & authorization ?!

What is (JWT)JSON Web Token ?!

Here is the diagram of how JWT works:

Structure of a JWT :-

Why using Authentication & Authorization ?!

There will be two types of users (admin & user)

How apply Authentication ?!

Step (1)

Step (2)

Step (3)

After the authentication service is up and running, let's send a POST request and see if registration works or not.

Step (4)

let's send a POST request and see if Login works or not.

How apply Authorization ?!

Step (1)

Step (2)

let's send a request and see if special route works for admin user with user_type_id == 1.

Conclusion ?!

Testing a REST API in Node JS with Express using Mocha and Chai 😎

Table Of Contents

What is Unit testing ?!

Why using Unit testing

Who use Unit testing ?!

Chai is an assertion library for NodeJS and browser with three styles [ should, Expect, Assert]

Mocha is a testing framework for JavaScript, each is an incredibly and well-built testing library for JavaScript

1.In order to start this all we need to do is to install two libraries with

run npm i mocha chai --save--dev

2.Now that is done downloading we come here where we have test script and we can change this by typing in "test": "mocha"

3.So to get started creating first test all need to do is create folder called test and add a new file task.js give it the exact same name as file you want to test in our case we will test

4.Now inside this file all need to do to import routes file (task.js) including all APIs and in order to write test we need to import chai then adding Assertion

5.Now we are able to call our RESTful APIs and in order to use mocha describe our test let's call it tasks API, then we define an arrow function so first task to describe Get API let's call it Get-All-Tasks then user It to describe what our API do it should Get all the tasks

6.Here we use chai with chai.request(server) and test our Get API .get("/api/tasks") the we expect using .end((err, response) which will receive error and response so we expect a successful results so response should have status 200 and body should be an array with 3 tasks

7.finally call Done(), and run using npm test and the test run successfully

If you need to request wrong route to show API response we make small changes

Test the GET (by Id) route the same steps but we will add task id and in response we will check for returned properties

Conclusion

Testing one of the most important skills you can known as a developer, It's something a lot of people don't teach or focus on but if you known testing, It's gonna set you apart from every other developers that doesn't known testing and give you extra leg up when you applying for jobs

We can now run our tests by running `npm test`

`run npm i mocha chai --save--dev`

2.Now that is done downloading we come here where we have test script and we can change this by typing in `"test": "mocha"`

5.Now we are able to call our RESTful APIs and in order to use mocha describe our test let's call it `tasks API`, then we define an arrow function so first task to describe Get API let's call it `Get-All-Tasks` then user It to describe what our API do `it should Get all the tasks`

6.Here we use chai with `chai.request(server)` and test our Get API `.get("/api/tasks")` the we expect using `.end((err, response)` which will receive error and response so we expect a successful results so response should have status 200 and body should be an array with 3 tasks

7.finally call `Done()`, and run using `npm test` and the test run successfully