Forem: Emanuel Quimper

Golang Rest API for NodeJS developer - Part 2

Emanuel Quimper — Fri, 20 Dec 2019 12:46:48 +0000

In part 1 we did set up the foundation of our REST API. In this part, we will set up the Register logic for our authentication portion of the app.
Authentication is a big part of almost every app we need to build as a developer. One thing it's because is so common you can almost translate the knowledge
earn in other languages. In our case for this tutorial, we will use a simple JWT authentication with an email/password combination.
Later I maybe plan to add Google OAuth.

The first thing to do is to create the User struct. Pretty standard stuff. An id who will be auto-increment by PostgreSQL. Some timestamps so we know when the user did get created or updated.
You can also see the JSON tag. If you look at the password I use -, this means we do not want the password to get return to the JSON client.

// domain/users.go

package domain

import "time"

type User struct {
    ID       int64  `json:"id"`
    Username string `json:"username"`
    Email    string `json:"email"`
    Password string `json:"-"`

    CreatedAt time.Time `json:"createdAt"`
    UpdatedAt time.Time `json:"updatedAt"`
}

After this, we will create 3 instances of error. This will make our life easier in the long run of the app.

// domain/errors.go

package domain

import "errors"

var (
    ErrNoResult = errors.New("no result")
    ErrUserWithEmailAlreadyExist = errors.New("user with email already exist")
    ErrUserWithUsernameAlreadyExist = errors.New("user with username already exist")
)

One thing I like when I work with Go is creating the interface need to make the app work before even starting writing the logic. The interface
will be like a contract and make sure my code will follow this. Time to jump on the UserRepo interface who will be our layer to the database
for the user stuff. I also create a Domain struct who will keep the DB instance. So we can make sure we have only one instance of this last one.
This will also make life easier and no cycle dependencies issue.

// domain/domain.go
package domain

type UserRepo interface {
    GetByEmail(email string) (*User, error)
    GetByUsername(username string) (*User, error)
    Create(user *User) (*User, error)
}

type DB struct {
    UserRepo UserRepo
}

type Domain struct {
    DB DB
}

With that, we can start creating the auth domain logic. First, we create a payload struct who will capture the client data request.
After this, the Register method will do the logic for creating a user to our app. This one will also handle the error if a user exists for both the
email or username, we want those to be unique. Finally, we create a method setPassword that will be filled in later part.

// domain/auth.go
package domain

type RegisterPayload struct {
    Email           string `json:"email"`
    Password        string `json:"password"`
    ConfirmPassword string `json:"confirmPassword"`
    Username        string `json:"username"`
}

func (d *Domain) Register(payload RegisterPayload) (*User, error) {
    userExist, _ := d.DB.UserRepo.GetByEmail(payload.Email)
    if userExist != nil {
        return nil, ErrUserWithEmailAlreadyExist
    }

    userExist, _ = d.DB.UserRepo.GetByUsername(payload.Username)
    if userExist != nil {
        return nil, ErrUserWithUsernameAlreadyExist
    }

    password, err := d.setPassword(payload.Password)
    if err != nil {
        return nil, err
    }

    data := &User{
        Username: payload.Username,
        Email:    payload.Email,
        Password: *password,
    }

    user, err := d.DB.UserRepo.Create(data)
    if err != nil {
        return nil, err
    }

    return user, nil
}

func (d *Domain) setPassword(password string) (*string, error) {
    return nil, nil
}

After this, we can add the domain to your server struct. This will make the domain available to this one inside the handlers.

// handlers/handlers.go

package handlers

import (
    "time"

    "github.com/go-chi/chi"
    "github.com/go-chi/chi/middleware"

    "todo/domain"
)

type Server struct {
    domain *domain.Domain
}

func setupMiddleware(r *chi.Mux) {
    r.Use(middleware.RequestID)
    r.Use(middleware.RealIP)
    r.Use(middleware.Compress(6, "application/json"))
    r.Use(middleware.Logger)
    r.Use(middleware.Recoverer)
    r.Use(middleware.URLFormat)
    r.Use(middleware.Timeout(60 * time.Second))
}

func NewServer(domain *domain.Domain) *Server {
    return &Server{domain: domain}
}

func SetupRouter(domain *domain.Domain) *chi.Mux {
    server := NewServer(domain)

    r := chi.NewRouter()

    setupMiddleware(r)

    server.setupEndpoints(r)

    return r
}

Now we can create our users handlers. Think of it as a controller. I like a thin controller in other frameworks like Laravel so here I follow
the same idea.

// handlers/users.go

package handlers

import "net/http"

func (s *Server) registerUser() http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        user, err := s.domain.Register()
    }
}

We can jump after this to our data layer. Remember in the intro I did say we will use Postgres. So we will add a UserRepo to this Postgres package.
This one will follow the UserRepo interface from our domain. This will be standard ORM stuff.

// postgres/user.go

package postgres

import (
    "errors"

    "github.com/go-pg/pg/v9"

    "todo/domain"
)

type UserRepo struct {
    DB *pg.DB
}

func (u *UserRepo) GetByEmail(email string) (*domain.User, error) {
    user := new(domain.User)

    err := u.DB.Model(user).Where("email = ?", email).First()
    if err != nil {
        if errors.Is(err, pg.ErrNoRows) {
            return nil, domain.ErrNoResult
        }

        return nil, err
    }

    return user, nil
}

func (u *UserRepo) GetByUsername(username string) (*domain.User, error) {
    user := new(domain.User)

    err := u.DB.Model(user).Where("username = ?", username).First()
    if err != nil {
        if errors.Is(err, pg.ErrNoRows) {
            return nil, domain.ErrNoResult
        }

        return nil, err
    }

    return user, nil
}

func (u *UserRepo) Create(user *domain.User) (*domain.User, error) {
    _, err := u.DB.Model(user).Returning("*").Insert()
    if err != nil {
        return nil, err
    }

    return user, nil
}

func NewUserRepo(DB *pg.DB) *UserRepo {
    return &UserRepo{DB: DB}
}

Time to update our main.go with the latest change needed.

// main.go

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"

    "github.com/go-pg/pg/v9"

    "todo/domain"
    "todo/handlers"
    "todo/postgres"
)

func main() {
    DB := postgres.New(&pg.Options{
        User:     "postgres",
        Password: "postgres",
        Database: "todo_dev",
    })

    defer DB.Close()

    domainDB := domain.DB{
        UserRepo: postgres.NewUserRepo(DB),
    }

    d := &domain.Domain{DB: domainDB}

    r := handlers.SetupRouter(d)

    port := os.Getenv("PORT")
    if port == "" {
        port = "8081"
    }

    err := http.ListenAndServe(fmt.Sprintf(":%s", port), r)
    if err != nil {
        log.Fatalf("cannot start server %v", err)
    }
}

