DEV Community: yanoandri

Mock Database Unit Test with Mockery in Go

yanoandri — Sun, 20 Feb 2022 17:03:17 +0000

Introduction

Hi everyone, in this article, we will learn how to create unit test in Go, using mockery to testing a project's dependency. We often use mock testing as we unit test a function with another dependencies such as database, so we will learn on how to create it by using example that i'd wrote in here with the steps by steps on how to refactor, create unit test and using the mockery itself, let's get start into it!

Why Mockery?

Mockery provide us with the command to generate mock functions, that we can use for unit testing, so as a results we don't have to write our mock function from scratch, and it will be automatically provided by searching into our interface functions, inside our project's dependencies

To make this tutorial easier, we will prepare to refactor our code from previous article first, create a unit test, run the mockery and start using it in our unit test file in Go

Refactor

first thing to do, we're going to have a look into our old code, we going to define the interface in it, how do we do it? by creating a new root folder with name of repository, from here this is what we call when we use our database dependency.



- config
 |_ config.go
- models
 |_ payment.go
- repository
 |_ payment.go
- test.go

we will start by defining the interface in payment.go inside our repository folder



type IPaymentRepository interface {
    UpdatePayment(id string, payment models.Payment) (models.Payment, error)
    DeletePayment(id string) (int64, error)
    SelectPaymentWIthId(id string) (models.Payment, error)
    CreatePayment(payment models.Payment) (int64, error)
}

since we are going to separate the database dependency from the function, we're going to create a struct that act to hold our database dependency value



type Repository struct {
    Database *gorm.DB
}

then we move all the functions except the main one, inside our payment.go, the complete repository will look like this



package repository

import (
    "errors"

    "github.com/yanoandri/simple-goorm/models"
    "gorm.io/gorm"
)

type IPaymentRepository interface {
    UpdatePayment(id string, payment models.Payment) (models.Payment, error)
    DeletePayment(id string) (int64, error)
    SelectPaymentWIthId(id string) (models.Payment, error)
    CreatePayment(payment models.Payment) (int64, error)
}

type Repository struct {
    Database *gorm.DB
}

func (repo Repository) UpdatePayment(id string, payment models.Payment) (models.Payment, error) {
    var updatePayment models.Payment
    result := repo.Database.Model(&updatePayment).Where("id = ?", id).Updates(payment)
    if result.RowsAffected == 0 {
        return models.Payment{}, errors.New("payment data not update")
    }
    return updatePayment, nil
}

func (repo Repository) DeletePayment(id string) (int64, error) {
    var deletedPayment models.Payment
    result := repo.Database.Where("id = ?", id).Delete(&deletedPayment)
    if result.RowsAffected == 0 {
        return 0, errors.New("payment data not update")
    }
    return result.RowsAffected, nil
}

func (repo Repository) SelectPaymentWIthId(id string) (models.Payment, error) {
    var payment models.Payment
    result := repo.Database.First(&payment, "id = ?", id)
    if result.RowsAffected == 0 {
        return models.Payment{}, errors.New("payment data not found")
    }
    return payment, nil
}

func (repo Repository) CreatePayment(payment models.Payment) (int64, error) {
    result := repo.Database.Create(&payment)
    if result.RowsAffected == 0 {
        return 0, errors.New("payment not created")
    }
    return result.RowsAffected, nil
}

because we move all the functions into our repository folder, we will have to change the way to call our functions, we start to define which database value we want to hold in our struct inside our test.go at the main function



repo := repository.Repository{Database: db}

and from there we can use our functions, without putting any external dependency inside our parameters, for example



// create a payment
payment := models.Payment{
    PaymentCode: "XXX-1",
    Name:        "Payment for item #1",
    Status:      "PENDING",
}

result, err := repo.CreatePayment(payment)

Create a Unit Test File

Luckily if we use VSCode, we can generate the unit test automatically by pressing ctrl + p if you are in windows or command + p and you will find the option to generate the functions like the screenshot below

and for the example we will create the test function of CreatePayment by blocking the whole functions to generate it



package repository

import (
    "testing"

    "github.com/yanoandri/simple-goorm/models"
)

func TestRepository_CreatePayment(t *testing.T) {
    type args struct {
        payment models.Payment
    }
    tests := []struct {
        name    string
        repo    Repository
        args    args
        want    int64
        wantErr bool
    }{
        // TODO: Add test cases.
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := tt.repo.CreatePayment(tt.args.payment)
            if (err != nil) != tt.wantErr {
                t.Errorf("Repository.CreatePayment() error = %v, wantErr %v", err, tt.wantErr)
                return
            }
            if got != tt.want {
                t.Errorf("Repository.CreatePayment() = %v, want %v", got, tt.want)
            }
        })
    }
}

