DEV Community: Syed Afroz Pasha

AWS Lambda Functions (Node.js) - Unit testing using Mocha and Chai

Syed Afroz Pasha — Fri, 17 Dec 2021 14:17:45 +0000

Unit testing is the process of testing a piece of code or module and identifying any issues within it. In unit testing, we test a piece of code/module with some set of test cases. In JavaScript-based applications, we use generally use Mocha and Chai to write the test cases.

Let us learn how to write unit test cases for the AWS Lambda function using Mocha and Chai.

What is AWS Lambda?

AWS Lambda is a serverless, event-driven compute service that lets you run code for virtually any type of application or backend service without provisioning or managing servers.

Unit testing of AWS lambda functions is also important as it helps us find any issues in the lambda code. In this article, we will be learning more about unit testing the lambda functions.

Let’s get started 🚀

Lambda Code

Let us first take a look into a sample Lambda function that fetches the search results from the database based on the search input and filter. This function takes two inputs — searchText and filterBy.

searchText will have the text which we want to search in the database
filterBy will have the field name based on which we want to order the search results.

// app.js
async function lambdaFunction(event, context) {
  const response = {};
  try {
    let requestBody = event.body;
    let { searchText, filterBy } = requestBody;

    /* Validate the required request params */
    if (!utils.isValidateInput(searchText) || !utils.isValidateInput(filterBy)) {
      throw new Error("Invalid request body");
    }

    // Get search results
    const searchResult = await fetchSearchResult(searchText, filterBy);

    if (searchResult && searchResult.length > 0) {
      response.data = searchResult;
      response.message = "Results fetched!";
    } else {
      response.data = searchResult || [];
      response.message = "No results found";
    }
    response.code = 200;
    return response;
  } catch (error) {
    response.code = 400;

    if (error) {
      response.ErrorMessages = [error.message];
    }

    return response;
  }
}

Unit testing of the lambda function

Now let’s test the above lambda code by writing the test cases. For unit testing, we will be using the following packages.

Mocha - For creating a test suite and running the test cases.
Chai - Assertion library to verify if a given code is working correctly or not.
Proxyquire - A package that can proxy the dependencies by overriding the functions inside it.
Lambda Tester — A package that can help to run a lambda function locally.

Now let’s dive deep into it.

Lambda function execution

For testing the lambda function, we need a way to execute/call a lambda function from our local. For that, we can use a third-party package called lambda-tester. Lambda-tester can take an event object and execute the lambda function to return the result.

// test.js
const expect = require("chai").expect;
const lambdaTester = require("lambda-tester");

// Import lambda funcion
const lambda = require('../src/lambda/app.js');

const mockData = {
  // some mock data
}

// Execute lambda function using lambda-tester package
lambdaTester(lambda.handler)
  .event(mockData) // Passing input data
  .expectResult((result) => {
    // Check if code exist
    expect(result.code).to.exist;

    // Check if code = 200
    expect(result.code).to.equal(200);

    // Check if data exist
    expect(result.data).to.exist;

    // Check if data is an array
    expect(result.data).to.be.a("array");

    done();
  })
  .catch(done); // Catch assertion errors

Overriding and mocking the dependencies

Now that we know how to call/execute a lambda function in our local. Let us learn about mocking the dependencies inside the lambda function. These dependencies can be any third-party libraries or DB call or even an API call. To override and mock these dependencies we can use proxyquire package.

Proxyquire will help us import the lambda function without calling (invoking) it and also help us mock the dependencies used inside the lambda function.

In the below example, we have two dependencies — utils (utility functions) and dataService (database functions). We will override a database function called query and add our own logic which will return the mock results. However, we will not override the utility functions file (utils) as it has independent code without any third-party dependencies.

// test.js
const proxyquire = require("proxyquire");

// Internal dependencies
const utils = require("../src/utils/utils");

// Create a object which will have mock functions
const dataStub = {
  // Mocking DB call
  query: function (params) {
    // return some mock results
  },
};

// Exporting the lambda with mock dependencies
const lambda = proxyquire.noCallThru().load("../src/lambda/app.js", {
  // Replacing the dependencies present inside lambda function (app.js) with mock functions
  "../dataService/data": dataStub,
  "../utils/utils": utils,
});