Conclusion

If you did like this tutorial don't forget to subscribe to my newsletter below. Also, the video link is at the top of the post.
If you have any question don't hesitate to ask in the comment section below.

Code for this part

Happy Coding :)

This is a cross-platform post from my blog. You can read the original here: https://equimper.com/blog/golang-rest-api-for-nodejs-developer-part-2

Golang Rest API for NodeJS developer - Part 1

Emanuel Quimper — Wed, 11 Dec 2019 14:36:23 +0000

In part 1, we will set up the foundation of our project. First, make sure you do have Go v1.13 install. On Mac, I recommend using Homebrew for that.

Go module init

First, create a folder where you will put the code for this project. Inside this folder run the command go mod init todo todo here will be the name of the project. In NodeJS we do npm init.

Setup the db connection

In this project, we will use the library go-pg so for that, we need to install it by running go get github.com/go-pg/pg. This will install the library and all the dependency.
Coming from a NodeJS background this is the equivalent of npm install. Create a folder called postgres in the root of your project and a file with the same name with go as the extension.

In this file, we will create a function New where the only job of this one is returning a pointer to a DB instance

// postgres/postgres.go

package postgres

import (
    "github.com/go-pg/pg/v9"
    _ "github.com/lib/pq"
)

func New(opts *pg.Options) *pg.DB {
    db := pg.Connect(opts)

    return db
}

I like to keep the root of the package the same name as the folder, It's a convention I like to follow and make life easier

Setup the basic handlers/endpoint

Handlers will be like our controller ish stuff. This will be where the logic of the app are bound with the client, in this case, rest API.
We will also set up middlewares and bind them to the router instance. For the routing, we use Chi and we can install it with go get github.com/go-chi/chi.
I found Chi to be the best routing library in Go. The reason is first for me to look like Express who is the routing library I use each time in NodeJS.
Also, this library follows the signature of the standard library. And in the Go community this is something they want.

// handlers/handlers.go

package handlers

import (
    "time"

    "github.com/go-chi/chi"
    "github.com/go-chi/chi/middleware"
)

type Server struct {

}

func setupMiddleware(r *chi.Mux) {
    r.Use(middleware.RequestID)
    r.Use(middleware.RealIP)
    r.Use(middleware.Compress(6, "application/json"))
    r.Use(middleware.Logger)
    r.Use(middleware.Recoverer)
    r.Use(middleware.URLFormat)
    r.Use(middleware.Timeout(60 * time.Second))
}

func NewServer() *Server {
    return &Server{}
}

func SetupRouter() *chi.Mux {
    server := NewServer()

    r := chi.NewRouter()

    setupMiddleware(r)

    server.setupEndpoints(r)

    return r
}

After this, we want some base endpoint. For this part-1 we will make just the barebone of it.

// handlers/endpoint.go

package handlers

import "github.com/go-chi/chi"

func (s *Server) setupEndpoints(r *chi.Mux) {
    r.Route("/api/v1", func(r chi.Router) {
        r.Route("/users", func(r chi.Router) {

        })
    })
}

Setup the Main function

In Go everything starts from the Main function. So in our, we will finally initialize the database plus the routing.
We also gonna make sure the router is running on a certain port. We check if the env variables provide a PORT variables else we use 8081.
This is the equivalent in NodeJS of

const port = process.env.PORT || 8081;

So create a file main.go in the root of the project and this should look like this.

// main.go

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"

    "github.com/go-pg/pg/v9"

    "todo/handlers"
    "todo/postgres"
)

func main() {
    DB := postgres.New(&pg.Options{
        User:     "postgres",
        Password: "postgres",
        Database: "todo_dev",
    })

    defer DB.Close()

    r := handlers.SetupRouter()

    port := os.Getenv("PORT")
    if port == "" {
        port = "8081"
    }

    err := http.ListenAndServe(fmt.Sprintf(":%s", port), r)
    if err != nil {
        log.Fatalf("cannot start server %v", err)
    }
}

Conclusion

Code for this part

Happy Coding :)

This is a cross-platform post from my blog. You can read the original here: https://equimper.com/blog/golang-rest-api-for-nodejs-developer-part-1

Golang Rest API for NodeJS developer - Intro

Emanuel Quimper — Mon, 09 Dec 2019 22:16:07 +0000

In the past few months, I've been working on some Golang projects. Loving it, but did get some issues. One of them is the lack of tutorials.
I mean you can find a lot of Golang tutorials online like on Youtube or Udemy etc.
But I didn't find one where I can learn how to build a full rest API or something like that.
A lot of them were just about Golang in general. Some about Golang as a full-stack solution, so you use Golang as the templating etc.
But didn't find one focussing on making Rest API.

What this tutorial will teach?

So this tutorial will be about making a Rest API but from a NodeJS developer perspective. This is a tutorial for those coming from the stack I was already showing in my channel. Those who use express etc.
We will learn how to make endpoint using Chi, how to use postgresql as the database. How to use go-pg as the orm. Also how to deal with user authentication and JWT. How
to hash and save a password etc. The basic yes, but enough so you can build a project after this tutorial. The repos will be available here and the playlist here.

I'm not saying what I show will be better than others, but I feel this tutorial can fill a gap I get when coming to Golang

Conclusion

I hope you will enjoy this tutorial, let me know in the comments if you have any question

P.S If I see people like Golang tutorial on my youtube channel, I'm planning to make one for GraphQL + Golang after

Happy Coding :)

This is a cross-platform post from my blog. You can read the original here: https://equimper.com/blog/golang-rest-api-for-nodejs-developer-intro

Build a REST API with AdonisJs and TDD Part 4

Emanuel Quimper — Tue, 03 Dec 2019 17:24:27 +0000

In this part number 4, we will continue working on our API. But now we will also make a request to another service call TheMovieDB Api.
This is finally an API where we can get info about a certain movie. In this part, we will create a new controller where the user will able to search
for a certain movie title. We first check if the movie already exists in our database. If not we then query the 3rd party API to get the info. When we got
that info we will persist them in our own database.

First, we will create a test call SearchMovie this will be another functional one.

adonis make:test SearchMovie

The first few tests will be just about the fact those movies are already inside our
database. This will make this simpler. Later for the test, we will mock TheMovieDB
so this way we will not exceed our request quotas.

// test/functional/search-movie.spec.js

'use strict'

const Factory = use('Factory')
const { test, trait } = use('Test/Suite')('Search Movie')

trait('Test/ApiClient')
trait('Auth/Client')

test('can query for a certain movie title', async ({ assert, client }) => {
  await Factory.model('App/Models/Movie').create({ title: 'Joker' })

  const response = await client.get('/api/movies?title=Joker').end();

  response.assertStatus(200)
  response.assertJSONSubset([{
    title: 'Joker',
  }])
})

