Testing for Web applications

Testing Principles
Tools - Libraries
- Ruby
- Elixir
- GO
- JavaScript

Testing Principles

Test Coverage

Testing Pyramid

Following levels of the Testing Pyramid, the application should include the three categories of tests with the corresponding test coverage:

Unit Tests: 100% test coverage.
Integration Tests: 100% test coverage.
UI Tests: write UI tests for every application screen that users can visit.

Test Types

For Web application projects, three types of tests are implemented: Unit Tests, Integration Tests, and UI Tests.

Unit Tests

Unit testing is a way of testing a unit, the smallest piece of code of an application. The purpose is to validate that each unit of the application code performs as expected. Unit testing is done during the development of an application by the developers.

Generally, write unit tests for the following modules:

models
services
forms
serializers
decorators
presenters
helpers

Integration Tests

Integration testing is a way of testing to ensure that the different components of the application work well together without the overhead of the actual application environment (i.e., the browser). These tests should assert at the request/response level: status code, headers, and body. They are helpful in testing permissions, redirections, what view is rendered, etc.

Write integration tests for controllers (including Web and API controllers) and third-party services (e.g., Stripe API, Twilio API, etc).

UI Tests

UI testing is a way of testing an application flow from start to end. UI testing aims to simulate the real user scenario and validate the system under test and its components for integration and data integrity.

Testing Strategy

General

For each pull request change, the tests must be added to that same pull request.
Treat test code as production code. This mindset will improve the readability, stability, and maintainability of the test suite.

Fixtures

Test data (e.g. New test user record) must be cleaned up from the test database after the test run completes.

var _ = Describe("User", func() {
    Describe("#CreateUser", func() {
        It("creates a user", func() {
            user, err := models.CreateUser()
            if err != nil {
                Fail("Creating user failed: " + err.Error())
            }
            Expect(user).ToNot(BeNil())
        })
    })
})

var _ = Describe("User", func() {
    Describe("#CreateUser", func() {
        It("creates a user", func() {
            user, err := models.CreateUser()
            if err != nil {
                Fail("Creating user failed: " + err.Error())
            }
            Expect(user).ToNot(BeNil())
        })
    })
    AfterEach(func() {
        TruncateTables("users")
    })
})

Prefer to use a fake data generator (e.g. Faker) for generating test data.

Fabricator(:customer) do
  last_name { 'John' }
  first_name { 'Doe' }
  email { '[email protected]@.com' }
end

require 'faker'
Fabricator(:customer) do
  last_name { FFaker::Name.last_name }
  first_name { FFaker::Name.first_name }
  email { FFaker::Internet.email }
end

Optimizations

Create only necessary test data, e.g. If the pagination per page size is 10, then create only 11 test records to test it.

it 'returns 10 customers' do
  Fabricate.times(30, :customer)

  sign_in_user

  get :index

  expect(assigns(:customers).size).to eq(10)
end

it 'returns 10 customers' do
  Fabricate.times(11, :customer)

  sign_in_user

  get :index

  expect(assigns(:customers).size).to eq(10)
end 

Prefer to use non persisted test objects to speed up tests when possible.

it 'returns the amount in currency format' do
  transaction = Fabricate(:transaction, amount: '100.00')

  expect(transaction.formatted_amount).to eq('฿ 100.00')
end

it 'returns the amount in currency format' do
  transaction = Fabricate.build(:transaction, amount: '100.00')

  expect(transaction.formatted_amount).to eq('฿ 100.00')
end

DRY-ing

Create testing helper methods/functions to reduce repetition across multiple tests.

describe 'GET #index' do
  it 'returns http success' do
    admin = Fabricate(:admin)
    request.env['devise.mapping'] = Devise.mappings[:user]
    sign_in(admin)

    get :index

    expect(response).to have_http_status(:success)
  end
end

describe 'GET #index' do
  it 'returns http success' do
    sign_in_as_admin

    get :index

    expect(response).to have_http_status(:success)
  end