Test case for the lambda function

Now that we have learned how to invoke a lambda function in local with mock dependencies. Let us now write a simple test case.

// test.js
const expect = require("chai").expect;
const proxyquire = require("proxyquire");
const lambdaTester = require("lambda-tester");

// Internal dependencies
const utils = require("../src/utils/utils");

// Import mock function from mock.js
const { mockDBfunction, validInput, invalidInput } = require("./mock");

// Define a common test suite
describe("FetchSearchResult Lambda Unit Test", function () {
  let lambda = null;

  // Mocking data services
  let dataStub = {};

  beforeEach(function () {
    // Exporting the lambda with mock dependencies
    lambda = proxyquire.noCallThru().load("../src/lambda/app.js", {
      // Replacing the dependencies present inside lambda function (app.js) with mock functions
      "../dataService/data": dataStub,
      "../utils/utils": utils,
    });
  });

  describe("Successful Invocation", function () {
    let mockData = null;

    before(function () {
      // Attach mock function to data services (mocked)
      dataStub = {
        ...dataStub,
        // Mocking DB call
        query: function (params) {
          // Get the name of the function which is calling 'query' inside lambda function (app.js)
          let functionName = arguments.callee.caller.name;

          // based on the function name mock the data
          return mockDBfunction(functionName);
        },
      };
      // Get valid inputs from mock.js
      mockData = validInput();
    });

    it("with code = 200", function (done) {
      // Execute lambda function using lambdaTester package
      lambdaTester(lambda.handler)
        .event(mockData) // Passing input data
        .expectResult((result) => {
          // Check if code exist
          expect(result.code).to.exist;

          // Check if code = 200
          expect(result.code).to.equal(200);

          // Check if data exist
          expect(result.data).to.exist;

          // Check if data is an array
          expect(result.data).to.be.a("array");

          done();
        })
        .catch(done); // Catch assertion errors
    });
  });
});

Now let’s run the test case using the command mocha and check if it is passing or not.

You can find all the code discussed in this article in this repo.

That’s all I have for today. Hope you enjoyed it. 😉

Thank you for stopping by. If you like the content do support me and follow me for more content like this.

You can connect with me on LinkedIn, Twitter, and GitHub.

JavaScript Best Practices for Beginners

Syed Afroz Pasha — Sat, 25 Sep 2021 07:26:32 +0000

Let us quickly discuss some of the best practices which you can follow while working with JavaScript. I have covered some of the basic stuff which we will be using often in our day-to-day programming.

Let’s get started.

Always define variables using let or const

By defining variables using let or const, we can avoid problems such as

Pollution of global variables and namespaces: Let’s say your application uses a global variable title. In some other part of your code, you have defined a variable title (without let or const) again, but this variable is specific to that function and it is nowhere related to the global variable title. Then there might be a chance this title variable might mutate (change) the global value.

If we define the variables using let or const, the variable will be blocked scoped meaning it’s only available to that block of code. Hence it will not be able to change the global variable.

Exposing sensitive data: Let’s say you are storing the API key in a global variable (which you defined without let or const), then this API key will be stored in the global object (window) and can be easily accessed by anyone visiting your site.

Again if we define the variables using let or const, the variable will be blocked scoped and it will not be exposed to the global object (window).

Always define conditions correctly

If you want to check a variable for falsy values (undefined, null, an empty string), simply use NOT operator (!) instead of checking each and every falsy value.

If you want to check if a key/value is present in an object. You can safely check one by one if that key/value exists using AND operator (&&).

You can also use optional chaining to check whether a key/value is present in an object or not.

Semicolon

Before we dive deep, here is an activity for you. Can you guess what will be the output of the below function?

Answer: The output will be undefined 😲. But how?, This is because of automatic semicolon insertion by JavaScript Engine while parsing the code. If the code is not formatted correctly like in the above example, JavaScript Engine will add a semicolon(;) to the end of the return statement (return;) and it thinks that no value is returned. So returns a value as undefined.

Automatic Semicolon Insertion (ASI): At the time of parsing the code, JavaScript Engine automatically inserts a semicolon at the end of each token. This sometimes may cause unexpected behavior of code. You can read more about it here