If you run the test you will get an error like this

can query for a certain movie title
  TypeError: Cannot read property 'name' of undefined
    at Factory.model

This means we didn't define yet our factory for the movie.

// database/factory.js

'use strict'

/*
|--------------------------------------------------------------------------
| Factory
|--------------------------------------------------------------------------
|
| Factories are used to define blueprints for database tables or Lucid
| models. Later you can use these blueprints to seed your database
| with dummy data.
|
*/

/** @type {import('@adonisjs/lucid/src/Factory')} */
const Factory = use('Factory')

Factory.blueprint('App/Models/User', faker => {
  return {
    username: faker.username(),
    email: faker.email(),
    password: 'password123'
  }
})

Factory.blueprint('App/Models/Challenge', faker => {
  return {
    title: faker.sentence(),
    description: faker.sentence()
  }
})

Factory.blueprint('App/Models/Movie', (faker, index, data) => {
  return {
    title: faker.sentence(),
    ...data
  }
})

If you check, the factory take 3 arguments and the third one is for getting data from when you call the factory. So you can overide value just like that.

If you rerun the test with npm t you will get now a new error. This error is about the fact then we
do not have yet a model Movie and our factory tries to create one with it. For this run the command

adonis make:model Movie -m

If you remember the -m means give me a migration file at the same time. We will just win some time with this.

Now the test will show this

Error: SQLITE_ERROR: table movies has no column named title

Pretty self explain the error, we try to add a title to but no column yet is defined. Time to add this to the migration file we just did create.

'use strict'

/** @type {import('@adonisjs/lucid/src/Schema')} */
const Schema = use('Schema')

class MovieSchema extends Schema {
  up () {
    this.create('movies', (table) => {
      table.increments()

      table.string('title').notNullable()

      table.timestamps()
    })
  }

  down () {
    this.drop('movies')
  }
}

module.exports = MovieSchema

After this we get

expected 404 to equal 200
404 => 200

Normal the route is not created yet. Add this to your routes.js file

// start/routes.js

Route.group(() => {
  Route.get('/', 'MovieController.index')
}).prefix('/api/movies')

Now almost the same error but if you check carefully you will see now the error is about a 500 error not 404 like before. It's because the controller does not exist yet.

Time to make an HTTP controller

adonis make:controller Movie

Ooooh, same error? Yes, we did use a method called index but our controller is empty.

// app/Controllers/Http/MovieController.js

'use strict'

class MovieController {
  async index({}) {

  }
}

module.exports = MovieController

It's time now to do some stuff to fix the new error about 204 for no-content.
We first need to get the query title and after this fetch our database with this and return that with a 200 status code.

// app/Controllers/Http/MovieController.js

'use strict'

const Movie = use('App/Models/Movie')

class MovieController {
  async index({ request, response }) {
    const movies = await Movie.query()
      .where('title', request.input('title'))
      .fetch()

    return response.ok(movies)
  }
}

module.exports = MovieController

The input method in the request object gives us a way to fetch the query argument we want. In this case that was the title where we did put Joker in it. If you run your test at this point this will work.
But... I don't like that. First, in this way of doing, we need a match of 100% the title. What happens if the user just put jok and not the full Joker title. Time to create a new test for this case.

test('can query with a subset of the title', async ({ assert, client }) => {
  await Factory.model('App/Models/Movie').create({ title: 'Joker' })

  const response = await client.get('/api/movies?title=jok').end();

  response.assertStatus(200)
  response.assertJSONSubset([{
    title: 'Joker',
  }])
})

Now when you run the test we see that fail. Time to make use of a real query search

// app/Controllers/Http/MovieController.js

'use strict'

const Movie = use('App/Models/Movie')

class MovieController {
  async index({ request, response }) {
    const title = request.input('title')

    const movies = await Movie.query()
      .where('title', 'LIKE', `%${title}%`)
      .fetch()

    return response.ok(movies)
  }
}

module.exports = MovieController

Now this works with this change. This will make sure if a subset of the title is present at least we still give the movie to the user.

Time to force the user to provide a title pretty simple one here too

test('should throw 400 if no title is pass', async ({ assert, client }) => {
  const response = await client.get('/api/movies').end()

  response.assertStatus(400)
})

// app/Controllers/Http/MovieController.js

'use strict'

const Movie = use('App/Models/Movie')

class MovieController {
  async index({ request, response }) {
    const title = request.input('title')

    if (!title) {
      return response.status(400).json({ error: 'title is required' })
    }

    const movies = await Movie.query()
      .where('title', 'LIKE', `%${title}%`)
      .fetch()

    return response.ok(movies)
  }
}

module.exports = MovieController

Conclusion

In the next part, we will jump on the TheMovieDB API stuff. We will learn how we can mock an external API so it's easier to test.

I hope you enjoy the post. Don't hesitate to comment below.

Source Code: https://github.com/EQuimper/adonis-tdd-tutorial-demo/tree/part-4

Happy Coding :)

This is a cross-platform post from my blog. You can read the original here: https://equimper.com/blog/build-a-rest-api-with-adonisjs-and-tdd-part-4

Build a REST API with AdonisJs and TDD Part 3

Emanuel Quimper — Fri, 29 Nov 2019 14:13:20 +0000

In this part, we jump straight back to our challenges API endpoint where we will add a way to a user to fetch all his own challenges. Also would be nice if the user can update and delete an own challenge.

Get /api/me/challenges

First thing create a new functional test by running

adonis make:test GetUserChallenges

In the test, we will write it in one go.

'use strict'

const Factory = use('Factory')
const { test, trait } = use('Test/Suite')('Get User Challenges')

trait('Test/ApiClient')
trait('Auth/Client')

test('can get all the user challenges', async ({ assert, client }) => {
  const user = await Factory.model('App/Models/User').create()
  const otherUser = await Factory.model('App/Models/User').create();
  const challenges = await Factory.model('App/Models/Challenge').makeMany(2)
  const otherChallenges = await Factory.model('App/Models/Challenge').makeMany(2)

  await user.challenges().saveMany(challenges)
  await otherUser.challenges().saveMany(otherChallenges)

  const response = await client
    .get('/api/me/challenges')
    .loginVia(user, 'jwt')
    .end()

  response.assertStatus(200)

  assert.equal(response.body.length, 2);

  response.assertJSONSubset([
    { title: challenges[0].title },
    { title: challenges[1].title }
  ])
})

This test start we 2 user. One who will be our, and one different user. We also make 2 challenges for us and 2 for the other user.

We make sure here don't save it right to the DB. We want to be able to add the relation with the user.

So we add the challenges to the user with the saveMany method who batch save those challenges. We do the same
with the other user.