end

# in the `/spec/support/devise_helpers.rb`
def sign_in_as_admin
  admin = Fabricate(:admin)
  request.env['devise.mapping'] = Devise.mappings[:user]
  sign_in(admin)
end

Each test must verify a single-use case.

it 'renders index view' do
  sign_in_as_admin

  get :index

  expect(response).to render_template :index
  expect(response).to have_http_status :ok
end

it 'renders index view' do
  sign_in_as_admin

  get :index

  expect(response).to render_template :index
end
 
it 'returns 200 status' do
  sign_in_as_admin

  get :index

  expect(response).to have_http_status :ok
end 

Stubbing and Mocking

All network requests must be mocked/stubbed.

it 'sends an SMS to the customer' do
  customer = Fabricate(:customer)
     
  # `service.call` makes a network request
  service = SMSService.new(customer)
     
  expect(service.call).to eq(true)
end

it 'sends an SMS to the customer' do
  customer = Fabricate(:customer)
      
  # `service.call` makes a network request
  service = SMSService.new(customer)

  # Mocks `call` method to prevent network request
  allow(service).to receive(:call).and_return(true)
 
  expect(service.call).to eq(true)
end

Prefer to use an HTTP request/response recorder (e.g. VCR) whenever possible over manual mocking/stubbing when testing external network requests. An HTTP request/response recorder records the request/response for the first time a test is executed (stored as files) and then re-uses these recordings for future test runs. So the tests can be executed with stubbed external network requests with real requests/responses.

it 'sends an SMS to the customer' do
  customer = Fabricate(:customer)
      
  # `service.call` makes a network request
  service = SMSService.new(customer)

  # Mocks `call` method to prevent network request
  allow(service).to receive(:call).and_return(true)
 
  expect(service.call).to eq(true)
end

# Preferred
it 'sends an SMS to the customer' do
  customer = Fabricate(:customer)
      
  # `service.call` makes a network request
  service = SMSService.new(customer)

  # Record the response when this test run for the first time and re-use the response when test runs later
  VCR.use_cassette('sms/send_sms_success') do
    expect(service.call).to eq(true)
  end
end

API

Prefer using a JSON Schema matcher (e.g. json_matchers) to validate JSON API responses.

it 'responds with user' do
  user = Fabricate(:user)

  authenticate_with_doorkeeper(user)

  get api_v1_me_path

  response = JSON.parse(response.body)

  expect(response.dig(:data, :attributes, :email)).to eq(user.email)
  expect(response.dig(:data, :attributes, :username)).to eq(user.username)
end

it 'responds with user' do
  user = Fabricate(:user)

  authenticate_with_doorkeeper(user)

  get api_v1_me_path

  response = JSON.parse(response.body)

  expect(response).to match_response_schema('v1/users/user', strict: true)
end

Tools - Libraries

Prefer to use the following libraries for testing:

Ruby

RSpec is a domain-specific language testing tool to test Ruby code. Check our Rspec code conventions.
Capybara is an acceptance testing framework for Ruby Web applications.
Fabrication is a Ruby object factory generator.
VCR is an HTTP request/response recorder for Ruby.
Faker is a fake data generator for Ruby.

Elixir

ExUnit is a built-in unit testing framework for Elixir. Check our ExUnit code conventions.
Wallaby is an acceptance testing framework for Elixir Web applications.
ExMachina is a test data factory generator for Elixir.
ExVCR is an HTTP request/response recorder for Elixir.
Faker is a fake data generator for Elixir.
Mimic is a mocking library for Elixir.

GO

Ginkgo is a BDD testing framework for Go.
Gomega is a matcher library for Go.
go-vcr is an HTTP request/response recorder for Go.
Faker is a struct data fake generator for Go.

JavaScript

Jest is a testing framework for JavaScript.
Cypress is a UI testing framework for JavaScript Web applications. Check our Cypress code conventions.