Mockery

We will install mockery using our go command



go install github.com/vektra/mockery/v2@latest

after it finishes, we will create our mock functions by using mockery features to generate all of function mocks, by typing this command



mockery --all --keeptree

notice the mocks folder of our project has been installed, and all of the functions has been mocked

and this is one example of our CreatePayment mock functions



// CreatePayment provides a mock function with given fields: payment
func (_m *IPaymentRepository) CreatePayment(payment models.Payment) (int64, error) {
    ret := _m.Called(payment)

    var r0 int64
    if rf, ok := ret.Get(0).(func(models.Payment) int64); ok {
        r0 = rf(payment)
    } else {
        r0 = ret.Get(0).(int64)
    }

    var r1 error
    if rf, ok := ret.Get(1).(func(models.Payment) error); ok {
        r1 = rf(payment)
    } else {
        r1 = ret.Error(1)
    }

    return r0, r1
}

Write our test functions to use mocks

Now let's include our mocked function to our unit test



package repository

import (
    "errors"
    "testing"

    mocks "github.com/yanoandri/simple-goorm/mocks/repository"
    "github.com/yanoandri/simple-goorm/models"
)

func TestRepository_CreatePayment(t *testing.T) {
    type args struct {
        payment models.Payment
    }
    tests := []struct {
        name    string
        args    args
        want    int64
        wantErr bool
    }{
        // TODO: Add test cases.
        {
            name: "success_create_payment",
            args: args{
                models.Payment{
                    PaymentCode: "payment-code-011",
                    Status:      "PENDING",
                },
            },
            want:    1,
            wantErr: false,
        },
        {
            name: "failed_create_payment",
            args: args{
                models.Payment{},
            },
            want:    0,
            wantErr: true,
        },
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            repo := &mocks.IPaymentRepository{}
            if !tt.wantErr {
                repo.On("CreatePayment", tt.args.payment).Return(tt.want, nil)
            } else {
                repo.On("CreatePayment", tt.args.payment).Return(tt.want, errors.New("Failed to create payment"))
            }
            got, err := repo.CreatePayment(tt.args.payment)
            if (err != nil) != tt.wantErr {
                t.Errorf("Repository.CreatePayment() error = %v, wantErr %v", err, tt.wantErr)
                return
            }
            if got != tt.want {
                t.Errorf("Repository.CreatePayment() = %v, want %v", got, tt.want)
            }
        })
    }
}

notice the repo is missing, it is because we didn't have to use the actual dependencies of database, and we want to mock it in every test session. And for now we will try to run our test by using command



go test ./... -v

Conclusions

This is just one function as an example to use mocks functions in unit test, you can continue to make test for UpdatePayment, DeletePayment and also SelectPaymentWIthId. Mockery has provide us with easier way to generate our functions and as a results we can test our dependencies without creating the same functions twice from scratch, Hope this tutorial helps, and keep exploring! See ya!

Source:

Repo

Playing with Environment Variables in Golang

yanoandri — Wed, 05 Jan 2022 13:56:14 +0000

Introduction

Hi, in this session we will learn how to read variable keys from .env file into our code, or we use to call it by handling environment variables in Golang.

Hands On

This will be a very quick tutorial, so let's just start it by initializing the project modules.

go mod init {your package name}

Then get and download specific dependencies from package github.com/joho/godotenv

go get github.com/joho/godotenv
go mod vendor

Let's headed to the root directories of the project and created the file call .env with contents of

HELLO=from the other side

and run our main script in main.go

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/joho/godotenv"
)

func init() {
    err := godotenv.Load(".env")
    if err != nil {
        log.Fatal("Error loading .env file")
    }
}

func main() {
    fmt.Printf("%s", os.Getenv("HELLO"))
}

Or if we do not want to mix things up with os.GetEnv, we can just also use it like this

package main

import (
    "fmt"
    "log"

    "github.com/joho/godotenv"
)

func main() {
    var envs map[string]string
    envs, err := godotenv.Read(".env")

    if err != nil {
        log.Fatal("Error loading .env file")
    }

    hello := envs["HELLO"]

    fmt.Printf("%s", hello)
}

this will have the same results

Conclusion

Allright, this is it for a quick tutorial, Happy exploring!

Source

Database Handling with Golang Gorm (CRUD Handling)

yanoandri — Mon, 27 Dec 2021 16:47:08 +0000

Introduction

Hi, in this session we will learn on how to use Gorm in Golang, to handle database operations such as create, read, update and delete (or usually called by many of us CRUD operations)