We create a response where we log the user with JWT. After this, we check for a status 200 Ok. Also, we want to make sure
I just receive 2 challenges, no more, no less. I don't want this endpoint to return me challenges from a others user.
I add the last check to make sure the 2 challenges we got are the one in the challenges variables.

If you run the test with adonis test or yarn test you will get 404 error. Remember this mean routes not exist. So jump to the file routes.js and add this line.

Route.get('/api/me/challenges', 'MeController.challenges').middleware(['auth'])

Here this route is nothing too strange, we make sure user is authenticated by using the middleware auth. We did that already :) Only thing change is I make use of another controller call MeController. I can have put it inside the ChallengeController but the thing is I like the controller to look like the route's path.

You can create a controller by running

adonis make:controller Me

Go inside the new file created and add this code to the class

async challenges() {

}

Now your test will have error cause we return nothing etc. Time to add the logic, and wow Adonis make your life soooo easy.

class MeController {
  async challenges({ response ,auth}) {
    const user = await auth.getUser();

    const challenges = await user.challenges().fetch();

    return response.ok(challenges.toJSON());
  }
}

First, we need to get the current user. By using the auth.getUser function we can get it. After this to get the challenges we can then
ask the user to fetch all the challenges owned. This is possible cause of the user model we have done in the first part.

challenges() {
  return this.hasMany('App/Models/Challenge')
}

This challenges method inside the User model gives us the one owned by the user. The thing is those challenges will not be in JSON format so that's why inside the response
we ask the toJSON method.

Now if you run your test all should be green :)

Put /api/challenges/:id

Now time to work on the update endpoint. First, create a new test

adonis make:test UpdateChallenge

We will need to test here, the first one is to make sure a user who is the author of the challenge can update it and see the change. The second test is to make
sure we don't let other users update a challenge.

'use strict'

const Factory = use('Factory')
const { test, trait } = use('Test/Suite')('Update Challenge')

trait('Test/ApiClient')
trait('Auth/Client')

test('a user can update a challenge owned', async ({ client }) => {
  const user = await Factory.model('App/Models/User').create()
  const challenge = await Factory.model('App/Models/Challenge').make()

  await user.challenges().save(challenge)

  const data = {
    title: 'This is my new title'
  }

  const response = await client
    .put(`/api/challenges/${challenge.id}`)
    .loginVia(user, 'jwt')
    .send(data)
    .end()

  response.assertStatus(200)

  response.assertJSONSubset({
    id: challenge.id,
    title: data.title
  })
})

For the first test, this is pretty simple. We first create a user and link the challenge. We then create a data object who will contain the new title. We then use the client and send to the endpoint this data. We check the response to make sure this is 200 ok and also the JSON contains the same id and the new title.

Run test, see it fail. Time to create the route first.

Route.put('/api/challenges/:id', 'ChallengeController.update')
  .validator('UpdateChallenge')
  .middleware(['auth'])

The route is pretty simple, but we add a validator. I will not do the test for this cause this is pretty easy and I want to give you more on the business logic.

For creating the validator just run

adonis make:validator UpdateChallenge

And inside this one paste that

'use strict'

class UpdateChallenge {
  get rules() {
    return {
      title: 'string',
      description: 'string'
    }
  }

  get messages() {
    return {
      string: '{{ field }} is not a valid string'
    }
  }

  get validateAll() {
    return true
  }

  async fails(errorMessages) {
    return this.ctx.response.status(400).json(errorMessages)
  }
}

module.exports = UpdateChallenge

This is like the CreateChallenge validator but nothing is required.

Inside your ChallengeController now add this method

async update({ response, request, params, auth }) {
  const user = await auth.getUser()

  const challenge = await Challenge.findOrFail(params.id)

  if (challenge.user_id !== user.id) {
    throw new UnauthorizedException();
  }

  challenge.merge(request.only(['title', 'description']));

  await challenge.save();

  return response.ok(challenge)
}

This update method will first get the user. Then find the challenge. This will return a free 404 if the challenge doesn't exist. After this, we check for the
user_id key in the challenge to see if that match the current user. If not we throw an Exception.

Time to make the exception

adonis make:exception UnauthorizedException

'use strict'

const { LogicalException } = require('@adonisjs/generic-exceptions')

class UnauthorizedException extends LogicalException {
  handle(error, { response }) {
    response.status(401).send('Not authorized')
  }
}

module.exports = UnauthorizedException

This one will return a 401 with the message Not authorized.

After this, if the user is the author we merge the request object for only title and description. Only fields we accept an update.

We make sure to save the challenge, if not this will not persist. And finally, we return this challenge with the status 200.

If you run the test all should be green. But we need to make sure a nonauthor cannot update.

test('cannot update challenge if not the author', async ({
  assert,
  client
}) => {
  const user = await Factory.model('App/Models/User').create()
  const otherUser = await Factory.model('App/Models/User').create()
  const challenge = await Factory.model('App/Models/Challenge').make()

  await otherUser.challenges().save(challenge)

  const data = {
    title: 'This is my new title'
  }

  const response = await client
    .put(`/api/challenges/${challenge.id}`)
    .loginVia(user, 'jwt')
    .send(data)
    .end()

  response.assertStatus(401)

  const _challenge = await use('App/Models/Challenge').find(challenge.id)

  // check if the title really didn't change
  assert.notEqual(_challenge.title, data.title)
})

All should be green :)

Time to work on the delete portion

adonis make:test DeleteUserChallenge

You must be good now with the basic stuff :) Lot of repetitive think here, but you win a lot of trust in your project.

'use strict'

const Factory = use('Factory')
const { test, trait } = use('Test/Suite')('Delete Challenge')

trait('Test/ApiClient')
trait('Auth/Client')

test('a user can delete a challenge owned', async ({ client }) => {
  const user = await Factory.model('App/Models/User').create()
  const challenge = await Factory.model('App/Models/Challenge').make()

  await user.challenges().save(challenge)

  const response = await client
    .delete(`/api/challenges/${challenge.id}`)
    .loginVia(user, 'jwt')
    .end()

  response.assertStatus(204)
})

test('cannot delete challenge if not the author', async ({
  assert,
  client
}) => {
  const user = await Factory.model('App/Models/User').create()
  const otherUser = await Factory.model('App/Models/User').create()
  const challenge = await Factory.model('App/Models/Challenge').make()

  await otherUser.challenges().save(challenge)

  const response = await client
    .delete(`/api/challenges/${challenge.id}`)
    .loginVia(user, 'jwt')
    .end()

  response.assertStatus(401)

  const _challenge = await use('App/Models/Challenge').find(challenge.id)

  assert.isNotNull(_challenge)
})

First, we will test a current user who owns the challenge can delete it. It's almost a copy and paste of the update method. Same for the version where the user cannot delete a challenge if not own.

For the routes now you should add