It is also recommended to add a semicolon at the end of each statement of the code to avoid ASI problems.

Brackets

People from different programming language backgrounds tend to start the braces in the next line. But in JavaScript, this can cause unexpected behavior of the code.

Never start the curly braces ({}) in the next line. Because of ASI, your code may behave unexpectedly.

Always start the curly braces just after the end of the statement (in the same line).

We can avoid these problems, by formatting the code using Prettier or any other formatting tools/libraries.

Template Literals

Template literal is used to define a string value. Template literals are enclosed by the backtick and dynamic values/placeholder can be passed using the dollar symbol ${dynamicValue}.

Below are some of the use cases of template literals.

Template literals can be used to define dynamic HTML content.

Template literals can be used to define database queries

Template literals can be used to define dynamic shorts URLs (single line).

Do not use template literals to define long URLs with multi-lines. As APIs do not support the multi-line URLs. There are many workarounds available to handle multiple parameters in a single line, but we are not going to discuss all of that here.

We can avoid most of the problems discussed in this article by using linters and code formatters. Here are some of the popular linters and code formatters.
Linters: ESLint , JSLint
Code formatters: Prettier

That’s all I have for today. Hope you enjoyed it. 😉

You also check out my article on Naming variables and functions in JavaScript.

Thank you for stopping by. If you like the content do support me and follow me for more content like this.

Connect with me on LinkedIn, Twitter, and GitHub.

Naming Variables, Functions and Classes in JavaScript

Syed Afroz Pasha — Fri, 27 Aug 2021 15:18:08 +0000

Introduction

Proper naming of variables and functions is very important. This makes your code more readable and easier to debug. In this article, I have consolidated some of the best practices from the styles guides such as Google and Airbnb. Most of the popular JavaScript frameworks and libraries follow these best practices.

Before we get started, here is what you need to know first.

There are different case styles used across different programming languages to name the variables. Let us discuss some of the case styles.

Camel Case: It is the practice of writing phrases without spaces or punctuation, indicating the separation of words with a single capitalized letter, and the first word starting with lower case. Example: pageCount
Pascal Case: It is very similar to the camel case, but the first letter starts with Upper case. Example: PageCount
Snake Case: Here we separate the words using underscore (_) and the words can be either in lower or upper case. Example: page_count or PAGE_COUNT

Now that we have learned different case styles, let us go through in detail on how to name a variable, functions and classes in JavaScript.

Naming Variables

Variables in JavaScript can be of two types:

Dynamic Variables: whose value keeps on changing. let is used to define the dynamic variables with primitive values (such as strings, boolean and numbers, etc.). And we also use const to define the dynamic variables with non-primitive values (such as objects and arrays). It is preferred to use Lower Camel Case for naming the dynamic variables.

Constant Variables: whose value remains constant and doesn’t change. const is used to define the constant variables. It is preferred to use Upper Case for naming the constant variables.

If the constant variables name has more than one word, then it is recommended to define it using the Upper Snake Case style.

Naming Functions

The function names are also preferred to be defined using the Lower Camel Case style.

Naming Classes

The class names are preferred to be defined using the Pascal Case style.

Naming React Components

React components (both class and functional components) are usually named in the Pascal case.

Naming exported node modules (Node.js)

It is preferred to use Lower Camel Case for naming the exported node module names.

Do and don’t while naming a variable

Variable names should start with either a letter, underscore (_), or a dollar sign ($).
Variable names cannot start with numbers or any special character other than underscore or dollar sign.
Variable names can have numbers, but not at the beginning of the name (first letter).
Variable names cannot have spaces.
Don’t use any of JavaScript’s reserved keywords such as (const, for, if, function, etc.)
Use meaningful names like userName or ShoppingList and avoid ambiguous names/abbreviations.
Names should specify what value it is holding (like orderNumber or employeeName) in case of variables.
Names should specify what action it is doing (like getStudentDetail or updateCartItems) in case of functions.

Summary

Let us summarize the items we have learned so far.

Thank you for stopping by. If you like the content do support me and follow me for more content like this.

Connect with me on LinkedIn, Twitter, and GitHub.