What is Gorm?

Gorm is just as many object relational mapper that every language / framework has, that handles database operations with defined models of our own tables inside our codes. This post will only cover the basic connection, model definition, basic CRUD handling, and we will use postgresql as our database, so let's get start with it!

Initialize Package

First we need to initiate our project with command

go mod init {your package name}

after initializing the project, we can run the command to get the Gorm package and download it to our projects

go get -u gorm.io/gorm
go mod vendor

Okay, so we will separate a folders for configuration, model definition and a main package for running this tutorial, here's my folder structured looks like

- config
 |_ config.go
- models
 |_ payment.go
- test.go

Connecting to DB (Using PostgreSQL)

the code inside config.go is utilize for handling database connection

package config

import (
    "fmt"

    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

const (
    Host     = "localhost"
    User     = "postgres"
    Password = "*******"
    Name     = "payment"
    Port     = "5432"
)

func Setup() (*gorm.DB, error) {
    connectionString := fmt.Sprintf("host=%s port=%s user=%s dbname=%s password=%s sslmode=disable",
        Host,
        Port,
        User,
        Name,
        Password,
    )

    db, err := gorm.Open(postgres.Open(connectionString), &gorm.Config{})
    if err != nil {
        return nil, err
    }
    return db, nil
}

notice that in this file, we defined the connection with enum to handle host, database name, and user authentication needed to connect into our database, also since we use postgre database we import only for the postgres driver

let's try our connection first in test.go file

package main

import (
    "errors"
    "fmt"
    "log"

    "github.com/yanoandri/simple-goorm/config"
    "gorm.io/gorm"
)

func main() {
    //connect to postgresql
    _, err := config.Setup()
    if err != nil {
        log.Panic(err)
        return
    }
    fmt.Println("Connected")
}

if the credentials provided in config.go are correctly provided, the program print "Connected" to mark our connection is successful. For this part, we ignore the return value first, since we are going to talk about in the next part

Model Definition

Let's try creating our first model, we will define the payment.go as our first table

package models

import (
    "time"

    "github.com/google/uuid"
)

type Payment struct {
    ID          uuid.UUID `gorm:"type:uuid;default:uuid_generate_v4();primaryKey;"`
    PaymentCode string
    Name        string
    Status      string
    Created     time.Time `gorm:"autoCreateTime"`
    Updated     time.Time `gorm:"autoUpdateTime"`
}

Inside the struct that we named as payments, we defined the datatypes of every column inside it, you can see this docs on how to use it properly for your table definition

We will try to migrate this table definition inside model into our database, let's use the successful return value of gorm.DB in the earlier section and modify our test.go

package main

import (
    "errors"
    "fmt"
    "log"

    "github.com/yanoandri/simple-goorm/config"
    "github.com/yanoandri/simple-goorm/models"
    "gorm.io/gorm"
)

func main() {
    //connect to postgresql
    db, err := config.Setup()
    if err != nil {
        log.Panic(err)
        return
    }
    fmt.Println("Connected")
    //migrate models inside project
    db.AutoMigrate(models.Payment{})
    fmt.Println("Migrated")
}

Notice the db.AutoMigrate function is use to call the migration if there are any change inside models folder, if there are nothing to change, then it will not make any changes into it

CRUD Handling

Create

Let's try to cover create part this time, we will make the CreatePayment function outside the main function

func CreatePayment(db *gorm.DB, payment models.Payment) (int64, error) {
    result := db.Create(&payment)
    if result.RowsAffected == 0 {
        return 0, errors.New("payment not created")
    }
    return result.RowsAffected, nil
}

then run it inside our main

func main() {
    //connect to postgresql
    db, err := config.Setup()
    if err != nil {
        log.Panic(err)
        return
    }
    fmt.Println("Connected")

    // create a payment
    payment := models.Payment{
        PaymentCode: "XXX-1",
        Name:        "Payment for item #1",
        Status:      "PENDING",
    }

    result, err := CreatePayment(db, payment)
    if err != nil {
        log.Panic(err)
        return
    }
    fmt.Println("Payment created", result)
}

results in our database

Select with id

In earlier create function, we only return the number of rows that we created. This time we return the model as a struct

func SelectPaymentWIthId(db *gorm.DB, id string) (models.Payment, error) {
    var payment models.Payment
    result := db.First(&payment, "id = ?", id)
    if result.RowsAffected == 0 {
        return models.Payment{}, errors.New("payment data not found")
    }
    return payment, nil
}

in test.go

func main() {
    //connect to postgresql
    db, err := config.Setup()
    if err != nil {
        log.Panic(err)
        return
    }
    fmt.Println("Connected")

    // select a payment
    var id string
    fmt.Println("Input payment id : ")
    fmt.Scanln(&id)

    payment, _ := SelectPaymentWIthId(db, id)
    fmt.Println("Your payment is", payment)
}

results

Update

This time we will update the mark the status as PAID for the specific record

func UpdatePayment(db *gorm.DB, id string, payment models.Payment) (models.Payment, error) {
    var updatePayment models.Payment
    result := db.Model(&updatePayment).Where("id = ?", id).Updates(payment)
    if result.RowsAffected == 0 {
        return models.Payment{}, errors.New("payment data not update")
    }
    return updatePayment, nil
}

in test.go

func main() {
    //connect to postgresql
    db, err := config.Setup()
    if err != nil {
        log.Panic(err)
        return
    }
    fmt.Println("Connected")

    // select a payment
    var id string
    fmt.Println("Input payment id : ")
    fmt.Scanln(&id)

    payment, _ := SelectPaymentWIthId(db, id)
    fmt.Println("Your payment is", payment)

    // update a payment with previous id
    updatedPayment, _ := UpdatePayment(db, id, models.Payment{
        Status: "PAID",
    })
    fmt.Println("Your payment status now is ", updatedPayment)
}

results

notice the only information that returned inside struct is only the updated attributes

Delete

The last part is how to delete from tables

func DeletePayment(db *gorm.DB, id string) (int64, error) {
    var deletedPayment models.Payment
    result := db.Where("id = ?", id).Delete(&deletedPayment)
    if result.RowsAffected == 0 {
        return 0, errors.New("payment data not update")
    }
    return result.RowsAffected, nil
}

in test.go

func main() {
    //connect to postgresql
    db, err := config.Setup()
    if err != nil {
        log.Panic(err)
        return
    }
    fmt.Println("Connected")

    // select a payment
    var id string
    fmt.Println("Input payment id : ")
    fmt.Scanln(&id)

    payment, _ := SelectPaymentWIthId(db, id)
    fmt.Println("Your payment is", payment)

    // delete a payment with previous id
    DeletePayment(db, id)
    fmt.Println("Your payment now is deleted")
}

in our script

let's see the results directly database

Conclusion

That's it on how to handle CRUD and connection to database with Golang Gorm. This is really based on my experience and there's still so much more to explore about this package. Happy exploring!

Source :

Build a simple API with Golang echo framework

yanoandri — Sun, 19 Dec 2021 15:06:59 +0000

Hi everyone, in this article i'm going to show tutorial on how to create simple API with Echo Golang framework

First thing that we need to do is to create project in golang by running this command

go mod init {your-package name}

example

go mod init github.com/yanoandri/simple-golang-echo

your package name could be anything, but for this tutorial i'm using the url of my github repos for later

after running the command, there will be a file call go.mod and this time we will run this command to get echo dependencies

go get github.com/labstack/echo/v4

and copy the downloaded dependencies to our project's folder that we are going to call vendor with command

go mod vendor

after the dependency is downloaded, let's start to create a file call server.go

package main

import (
    "net/http"

    "github.com/labstack/echo"
)

type HelloWorld struct {
    Message string `json:"message"`
}

func main() {
    e := echo.New()
    e.GET("/hello", Greetings)
    e.Logger.Fatal(e.Start(":3000"))
}

func Greetings(c echo.Context) error {
    return c.JSON(http.StatusOK, HelloWorld{
        Message: "Hello World",
    })
}

let's run the API that we just created, by command

go run server.go

Then we will test the API by request to http://localhost:3000/hello the response will be

{"message":"Hello World"}

Now, let's head back and handle any parameters or query inside the url, by modifying some of the line in the main function. let's add the function to handle query and parameters

func GreetingsWithParams(c echo.Context) error {
    params := c.Param("name")
    return c.JSON(http.StatusOK, HelloWorld{
        Message: "Hello World, my name is " + params,
    })
}

func GreetingsWithQuery(c echo.Context) error {
    query := c.QueryParam("name")
    return c.JSON(http.StatusOK, HelloWorld{
        Message: "Hello World i'm using queries and my name is " + query,
    })
}

Then in the main function, add this two line

e.GET("/hello/:name", GreetingsWithParams)
e.GET("/hello-queries", GreetingsWithQuery)

let's test it again by requesting the url with parameters
localhost:3000/hello/yano

{"message":"Hello World, my name is yano"}

and the second request using query with http://localhost:3000/hello-queries?name=yano

{"message":"Hello World i'm using queries and my name is yano"}

That's it for this tutorial, thank you for reading and happy coding :)

Source:

Echo
Repo