Route
  .delete('/api/challenges/:id', 'ChallengeController.delete')
  .middleware([
    'auth'
  ])

And for your controller, it's easy like that

  async destroy({ response, params, auth }) {
    const user = await auth.getUser()

    const challenge = await Challenge.findOrFail(params.id)

    if (challenge.user_id !== user.id) {
      throw new UnauthorizedException();
    }

    await challenge.delete()

    return response.noContent();
  }

Remember findOrFail give you a free 404 if the challenge doesn't exist. We need to just throw 401 exceptions if the user is not the author.

The routes file

If you look right now at your routes file this will look something like that

Route.get('/api/challenges', 'ChallengeController.all')
Route.get('/api/challenges/:id', 'ChallengeController.show')
Route.put('/api/challenges/:id', 'ChallengeController.update')
  .validator('UpdateChallenge')
  .middleware(['auth'])
Route.post('/api/challenges', 'ChallengeController.store')
  .validator('CreateChallenge')
  .middleware(['auth'])
Route.delete('/api/challenges/:id', 'ChallengeController.destroy').middleware([
  'auth'
])

Route.get('/api/me/challenges', 'MeController.challenges').middleware(['auth'])

Must be another way of doing this repetetive task ? And yes we can make use of grouping

Route.group(() => {
  Route.get('/', 'ChallengeController.all')
  Route.get('/:id', 'ChallengeController.show')
}).prefix('/api/challenges')
Route.group(() => {
  Route.post('/', 'ChallengeController.store').validator('CreateChallenge')
  Route.put('/:id', 'ChallengeController.update').validator('UpdateChallenge')
  Route.delete('/:id', 'ChallengeController.destroy')
}).prefix('/api/challenges').middleware(['auth'])

If you ask why do we don't nested them, it's because right now we can't with the version we run. This is the error you will get

RuntimeException: E_NESTED_ROUTE_GROUPS: Nested route groups are not allowed

I hope you enjoy this post :) And we talk in part 4 where we will start to add a bit more interaction with the API :)

Source Code: https://github.com/EQuimper/adonis-tdd-tutorial-demo/tree/part-3

Happy Coding :)

This is a cross-platform post from my blog. You can read the original here: https://equimper.com/blog/build-a-rest-api-with-adonisjs-and-tdd-part-3

Build a REST API with AdonisJs and TDD Part 2

Emanuel Quimper — Thu, 28 Nov 2019 14:32:36 +0000

In this part, we will continue our Movies rest API with TDD. We will go a bit faster cause we now know the step we need to make in order to follow the TDD approach.

Fail -> Pass -> Refactor

Quick Fixes

In the last part, we make use, in testing env, of the DB postgres. Nothing bad with that, it's ok to use it. But I think will be faster in the long run if we make use of SQLite.

Don't worry again Adonis have made it easy for us :)

First, run

npm i -D sqlite3

This will install the drive we need for SQLite as a Dev Dependencies.

Now go inside your .env.testing file and put those lines

DB_CONNECTION=sqlite
DB_HOST=127.0.0.1
DB_PORT=3306
DB_USER=root
DB_PASSWORD=
DB_DATABASE=movies_challenges_test

Don't forget to remove the other one who touches the db.

Now if you rerun the test with adonis test you should see all test pass

If you compare this to before you can see we get a bit faster. This will get faster more and more test we will add. SQLite is a in-memory db.

Get /api/challenges

Here, as the title says, we will work on the GET request who gonna give us all the challenges in our API. For now and for the purpose of the tutorial, we don't gonna worry about the pagination, etc.

adonis make:test GetChallenges

And choose Functional test

Go to the new file

test/functional/get-challenges.spec.js

Like in the past test file we need to import the Factory and get the trait

'use strict'

const Factory = use('Factory')
const { test, trait } = use('Test/Suite')('Get Challenges')

trait('Test/ApiClient')
trait('Auth/Client')

test('make sure 2 + 2 is 4', async ({ assert, client }) => {
  assert.equal(2 + 2, 4)
})

Time to write the first test. First, what do we want to achieve here? For this endpoints, we want to make sure we can get all the challenges we have to save inside the database. This will be quite simple here.

'use strict'

const Factory = use('Factory')
const { test, trait } = use('Test/Suite')('Get Challenges')

trait('Test/ApiClient')
trait('Auth/Client')

test('can get all the challenges', async ({ assert, client }) => {
  const challenges = await Factory.model('App/Models/Challenge').createMany(3)

  const response = await client.get('/api/challenges').end()

  response.assertStatus(200)

  response.assertJSONSubset([
    { title: challenges[0].title },
    { title: challenges[1].title },
    { title: challenges[2].title },
  ])
})

Here we first create 3 challenges by using the createMany method on Factory. After we check the response status equal 200 and also the JSON response have all 3 titles inside the return array.

If you run the test this is what you see.

Make sense we didn't create the route yet. Go to the route file and add

Route.get('/api/challenges', 'ChallengeController.all')

Now if you add this line to your test file

console.log('error', response.error)

After the response promise resolve you will see.

'RuntimeException: E_UNDEFINED_METHOD: Method all missing on App/Controllers/Http/ChallengeController\n> More details: https://err.sh/adonisjs/errors/E_UNDEFINED_METHOD'

This is normal, we make use of a method in controller who do not exist.

Go inside your ChallengeController and add this method

async all({ response, request }) {
  const challenges = await Challenge.all()

  return response.ok(challenges)
}

Now after running the test, all should be green :)

This call the all method from your Challenge model and this will return an array of all the challenge available. The response.ok will return a JSON object with the status 200 OK :)

Get /api/challenges/:id

Time to work on getting a single challenge by his id.

Pretty simple work again, just need to follow those step.

adonis make:test GetChallenge

You can copy and paste the last test we create about to get all challenges this will look almost the same.

'use strict'

const Factory = use('Factory')
const { test, trait } = use('Test/Suite')('Get Challenge')

trait('Test/ApiClient')
trait('Auth/Client')

test('can get a challenge by id', async ({ assert, client }) => {
  const challenges = await Factory.model('App/Models/Challenge').createMany(3)

  const challenge = challenges[0]

  const response = await client.get(`/api/challenges/${challenge.id}`).end()

  response.assertStatus(200)

  response.assertJSONSubset({ title: challenge.title, id: challenge.id })
})

A pretty simple one, we create 3 challenges just to make it a bit more realistic. We after that create a variable challenge who will be the first one in the array. We then add the id to the URL. In the end, we check for the status 200 and also the JSON will need to have both title and id who match this challenge.

Follow the same step we have made before, so go to routes and add the route for this one.

Route.get('/api/challenges/:id', 'ChallengeController.show')

After this, your test will say we don't have the method in your controller. Time to add this

async show({ response }) {
  return response.ok({})
}

The next error is important, is the one who checks if the return object matches what we supposed. It's pretty normal it failed here we return an empty object. So time to make it work.

async show({ response, params }) {
  const challenge = await Challenge.find(params.id)

  return response.ok(challenge)
}

For getting access of the params id we make use of the params object and we then call find from the Challenge Model.

If you run all the test now all will be green.

But we need one more test for this endpoint. What will happen if the id do not exist?

If you try it this will fail. A pretty easy test to write

test('status 404 if id do not exist', async ({ assert, client }) => {
  const response = await client.get('/api/challenges/999').end()

  response.assertStatus(404)
})

Does the error say 204 should equal 404? Umh strange, time to fix it.

async show({ response, params }) {
  const challenge = await Challenge.findOrFail(params.id)

  return response.ok(challenge)
}

Yes, only one thing to change, findOrFail like the name says will return 404 if the object is not found :) Really nice and easy :)

Source code: https://github.com/EQuimper/adonis-tdd-tutorial-demo/tree/part-2

End word

Hope you enjoy this one, not too much, but we start to understand the flow and see how TDD help us going faster on the implementation of the API.

In the next part, we will add a way for a user to get all of his challenges. And also a way to update and delete the challenge if you are the author.

Happy coding :)

This is a cross-platform post from my blog. You can read the original here: https://equimper.com/blog/build-a-rest-api-with-adonisjs-and-tdd-part-2

Build a REST API with AdonisJs and TDD Part 1

Emanuel Quimper — Mon, 25 Nov 2019 20:10:42 +0000

Hello dev.to :) My first post here :)

I've been playing lately with AdonisJs a NodeJS MVC framework who look a lot like Laravel a really popular PHP framework. I really started to love the Adonis approach, more convention than configuration. I also love the fact they say in the headline.

Writing micro-services or you are a fan of TDD, it all boils down to confidence. AdonisJs simplicity will make you feel confident about your code.

In the past few month, I wrote all my backend project with the TDD pattern, and I really feel this help me getting more productive, and more confident with my code. I know TDD is not perfect, can slow you down, when you start, but I really think this can improved your code in the long term.

About this tutorial

So in this tutorial we gonna build kind of a bucket list for movies to watch. A user can create a challenge, and put movies to this one. I know, this is not the most awesome project ever, but this will help you see how Lucid, the Adonis ORM work with relationship. We gonna also see how easy this framework will make our live.

At the end of this tutorial, we gonna create a service where a user can finally enter just the name of the movie and the year. Us we will use TheMovieDB Api and find info about this movie.

Getting Started

First we need to install the Adonis cli

npm i -g @adonisjs/cli

To make sure everything work run the command in your terminal

adonis --help

If you see a list of command that mean this is working :)

For creating the project we will run this command in the terminal

adonis new movies_challenges --api-only

Here this will create a new project call movies_challenges and this will be an api only boilerplate, so no ui with this.

Follow the instructions

cd movies_challenges

For running the project the command will be

adonis serve --dev

But for us we don't really need cause all the interaction will be done from the testing.

Open the project in your text-editor of choice. For myself I use VSCode it's free and awesome.

Setup the db

Adonis have setup lot of stuff for us. But they let us choosing some stuff like which db to use etc. If you open the file config/database.js you will see sqlite, mysql and postgresql config. For this project I will be using Posgresql

To make it work we need to follow the instruction they provide at the bottom of this file.

npm i --save pg

After this go inside your .env file and setup the connection for your db. For me this will look like

DB_CONNECTION=pg
DB_HOST=127.0.0.1
DB_PORT=5432
DB_USER=postgres
DB_PASSWORD=postgres
DB_DATABASE=movies_challenges_dev

After I make sure I create the db from my terminal

createdb movies_challenges_dev

Setup the testing environnment

Adonis don't came with a testing framework out-of-the-box, but it's really easy to make it work.

Run the command

adonis install @adonisjs/vow

What is that ? Adonis have a way to install dependency by using npm internally. But the beauty of this it's they can add other stuff also. Like if you look what happen after this is done, they will open a a url in your browser with other instructions.

They have create 3 new files.

.env.testing
vowfile.js
example.spec.js

First we will setup the .env.testing file to make sure we it a test db and not the dev one.

Append that to the end of the file

DB_CONNECTION=pg
DB_HOST=127.0.0.1
DB_PORT=5432
DB_USER=postgres
DB_PASSWORD=postgres
DB_DATABASE=movies_challenges_test

After I make sure I create the db from my terminal

createdb movies_challenges_test

Writing your first test

So the way the app will work is a User can have many Challenges. Those challenge can have many movie to it. But movie can be to many challenge.

So in relationship this will look like

If you have check a bit the folder structure you will see Adonis give use User model and Auth of the box.

We will use this in the future.

So for making your first test file we will need to think about what we need to do.

The first thing I want to test is the fact a user can create a challenge. A challenge need to have a title, and a description is optionnal. I want to make sure only a authenticate user can create a challenge. When a challenge is create I need to put the current_user id to the data. So we will know who is the owner.

Adonis give us lot of tool to make our live easier. One of them is generator command thank to ace. We will use a command to make our first test. But to be able to do this we need to register the vow test framework to the provider of the project. Open start/app.js and add this to your aceProvider

const aceProviders = [
  '@adonisjs/lucid/providers/MigrationsProvider',
  '@adonisjs/vow/providers/VowProvider',
]

Now we can run the command

adonis make:test CreateChallenge

When you get ask unit or functionnal test use functionnal and click enter.

This will create a file

test/functional/create-challenge.spec.js

Nice first test file create :)

We will change the title of this test to be more useful.

test('can create a challenge if valid data', async ({ assert }) => {})

Now the way I wrote test is by creating the assertion first. After I then go backward and create the step I need to make it work.

test('can create a challenge if valid data', async ({ assert }) => {

  const response = // do api call

  response.assertStatus(201)
  response.assertJSONSubset({
    title: 'Top 5 2018 Movies to watch',
    description: 'A list of 5 movies from 2018 to absolutely watched',
    user_id: // to do
  })
})

Here I test than I want to receive back from my api call a 201 created with a certain object who will have the title a provide, the description I provide, and my current user id.

Next we need to write the code for the response

const { test, trait } = use('Test/Suite')('Create Challenge')

trait('Test/ApiClient')

test('can create a challenge if valid data', async ({ assert, client }) => {

  const data = {
    title: 'Top 5 2018 Movies to watch',
    description: 'A list of 5 movies from 2018 to absolutely watched'
  }

  const response = await client.post('/api/challenges').send(data).end()

  response.assertStatus(201)
  response.assertJSONSubset({
    title: data.title,
    description: data.description,
    user_id: // to do
  })
})

To make a api call we need to import first trait from the test suite. We need to told the test we want the api client. This will give us now access to client in the callback. I then put my data I want to an object and send it to a route with the verb POST.

Now I want to test with a current user jwt in the headers. How can we do this ? This is so easy with Adonis

'use strict'

const Factory = use('Factory')
const { test, trait } = use('Test/Suite')('Create Challenge')

trait('Test/ApiClient')
trait('Auth/Client')

test('can create a challenge if valid data', async ({ assert, client }) => {
  const user = await Factory.model('App/Models/User').create()

  const data = {
    title: 'Top 5 2018 Movies to watch',
    description: 'A list of 5 movies from 2018 to absolutely watched',
  }

  const response = await client
    .post('/api/challenges')
    .loginVia(user, 'jwt')
    .send(data)
    .end()

  response.assertStatus(201)
  response.assertJSONSubset({
    title: data.title,
    description: data.description,
    user_id: user.id,
  })
})

OMG !!! Too much. DONT WORRY. We just need to break it down a bit. So first what is Factory. Factory is a way to make dummy data easier. This come with a really nice api. Here the Factory will create a user to the db. But how can the factory know the data we want ? Easy just open the database/factory.js file and add this at the bottom

const Factory = use('Factory')

Factory.blueprint('App/Models/User', faker => {
  return {
    username: faker.username(),
    email: faker.email(),
    password: 'password123',
  }
})

Here we create a Factory for the Models user we have in the db. This use faker also who is a library who make dummy data so much easier. Here I put a fake username and email. But why I don't do this to password ? It's because when I will need to test login I want to be able to log, and because the password will become hash I need to know what is the original version.

So this line

const user = await Factory.model('App/Models/User').create()

We create a user to the db, now we can use this same user here in the request

const response = await client
  .post('/api/challenges')
  .loginVia(user, 'jwt')
  .send(data)
  .end()

As you can see we can now use loginVia and pass the user at first argument, the second argument is the type of auth here I say jwt. I can use .loginVia cause of this trait at the top

trait('Auth/Client')

Now in my json response I can now check the user id is really the one of the current user

response.assertJSONSubset({
  title: data.title,
  description: data.description,
  user_id: user.id,
})

One think we need to do before going further and run the test is we need to see the error from the response to do a real tdd.

So we will add this line before the assertion

console.log('error', response.error)

Now we can run the test with the command adonis test

You will see the error

error: relation "users" does not exist

What that mean ? It's because Vow by default don't run migration. But us a developer we don't want to run it manually on every test that will be painful. What can we do ? Adonis make again our live easy. Go in the file vowfile.js and uncomment the code already wrote for this

On line 14: const ace = require('@adonisjs/ace')
On line 37: await ace.call('migration:run', {}, { silent: true })
On line 60: await ace.call('migration:reset', {}, { silent: true })

Now if you rerun the test you will see

error { Error: cannot POST /api/challenges (404)

Nice one step further :) This error mean we don't have a route. We need to create it. Open start/routes.js and add this code

Route.post('/api/challenges', 'ChallengeController.store')

Here I say, when we get a post request to the route /api/challenges pass the data to the controller ChallengeController and the methods store. Remember Adonis is MVC so yes we need controller :)

Save the code and rerun the test

Now in the text of the error you will see

Error: Cannot find module \'/Users/equimper/coding/tutorial/movies_challenges/app/Controllers/Http/ChallengeController\'

This mean the controller don't exist :) So we need to create one. Again adonis have a generator for this

adonis make:controller ChallengeController

When ask choose http not websocket

Rerun the test

'RuntimeException: E_UNDEFINED_METHOD: Method store missing on App/Controllers/Http/ChallengeController\n> More details: https://err.sh/adonisjs/errors/E_UNDEFINED_METHOD'

Method store is missing. Fine this is normal the controller is empty. Add this to your file

// app/Controllers/Http/ChallengeController.js
class ChallengeController {
  store() {}
}

Rerun the test

expected 204 to equal 201
204 => 201

So now this is where the fun start, we expected 201 but received 204. We can fix this error by adding

class ChallengeController {
  store({ response }) {
    return response.created({})
  }
}

Adonis give us the response object who can be destructuring from the arguments of the method. Here I want to return 201 who mean created so I can use the created function. I pass an empty object so I can see my test failing further

 expected {} to contain subset { Object (title, description, ...) }
  {
  + title: "Top 5 2018 Movies to watch"
  + description: "A list of 5 movies from 2018 to absolutely watched"
  + user_id: 1
  }

Here the error mean we send nothing but expected stuff. Now time to do the logic.

const Challenge = use('App/Models/Challenge')

class ChallengeController {
  async store({ response, request }) {
    const challenge = await Challenge.create(
      request.only(['title', 'description'])
    )

    return response.created(challenge)
  }
}

I add an import at the top, this is my challenge model I plan to created in future test. Now I can make use of async and also the request object to create a challenge. The only method info can be see here.

Now if I rerun the test I see

'Error: Cannot find module \'/Users/equimper/coding/tutorial/movies_challenges/app/Models/Challenge\''

Fine make sense the model don't exist

adonis make:model Challenge -m

The -m give you the migration file also

This command will created

✔ create  app/Models/Challenge.js
✔ create  database/migrations/1546449691298_challenge_schema.js

Now if we return the test

'error: insert into "challenges" ("created_at", "description", "title", "updated_at") values ($1, $2, $3, $4) returning "id" - column "description" of relation "challenges" does not exist'

Make sense the table don't have a column description. So we should add one

So open your migration file for the challenge_schema

class ChallengeSchema extends Schema {
  up() {
    this.create('challenges', table => {
      table.text('description')
      table.increments()
      table.timestamps()
    })
  }

  down() {
    this.drop('challenges')
  }
}

Here I add a colum text call description

Rerun the test

'error: insert into "challenges" ("created_at", "description", "title", "updated_at") values ($1, $2, $3, $4) returning "id" - column "title" of relation "challenges" does not exist'

Now is the same error but for title

class ChallengeSchema extends Schema {
  up() {
    this.create('challenges', table => {
      table.string('title')
      table.text('description')
      table.increments()
      table.timestamps()
    })
  }

  down() {
    this.drop('challenges')
  }
}

Here title will be a string. Now rerun the test

  expected { Object (title, description, ...) } to contain subset { Object (title, description, ...) }
  {
  - created_at: "2019-01-02 12:28:37"
  - id: 1
  - updated_at: "2019-01-02 12:28:37"
  + user_id: 1
  }

The error mean the title and description are save, but the user_id don't exist, so we need to add the relation in the migration and the model

Again in the migration file add

class ChallengeSchema extends Schema {
  up() {
    this.create('challenges', table => {
      table.string('title')
      table.text('description')
      table
        .integer('user_id')
        .unsigned()
        .references('id')
        .inTable('users')
      table.increments()
      table.timestamps()
    })
  }

  down() {
    this.drop('challenges')
  }
}

Here the user_id is a integer, reference the id of a user in the users table

Now open the Challenge model in app/Models/Challenge.js and add this code

class Challenge extends Model {
  user() {
    return this.belongsTo('App/Models/User')
  }
}

And we need to do the other way of relation so open app/Models/User.js and add at the bottom after tokens

challenges() {
  return this.hasMany('App/Models/Challenge')
}

Wow I love this syntax and how easy we can see the relations. Thank to Adonis team and Lucid ORM :)

Run the test

 expected { Object (title, description, ...) } to contain subset { Object (title, description, ...) }
  {
  - created_at: "2019-01-02 12:35:20"
  - id: 1
  - updated_at: "2019-01-02 12:35:20"
  + user_id: 1
  }

Same error ? Yes when we create we didn't put the user_id. So we need to

class ChallengeController {
  async store({ response, request, auth }) {
    const user = await auth.getUser()

    const challenge = await Challenge.create({
      ...request.only(['title', 'description']),
      user_id: user.id,
    })

    return response.created(challenge)
  }
}

Here I make use of auth, who is a object we method touching the authentication. Here I can use the current user with the function auth.getUser. This will return the user from the jwt. Now I can then merge this to the object when create.

Now if you run your test all should work. BUTTTTT this is not done. We need a test to make sure the user is really authenticate, cause now this endpoint is accessible by everyone.

Add to our test file

test('cannot create a challenge if not authenticated', async ({
  assert,
  client,
}) => {})

Again we gonna work with the same idea, building the assertion first and going backward

test('cannot create a challenge if not authenticated', async ({
  assert,
  client,
}) => {
  response.assertStatus(401)
})

Here we want the status to be 401 unauthorized

test('cannot create a challenge if not authenticated', async ({
  assert,
  client,
}) => {
  const data = {
    title: 'Top 5 2018 Movies to watch',
    description: 'A list of 5 movies from 2018 to absolutely watched',
  }

  const response = await client
    .post('/api/challenges')
    .send(data)
    .end()

  console.log('error', response.error)

  response.assertStatus(401)
})

First make sure to delete the console.log from the other test. Now your test should look like that here.

Open your routes file

Route.post('/api/challenges', 'ChallengeController.store').middleware(['auth'])

If you run the test all will be green :)

But now I will like to test the fact then title is required and both description and title need to be a string how can I do this ?

Adonis give us access to another really nice tool can validator.

We need to install the validator library

adonis install @adonisjs/validator

Go to start/app.js and add the provider

const providers = [
  '@adonisjs/framework/providers/AppProvider',
  '@adonisjs/auth/providers/AuthProvider',
  '@adonisjs/bodyparser/providers/BodyParserProvider',
  '@adonisjs/cors/providers/CorsProvider',
  '@adonisjs/lucid/providers/LucidProvider',
  '@adonisjs/validator/providers/ValidatorProvider',
]

Now go back to our test file for challenge and add a new one

test('cannot create a challenge if no title', async ({ assert }) => {})

Before going further, I don't like the fact I need to manually wrote the title and description. I would like to be able to make the factory create it for us. This is possible, first go to database/factory.js

We need to create a Factory for the Challenge

Factory.blueprint('App/Models/Challenge', faker => {
  return {
    title: faker.sentence(),
    description: faker.sentence()
  }
});

Now we can use this with the help of make

const { title, description } = await Factory.model(
  'App/Models/Challenge'
).make()

This will give us a fake title and description but without being save to the db.

Going back to the test will would like to receive error if the title is not in the body

test('cannot create a challenge if no title', async ({ assert, client }) => {
  response.assertStatus(400)
  response.assertJSONSubset([
    {
      message: 'title is required',
      field: 'title',
      validation: 'required',
    },
  ])
})

Now we need to write the code to get to this. I will skip some process, but hey continue it, this is how we get better. I will just not wrote it cause that take lot and lot of line :)

test('cannot create a challenge if no title', async ({ assert, client }) => {
  const user = await Factory.model('App/Models/User').create()
  const { description } = await Factory.model('App/Models/Challenge').make()

  const data = {
    description,
  }

  const response = await client
    .post('/api/challenges')
    .loginVia(user, 'jwt')
    .send(data)
    .end()

  response.assertStatus(400)
  response.assertJSONSubset([
    {
      message: 'title is required',
      field: 'title',
      validation: 'required',
    },
  ])
})

First we create a user to be able to log, cause we need to be authenticated remember :)

Second I get a fake description from my factory. I just send this one.

I assert I receive a 400 for bad request and a json array of error message.

If I run the test now I receive

expected 201 to equal 400
  201 => 400

That mean the Challenge get create but shouldn't

So we need to add a validator for this

adonis make:validator CreateChallenge

Go inside your routes file and we want to use this

Route.post('/api/challenges', 'ChallengeController.store')
  .validator('CreateChallenge')
  .middleware(['auth'])

Now if you run the test you will see

expected 201 to equal 400
  201 => 400

Make sense the validator break stuff. Time to wrote some code. Open app/Validators/CreateChallenge.js

class CreateChallenge {
  get rules() {
    return {
      title: 'required|string',
      description: 'string',
    }
  }

  get messages() {
    return {
      required: '{{ field }} is required',
      string: '{{ field }} is not a valid string',
    }
  }

  get validateAll() {
    return true
  }

  async fails(errorMessages) {
    return this.ctx.response.status(400).json(errorMessages)
  }
}

Here I add some rules, messages, and I also show the fails with a status 400 for bad request. I also put the validateAll to make sure I validate all stuff, not just one by one.

If you run the test now all should work :)

We can also add the notNullable field to the title column in the migrations

table.string('title').notNullable()

A last test can be create to test both description and title need to be a string.

test('cannot create a challenge if title and description are not a string', async ({
  assert,
  client,
}) => {
  const user = await Factory.model('App/Models/User').create()

  const data = {
    title: 123,
    description: 123,
  }

  const response = await client
    .post('/api/challenges')
    .loginVia(user, 'jwt')
    .send(data)
    .end()

  response.assertStatus(400)
  response.assertJSONSubset([
    {
      message: 'title is not a valid string',
      field: 'title',
      validation: 'string',
    },
    {
      message: 'description is not a valid string',
      field: 'description',
      validation: 'string',
    },
  ])
})

And if we run again the test BOOM all green.

End word

I hope you enjoy the part 1 of this tutorial. Don't forget to subscribe to get notifications when I will post the part 2.

If you find any typo, or your want to let me know something about this project, don't hesitate to let a comment below :)

The code can be find here on github

This is a cross-platform post from my blog. You can read the original here: https://equimper.com/blog/build-a-rest-api-with-adonisjs-and-tdd-part-1