📖 0%

01 Apr 2024 · 34 min read ·Article 88 / 119

11 Add Unit Tests Using Mockery

Ihsan Arif

Writer at Santekno · Backend Engineer

At this stage we will need the following dependencies

bash

1brew install mockery

bash

1go get github.com/stretchr/testify

bash

1go mod tidy

bash

1go mod vendor

bash

1go get github.com/DATA-DOG/go-sqlmock

In this project we will try to create unit tests using a mocking library with the name mockery. This library is widely used by golang developers because of its ease of use and has the advantage of features that can cover all the necessary unit tests. If you have used unit tests in golang, you may already know this library but if you want to get more references, Santekno has also provided previous posts including:

How to Create Unit Tests on Golang
How to Make a Unit Benchmark on Golang
How to Create Unit Tests Using Moq Library On Golang
Mocking Unit Test Techniques in Golang
How to Create Integration Tests on Golang
Or a collection of articles about unit tests

Unit Test Repository

The first time we will create a unit test at the repository level. This repository has several functions so that later we will create unit tests one by one to be more detailed. Then before making a unit test we need to make a mocking to be used later at the top level unit test, for example the repository will need at the usecase level then we need to generate and add the code below to the interface that has been defined.

Open the reposito.go file and add the code as below. ``go //go:generate mockery –name=ArticleRepository –filename=repository_mock.go –inpackage

type ArticleRepository interface { GetAll(ctx context.Context) ([]*models.Article, error) GetByID(ctx context.Context, id int64) (*models.Article, error) Update(ctx context.Context, article *models.Article) (*models.Article, error) Store(ctx context.Context, article *models.Article) (int64, error) Delete(ctx context.Context, id int64) (bool, error) }

text

1Then place the terminal pointer at the folder position and execute this command.
2```bash
3go generate ./...

If successful there will be a repository_mock.go file that has automatically generated itself.

Create initialitation unit test

Here is the unit test for repository initiation.

 1func TestNew(t *testing.T) {
 2	type args struct {
 3		conn *sql.DB
 4	}
 5	tests := []struct {
 6		name string
 7		args args
 8		want *ArticleStore
 9	}{
10		{
11			name: "success",
12			args: args{},
13			want: &ArticleStore{},
14		},
15	}
16	for _, tt := range tests {
17		t.Run(tt.name, func(t *testing.T) {
18			if got := New(tt.args.conn); !reflect.DeepEqual(got, tt.want) {
19				t.Errorf("New() = %v, want %v", got, tt.want)
20			}
21		})
22	}
23}

Unit test for GetAll function

  1func TestArticleStore_GetAll(t *testing.T) {
  2	ctx := context.Background()
  3	mockDB, mock, err := sqlmock.New()
  4	if err != nil {
  5		t.Errorf("error")
  6	}
  7
  8	// expect query
  9	const expetcqueryGetAll = `SELECT id, title, content, create_at, update_at FROM articles`
 10	var column = []string{"id", "title", "content", "create_at", "update_at"}
 11	var timeNow = time.Now()
 12	var expectResult []*models.Article
 13
 14	type fields struct {
 15		db *sql.DB
 16	}
 17	type args struct {
 18		ctx context.Context
 19	}
 20	tests := []struct {
 21		name    string
 22		fields  fields
 23		args    args
 24		want    []*models.Article
 25		wantErr bool
 26		mock    func()
 27	}{
 28		{
 29			name: "success get article",
 30			fields: fields{
 31				db: mockDB,
 32			},
 33			mock: func() {
 34				mock.ExpectQuery(expetcqueryGetAll).WillReturnRows(
 35					sqlmock.NewRows(column).AddRow(
 36						1, "test", "test content", timeNow, timeNow,
 37					),
 38				)
 39			},
 40			want: []*models.Article{
 41				{
 42					ID:       1,
 43					Title:    "test",
 44					Content:  "test content",
 45					CreateAt: timeNow,
 46					UpdateAt: timeNow,
 47				},
 48			},
 49			args: args{
 50				ctx: ctx,
 51			},
 52			wantErr: false,
 53		},
 54		{
 55			name: "failed when query error",
 56			fields: fields{
 57				db: mockDB,
 58			},
 59			mock: func() {
 60				mock.ExpectQuery(expetcqueryGetAll).WillReturnError(sql.ErrNoRows)
 61			},
 62			want: expectResult,
 63			args: args{
 64				ctx: ctx,
 65			},
 66			wantErr: true,
 67		},
 68		{
 69			name: "failed rows next",
 70			fields: fields{
 71				db: mockDB,
 72			},
 73			mock: func() {
 74				mock.ExpectQuery(expetcqueryGetAll).WillReturnRows(
 75					sqlmock.NewRows(column).AddRow(
 76						1, "test", "test content", "test", "test",
 77					),
 78				)
 79			},
 80			want: expectResult,
 81			args: args{
 82				ctx: ctx,
 83			},
 84			wantErr: true,
 85		},
 86	}
 87	for _, tt := range tests {
 88		t.Run(tt.name, func(t *testing.T) {
 89			r := &ArticleStore{
 90				db: tt.fields.db,
 91			}
 92			tt.mock()
 93			got, err := r.GetAll(tt.args.ctx)
 94			if (err != nil) != tt.wantErr {
 95				t.Errorf("ArticleStore.GetAll() error = %v, wantErr %v", err, tt.wantErr)
 96				return
 97			}
 98			assert.EqualValues(t, got, tt.want)
 99		})
100	}
101}

Create unit test for GetByID

 1func TestArticleStore_GetByID(t *testing.T) {
 2	ctx := context.Background()
 3	mockDB, mock, err := sqlmock.New()
 4	if err != nil {
 5		t.Errorf("error")
 6	}
 7
 8	// expect query
 9	const expectQueryGetById = `SELECT id, title, content, create_at, update_at FROM articles WHERE id=(.*)`
10	var column = []string{"id", "title", "content", "create_at", "update_at"}
11	var timeNow = time.Now()
12
13	type fields struct {
14		db *sql.DB
15	}
16	type args struct {
17		ctx context.Context
18		id  int64
19	}
20	tests := []struct {
21		name    string
22		fields  fields
23		args    args
24		want    *models.Article
25		wantErr bool
26		mock    func()
27	}{
28		{
29			name: "success get article",
30			fields: fields{
31				db: mockDB,
32			},
33			mock: func() {
34				mock.ExpectQuery(expectQueryGetById).WillReturnRows(
35					sqlmock.NewRows(column).AddRow(
36						1, "test", "test content", timeNow, timeNow,
37					),
38				)
39			},
40			want: &models.Article{
41				ID:       1,
42				Title:    "test",
43				Content:  "test content",
44				CreateAt: timeNow,
45				UpdateAt: timeNow,
46			},
47			args: args{
48				ctx: ctx,
49			},
50			wantErr: false,
51		},
52		{
53			name: "failed when query error",
54			fields: fields{
55				db: mockDB,
56			},
57			mock: func() {
58				mock.ExpectQuery(expectQueryGetById).WillReturnError(sql.ErrNoRows)
59			},
60			want: &models.Article{},
61			args: args{
62				ctx: ctx,
63			},
64			wantErr: true,
65		},
66	}
67	for _, tt := range tests {
68		t.Run(tt.name, func(t *testing.T) {
69			r := &ArticleStore{
70				db: tt.fields.db,
71			}
72			tt.mock()
73			got, err := r.GetByID(tt.args.ctx, tt.args.id)
74			if (err != nil) != tt.wantErr {
75				t.Errorf("ArticleStore.GetByID() error = %v, wantErr %v", err, tt.wantErr)
76				return
77			}
78			assert.EqualExportedValues(t, got, tt.want)
79		})
80	}
81}

Create unit test for Update function

 1func TestArticleStore_Update(t *testing.T) {
 2	ctx := context.Background()
 3	mockDB, mock, err := sqlmock.New()
 4	if err != nil {
 5		t.Errorf("error")
 6	}
 7
 8	// expect query
 9	const expectQueryUpdate = `UPDATE articles SET title=(.*), content=(.*), update_at=(.*) WHERE id=(.*)`
10	var timeNow = time.Now()
11
12	type fields struct {
13		db *sql.DB
14	}
15	type args struct {
16		ctx     context.Context
17		article *models.Article
18	}
19	tests := []struct {
20		name    string
21		fields  fields
22		args    args
23		want    *models.Article
24		wantErr bool
25		mock    func()
26	}{
27		{
28			name: "success update article",
29			fields: fields{
30				db: mockDB,
31			},
32			mock: func() {
33				mock.ExpectExec(expectQueryUpdate).WillReturnResult(
34					sqlmock.NewResult(1, 1),
35				)
36			},
37			want: &models.Article{
38				ID:       1,
39				Title:    "test",
40				Content:  "test content",
41				CreateAt: timeNow,
42				UpdateAt: timeNow,
43			},
44			args: args{
45				ctx: ctx,
46				article: &models.Article{
47					ID:       1,
48					Title:    "test",
49					Content:  "test content",
50					CreateAt: timeNow,
51					UpdateAt: timeNow,
52				},
53			},
54			wantErr: false,
55		},
56		{
57			name: "failed when query error",
58			fields: fields{
59				db: mockDB,
60			},
61			mock: func() {
62				mock.ExpectExec(expectQueryUpdate).WillReturnError(errors.New("got error"))
63			},
64			want: nil,
65			args: args{
66				ctx: ctx,
67				article: &models.Article{
68					ID:       1,
69					Title:    "test",
70					Content:  "test content",
71					CreateAt: timeNow,
72					UpdateAt: timeNow,
73				},
74			},
75			wantErr: true,
76		},
77	}
78	for _, tt := range tests {
79		t.Run(tt.name, func(t *testing.T) {
80			r := &ArticleStore{
81				db: tt.fields.db,
82			}
83			tt.mock()
84			got, err := r.Update(tt.args.ctx, tt.args.article)
85			if (err != nil) != tt.wantErr {
86				t.Errorf("ArticleStore.Update() error = %v, wantErr %v", err, tt.wantErr)
87				return
88			}
89			assert.EqualExportedValues(t, got, tt.want)
90		})
91	}
92}

Create Unit test for Store function

 1func TestArticleStore_Store(t *testing.T) {
 2	ctx := context.Background()
 3	mockDB, mock, err := sqlmock.New()
 4	if err != nil {
 5		t.Errorf("error")
 6	}
 7
 8	// expect query
 9	const expectQueryInsert = `INSERT INTO articles\(title, content, create_at, update_at\) VALUES\((.*),(.*),(.*),(.*)\)`
10	var timeNow = time.Now()
11
12	type fields struct {
13		db *sql.DB
14	}
15	type args struct {
16		ctx     context.Context
17		article *models.Article
18	}
19	tests := []struct {
20		name    string
21		fields  fields
22		args    args
23		want    int64
24		wantErr bool
25		mock    func()
26	}{
27		{
28			name: "success create article",
29			fields: fields{
30				db: mockDB,
31			},
32			mock: func() {
33				mock.ExpectExec(expectQueryInsert).WillReturnResult(
34					sqlmock.NewResult(1, 1),
35				)
36			},
37			want: 1,
38			args: args{
39				ctx: ctx,
40				article: &models.Article{
41					ID:       1,
42					Title:    "test",
43					Content:  "test content",
44					CreateAt: timeNow,
45					UpdateAt: timeNow,
46				},
47			},
48			wantErr: false,
49		},
50		{
51			name: "failed when query error",
52			fields: fields{
53				db: mockDB,
54			},
55			mock: func() {
56				mock.ExpectExec(expectQueryInsert).WillReturnError(errors.New("got error"))
57			},
58			want: 0,
59			args: args{
60				ctx: ctx,
61				article: &models.Article{
62					ID:       1,
63					Title:    "test",
64					Content:  "test content",
65					CreateAt: timeNow,
66					UpdateAt: timeNow,
67				},
68			},
69			wantErr: true,
70		},
71	}
72	for _, tt := range tests {
73		t.Run(tt.name, func(t *testing.T) {
74			r := &ArticleStore{
75				db: tt.fields.db,
76			}
77			tt.mock()
78			got, err := r.Store(tt.args.ctx, tt.args.article)
79			if (err != nil) != tt.wantErr {
80				t.Errorf("ArticleStore.Store() error = %v, wantErr %v", err, tt.wantErr)
81				return
82			}
83			assert.Equal(t, got, tt.want)
84		})
85	}
86}

Create unit test for Delete function

 1func TestArticleStore_Delete(t *testing.T) {
 2	ctx := context.Background()
 3	mockDB, mock, err := sqlmock.New()
 4	if err != nil {
 5		t.Errorf("error")
 6	}
 7
 8	// expect query
 9	const expectQueryDelete = `DELETE FROM articles WHERE id=(.*)`
10	type fields struct {
11		db *sql.DB
12	}
13	type args struct {
14		ctx context.Context
15		id  int64
16	}
17	tests := []struct {
18		name    string
19		fields  fields
20		args    args
21		want    bool
22		wantErr bool
23		mock    func()
24	}{
25		{
26			name: "success delete article",
27			fields: fields{
28				db: mockDB,
29			},
30			mock: func() {
31				mock.ExpectExec(expectQueryDelete).WillReturnResult(
32					sqlmock.NewResult(1, 1),
33				)
34			},
35			want: true,
36			args: args{
37				ctx: ctx,
38				id:  1,
39			},
40			wantErr: false,
41		},
42		{
43			name: "failed when query error",
44			fields: fields{
45				db: mockDB,
46			},
47			mock: func() {
48				mock.ExpectExec(expectQueryDelete).WillReturnError(errors.New("got error"))
49			},
50			want: false,
51			args: args{
52				ctx: ctx,
53				id:  1,
54			},
55			wantErr: true,
56		},
57	}
58	for _, tt := range tests {
59		t.Run(tt.name, func(t *testing.T) {
60			r := &ArticleStore{
61				db: tt.fields.db,
62			}
63			tt.mock()
64			got, err := r.Delete(tt.args.ctx, tt.args.id)
65			if (err != nil) != tt.wantErr {
66				t.Errorf("ArticleStore.Delete() error = %v, wantErr %v", err, tt.wantErr)
67				return
68			}
69			assert.Equal(t, got, tt.want)
70		})
71	}
72}

Creating a Usecase level unit test

In making this Usecase level unit test, we also need to add a mock so that the unit test can be done at the upper level, namely the handler.

1//go:generate mockery --name=ArticleUsecase --filename=usecase_mock.go --inpackage
2
3type ArticleUsecase interface {
4	GetAll(ctx context.Context) ([]models.ArticleResponse, error)
5	GetByID(ctx context.Context, id int64) (models.ArticleResponse, error)
6	Update(ctx context.Context, article models.ArticleUpdateRequest) (models.ArticleResponse, error)
7	Store(ctx context.Context, article models.ArticleCreateRequest) (models.ArticleResponse, error)
8	Delete(ctx context.Context, id int64) (bool, error)
9}

Do the same as at the repository level

bash

1go generate ./...

then a file called usecase_mock.go will be created. First create a unit test on initialization as below.

 1func TestNew(t *testing.T) {
 2	type args struct {
 3		repo repository.ArticleRepository
 4	}
 5	tests := []struct {
 6		name string
 7		args args
 8		want *Usecase
 9	}{
10		{
11			name: "success new",
12			want: &Usecase{},
13		},
14	}
15	for _, tt := range tests {
16		t.Run(tt.name, func(t *testing.T) {
17			if got := New(tt.args.repo); !reflect.DeepEqual(got, tt.want) {
18				t.Errorf("New() = %v, want %v", got, tt.want)
19			}
20		})
21	}
22}

Create unit test for GetAll

 1func TestUsecase_GetAll(t *testing.T) {
 2	var ctx = context.Background()
 3	var timeNow = time.Now()
 4	mockRepository := new(repository.MockArticleRepository)
 5	type fields struct {
 6		articleRepository repository.ArticleRepository
 7	}
 8	type args struct {
 9		ctx context.Context
10	}
11	tests := []struct {
12		name    string
13		fields  fields
14		args    args
15		want    []models.ArticleResponse
16		wantErr bool
17		mock    func(args args)
18	}{
19		{
20			name: "success",
21			args: args{
22				ctx: ctx,
23			},
24			fields: fields{
25				articleRepository: mockRepository,
26			},
27			mock: func(args args) {
28				var res = []*models.Article{
29					{
30						ID:       1,
31						Title:    "test",
32						Content:  "test content",
33						CreateAt: timeNow,
34						UpdateAt: timeNow,
35					},
36				}
37				mockRepository.On("GetAll", args.ctx).Return(res, nil).Once()
38			},
39			want: []models.ArticleResponse{
40				{
41					ID:       1,
42					Title:    "test",
43					Content:  "test content",
44					CreateAt: timeNow,
45					UpdateAt: timeNow,
46				},
47			},
48			wantErr: false,
49		},
50		{
51			name: "failed get all data",
52			args: args{
53				ctx: ctx,
54			},
55			fields: fields{
56				articleRepository: mockRepository,
57			},
58			mock: func(args args) {
59				var res = []*models.Article{}
60				mockRepository.On("GetAll", args.ctx).Return(res, errors.New("got error")).Once()
61			},
62			want:    nil,
63			wantErr: true,
64		},
65	}
66	for _, tt := range tests {
67		t.Run(tt.name, func(t *testing.T) {
68			tt.mock(tt.args)
69			u := &Usecase{
70				articleRepository: tt.fields.articleRepository,
71			}
72			got, err := u.GetAll(tt.args.ctx)
73			if (err != nil) != tt.wantErr {
74				t.Errorf("Usecase.GetAll() error = %v, wantErr %v", err, tt.wantErr)
75				return
76			}
77			if !reflect.DeepEqual(got, tt.want) {
78				t.Errorf("Usecase.GetAll() = %v, want %v", got, tt.want)
79			}
80		})
81	}
82}

Create Unit test for GetByID

 1func TestUsecase_GetByID(t *testing.T) {
 2	var ctx = context.Background()
 3	var timeNow = time.Now()
 4	mockRepository := new(repository.MockArticleRepository)
 5	type fields struct {
 6		articleRepository repository.ArticleRepository
 7	}
 8	type args struct {
 9		ctx context.Context
10		id  int64
11	}
12	tests := []struct {
13		name    string
14		fields  fields
15		args    args
16		want    models.ArticleResponse
17		wantErr bool
18		mock    func(args args)
19	}{
20		{
21			name: "success",
22			args: args{
23				ctx: ctx,
24				id:  1,
25			},
26			fields: fields{
27				articleRepository: mockRepository,
28			},
29			mock: func(args args) {
30				var res = &models.Article{
31					ID:       1,
32					Title:    "test",
33					Content:  "test content",
34					CreateAt: timeNow,
35					UpdateAt: timeNow,
36				}
37				mockRepository.On("GetByID", args.ctx, args.id).Return(res, nil).Once()
38			},
39			want: models.ArticleResponse{
40				ID:       1,
41				Title:    "test",
42				Content:  "test content",
43				CreateAt: timeNow,
44				UpdateAt: timeNow,
45			},
46			wantErr: false,
47		},
48		{
49			name: "failed get by id",
50			args: args{
51				ctx: ctx,
52			},
53			fields: fields{
54				articleRepository: mockRepository,
55			},
56			mock: func(args args) {
57				var res = &models.Article{}
58				mockRepository.On("GetByID", args.ctx, args.id).Return(res, errors.New("got error")).Once()
59			},
60			want:    models.ArticleResponse{},
61			wantErr: true,
62		},
63	}
64	for _, tt := range tests {
65		t.Run(tt.name, func(t *testing.T) {
66			tt.mock(tt.args)
67			u := &Usecase{
68				articleRepository: tt.fields.articleRepository,
69			}
70			got, err := u.GetByID(tt.args.ctx, tt.args.id)
71			if (err != nil) != tt.wantErr {
72				t.Errorf("Usecase.GetByID() error = %v, wantErr %v", err, tt.wantErr)
73				return
74			}
75			if !reflect.DeepEqual(got, tt.want) {
76				t.Errorf("Usecase.GetByID() = %v, want %v", got, tt.want)
77			}
78		})
79	}
80}

Create unit test for Update

  1func TestUsecase_Update(t *testing.T) {
  2	var ctx = context.Background()
  3	var timeNow = time.Now()
  4	mockRepository := new(repository.MockArticleRepository)
  5	type fields struct {
  6		articleRepository repository.ArticleRepository
  7	}
  8	type args struct {
  9		ctx     context.Context
 10		request models.ArticleUpdateRequest
 11	}
 12	tests := []struct {
 13		name    string
 14		fields  fields
 15		args    args
 16		want    models.ArticleResponse
 17		wantErr bool
 18		mock    func(args args)
 19	}{
 20		{
 21			name: "failed when request id was zero",
 22			fields: fields{
 23				articleRepository: mockRepository,
 24			},
 25			args: args{
 26				ctx:     ctx,
 27				request: models.ArticleUpdateRequest{},
 28			},
 29			mock:    func(args args) {},
 30			want:    models.ArticleResponse{},
 31			wantErr: true,
 32		},
 33		{
 34			name: "failed when get by repo",
 35			fields: fields{
 36				articleRepository: mockRepository,
 37			},
 38			args: args{
 39				ctx: ctx,
 40				request: models.ArticleUpdateRequest{
 41					ID: 1,
 42				},
 43			},
 44			mock: func(args args) {
 45				var article *models.Article
 46				mockRepository.On("GetByID", args.ctx, args.request.ID).Return(article, errors.New("got error")).Once()
 47			},
 48			want:    models.ArticleResponse{},
 49			wantErr: true,
 50		},
 51		{
 52			name: "failed when get by id not found",
 53			fields: fields{
 54				articleRepository: mockRepository,
 55			},
 56			args: args{
 57				ctx: ctx,
 58				request: models.ArticleUpdateRequest{
 59					ID: 1,
 60				},
 61			},
 62			mock: func(args args) {
 63				var article = &models.Article{}
 64				mockRepository.On("GetByID", args.ctx, args.request.ID).Return(article, nil).Once()
 65			},
 66			want:    models.ArticleResponse{},
 67			wantErr: true,
 68		},
 69		{
 70			name: "failed when update repo",
 71			fields: fields{
 72				articleRepository: mockRepository,
 73			},
 74			args: args{
 75				ctx: ctx,
 76				request: models.ArticleUpdateRequest{
 77					ID:       1,
 78					Title:    "test update",
 79					Content:  "test update",
 80					UpdateAt: timeNow,
 81				},
 82			},
 83			mock: func(args args) {
 84				var article = &models.Article{
 85					ID:       1,
 86					Title:    "test",
 87					Content:  "test",
 88					CreateAt: timeNow,
 89					UpdateAt: timeNow,
 90				}
 91				mockRepository.On("GetByID", args.ctx, args.request.ID).Return(article, nil).Once()
 92
 93				article.FromUpdateRequest(args.request)
 94				mockRepository.On("Update", args.ctx, article).Return(&models.Article{}, errors.New("got error"))
 95			},
 96			want:    models.ArticleResponse{},
 97			wantErr: true,
 98		},
 99		{
100			name: "success update",
101			fields: fields{
102				articleRepository: mockRepository,
103			},
104			args: args{
105				ctx: ctx,
106				request: models.ArticleUpdateRequest{
107					ID:       1,
108					Title:    "test update",
109					Content:  "test update",
110					UpdateAt: timeNow,
111				},
112			},
113			mock: func(args args) {
114				var article = &models.Article{
115					ID:       1,
116					Title:    "test",
117					Content:  "test",
118					CreateAt: timeNow,
119					UpdateAt: timeNow,
120				}
121				mockRepository.On("GetByID", args.ctx, args.request.ID).Return(article, nil).Once()
122
123				article.FromUpdateRequest(args.request)
124				mockRepository.On("Update", args.ctx, article).Return(article, nil).Once()
125			},
126			want: models.ArticleResponse{
127				ID:       1,
128				Title:    "test update",
129				Content:  "test update",
130				UpdateAt: timeNow,
131				CreateAt: timeNow,
132			},
133			wantErr: false,
134		},
135	}
136	for _, tt := range tests {
137		t.Run(tt.name, func(t *testing.T) {
138			tt.mock(tt.args)
139			u := &Usecase{
140				articleRepository: tt.fields.articleRepository,
141			}
142			got, err := u.Update(tt.args.ctx, tt.args.request)
143			if (err != nil) != tt.wantErr {
144				t.Errorf("Usecase.Update() error = %v, wantErr %v", err, tt.wantErr)
145				return
146			}
147			if !reflect.DeepEqual(got.ID, tt.want.ID) {
148				t.Errorf("Usecase.Update() = %v, want %v", got, tt.want)
149			}
150			if !reflect.DeepEqual(got.Title, tt.want.Title) {
151				t.Errorf("Usecase.Update() = %v, want %v", got, tt.want)
152			}
153			if !reflect.DeepEqual(got.Content, tt.want.Content) {
154				t.Errorf("Usecase.Update() = %v, want %v", got, tt.want)
155			}
156			if !reflect.DeepEqual(got.CreateAt, tt.want.CreateAt) {
157				t.Errorf("Usecase.Update() = %v, want %v", got, tt.want)
158			}
159		})
160	}
161}

Create unit test for Store

 1func TestUsecase_Store(t *testing.T) {
 2	var ctx = context.Background()
 3	var timeNow = time.Now()
 4	mockRepository := new(repository.MockArticleRepository)
 5	type fields struct {
 6		articleRepository repository.ArticleRepository
 7	}
 8	type args struct {
 9		ctx     context.Context
10		request models.ArticleCreateRequest
11	}
12	tests := []struct {
13		name    string
14		fields  fields
15		args    args
16		want    models.ArticleResponse
17		wantErr bool
18		mock    func(args args)
19	}{
20		{
21			name: "failed store repository",
22			fields: fields{
23				articleRepository: mockRepository,
24			},
25			args: args{
26				ctx: ctx,
27				request: models.ArticleCreateRequest{
28					Title:    "test",
29					Content:  "test content",
30					CreateAt: timeNow,
31				},
32			},
33			mock: func(args args) {
34				var result int64
35				mockRepository.On("Store", args.ctx, mock.Anything).Return(result, errors.New("got error")).Once()
36			},
37			want:    models.ArticleResponse{},
38			wantErr: true,
39		},
40		{
41			name: "success store repository",
42			fields: fields{
43				articleRepository: mockRepository,
44			},
45			args: args{
46				ctx: ctx,
47				request: models.ArticleCreateRequest{
48					Title:    "test",
49					Content:  "test content",
50					CreateAt: timeNow,
51				},
52			},
53			mock: func(args args) {
54				var result int64 = 1
55				mockRepository.On("Store", args.ctx, mock.Anything).Return(result, nil).Once()
56			},
57			want: models.ArticleResponse{
58				ID:       1,
59				Title:    "test",
60				Content:  "test content",
61				CreateAt: timeNow,
62				UpdateAt: timeNow,
63			},
64			wantErr: false,
65		},
66	}
67	for _, tt := range tests {
68		t.Run(tt.name, func(t *testing.T) {
69			tt.mock(tt.args)
70			u := &Usecase{
71				articleRepository: tt.fields.articleRepository,
72			}
73			got, err := u.Store(tt.args.ctx, tt.args.request)
74			if (err != nil) != tt.wantErr {
75				t.Errorf("Usecase.Store() error = %v, wantErr %v", err, tt.wantErr)
76				return
77			}
78			if !reflect.DeepEqual(got.ID, tt.want.ID) {
79				t.Errorf("Usecase.Store() = %v, want %v", got, tt.want)
80			}
81			if !reflect.DeepEqual(got.Title, tt.want.Title) {
82				t.Errorf("Usecase.Store() = %v, want %v", got, tt.want)
83			}
84			if !reflect.DeepEqual(got.Content, tt.want.Content) {
85				t.Errorf("Usecase.Store() = %v, want %v", got, tt.want)
86			}
87		})
88	}
89}

Create unit test for Delete

  1func TestUsecase_Store(t *testing.T) {
  2	var ctx = context.Background()
  3	var timeNow = time.Now()
  4	mockRepository := new(repository.MockArticleRepository)
  5	type fields struct {
  6		articleRepository repository.ArticleRepository
  7	}
  8	type args struct {
  9		ctx     context.Context
 10		request models.ArticleCreateRequest
 11	}
 12	tests := []struct {
 13		name    string
 14		fields  fields
 15		args    args
 16		want    models.ArticleResponse
 17		wantErr bool
 18		mock    func(args args)
 19	}{
 20		{
 21			name: "failed store repository",
 22			fields: fields{
 23				articleRepository: mockRepository,
 24			},
 25			args: args{
 26				ctx: ctx,
 27				request: models.ArticleCreateRequest{
 28					Title:    "test",
 29					Content:  "test content",
 30					CreateAt: timeNow,
 31				},
 32			},
 33			mock: func(args args) {
 34				var result int64
 35				mockRepository.On("Store", args.ctx, mock.Anything).Return(result, errors.New("got error")).Once()
 36			},
 37			want:    models.ArticleResponse{},
 38			wantErr: true,
 39		},
 40		{
 41			name: "success store repository",
 42			fields: fields{
 43				articleRepository: mockRepository,
 44			},
 45			args: args{
 46				ctx: ctx,
 47				request: models.ArticleCreateRequest{
 48					Title:    "test",
 49					Content:  "test content",
 50					CreateAt: timeNow,
 51				},
 52			},
 53			mock: func(args args) {
 54				var result int64 = 1
 55				mockRepository.On("Store", args.ctx, mock.Anything).Return(result, nil).Once()
 56			},
 57			want: models.ArticleResponse{
 58				ID:       1,
 59				Title:    "test",
 60				Content:  "test content",
 61				CreateAt: timeNow,
 62				UpdateAt: timeNow,
 63			},
 64			wantErr: false,
 65		},
 66	}
 67	for _, tt := range tests {
 68		t.Run(tt.name, func(t *testing.T) {
 69			tt.mock(tt.args)
 70			u := &Usecase{
 71				articleRepository: tt.fields.articleRepository,
 72			}
 73			got, err := u.Store(tt.args.ctx, tt.args.request)
 74			if (err != nil) != tt.wantErr {
 75				t.Errorf("Usecase.Store() error = %v, wantErr %v", err, tt.wantErr)
 76				return
 77			}
 78			if !reflect.DeepEqual(got.ID, tt.want.ID) {
 79				t.Errorf("Usecase.Store() = %v, want %v", got, tt.want)
 80			}
 81			if !reflect.DeepEqual(got.Title, tt.want.Title) {
 82				t.Errorf("Usecase.Store() = %v, want %v", got, tt.want)
 83			}
 84			if !reflect.DeepEqual(got.Content, tt.want.Content) {
 85				t.Errorf("Usecase.Store() = %v, want %v", got, tt.want)
 86			}
 87		})
 88	}
 89}
 90
 91func TestUsecase_Delete(t *testing.T) {
 92	var ctx = context.Background()
 93	var timeNow = time.Now()
 94	mockRepository := new(repository.MockArticleRepository)
 95	type fields struct {
 96		articleRepository repository.ArticleRepository
 97	}
 98	type args struct {
 99		ctx context.Context
100		id  int64
101	}
102	tests := []struct {
103		name    string
104		fields  fields
105		args    args
106		want    bool
107		wantErr bool
108		mock    func(args args)
109	}{
110		{
111			name: "failed when get by id was error",
112			fields: fields{
113				articleRepository: mockRepository,
114			},
115			args: args{
116				ctx: ctx,
117				id:  1,
118			},
119			mock: func(args args) {
120				var article *models.Article
121				mockRepository.On("GetByID", args.ctx, args.id).Return(article, errors.New("got error")).Once()
122			},
123			want:    false,
124			wantErr: true,
125		},
126		{
127			name: "failed when article not found",
128			fields: fields{
129				articleRepository: mockRepository,
130			},
131			args: args{
132				ctx: ctx,
133				id:  1,
134			},
135			mock: func(args args) {
136				mockRepository.On("GetByID", args.ctx, args.id).Return(nil, nil).Once()
137
138			},
139			want:    false,
140			wantErr: true,
141		},
142		{
143			name: "failed when delete repo was error",
144			fields: fields{
145				articleRepository: mockRepository,
146			},
147			args: args{
148				ctx: ctx,
149				id:  1,
150			},
151			mock: func(args args) {
152				var article = &models.Article{
153					ID:       1,
154					Title:    "test",
155					Content:  "test content",
156					CreateAt: timeNow,
157					UpdateAt: timeNow,
158				}
159				mockRepository.On("GetByID", args.ctx, args.id).Return(article, nil).Once()
160
161				mockRepository.On("Delete", args.ctx, args.id).Return(false, errors.New("got error")).Once()
162			},
163			want:    false,
164			wantErr: true,
165		},
166		{
167			name: "success delete article",
168			fields: fields{
169				articleRepository: mockRepository,
170			},
171			args: args{
172				ctx: ctx,
173				id:  1,
174			},
175			mock: func(args args) {
176				var article = &models.Article{
177					ID:       1,
178					Title:    "test",
179					Content:  "test content",
180					CreateAt: timeNow,
181					UpdateAt: timeNow,
182				}
183				mockRepository.On("GetByID", args.ctx, args.id).Return(article, nil).Once()
184				mockRepository.On("Delete", args.ctx, args.id).Return(true, nil).Once()
185			},
186			want:    true,
187			wantErr: false,
188		},
189	}
190	for _, tt := range tests {
191		t.Run(tt.name, func(t *testing.T) {
192			tt.mock(tt.args)
193			u := &Usecase{
194				articleRepository: tt.fields.articleRepository,
195			}
196			got, err := u.Delete(tt.args.ctx, tt.args.id)
197			if (err != nil) != tt.wantErr {
198				t.Errorf("Usecase.Delete() error = %v, wantErr %v", err, tt.wantErr)
199				return
200			}
201			if got != tt.want {
202				t.Errorf("Usecase.Delete() = %v, want %v", got, tt.want)
203			}
204		})
205	}
206}

Creating Unit tests on Handlers

At this handler level we don’t need a mock generator because we won’t use the handler for unit tests so there is no need to create or generate it.

Unlike the others, in this handler we create unit tests using the httptest library which needs to be unit tested for handlers that have requests, responses and headers with the http protocol.

Starting with creating a unit test on initialization as below.

 1func TestNew(t *testing.T) {
 2	mockUsecase := new(usecase.MockArticleUsecase)
 3	type args struct {
 4		articleUsecase usecase.ArticleUsecase
 5	}
 6	tests := []struct {
 7		name string
 8		args args
 9		want *Delivery
10	}{
11		{
12			name: "success",
13			args: args{
14				articleUsecase: mockUsecase,
15			},
16			want: &Delivery{
17				articleUsecase: mockUsecase,
18			},
19		},
20	}
21	for _, tt := range tests {
22		t.Run(tt.name, func(t *testing.T) {
23			New(tt.args.articleUsecase)
24		})
25	}
26}

Unit test for GetAll

 1func TestDelivery_GetAll(t *testing.T) {
 2	mockUsecase := new(usecase.MockArticleUsecase)
 3	timeNow := time.Now().UTC()
 4	type fields struct {
 5		articleUsecase usecase.ArticleUsecase
 6		validate       *validator.Validate
 7	}
 8	type args struct {
 9		params httprouter.Params
10	}
11	tests := []struct {
12		name           string
13		fields         fields
14		args           args
15		wantStatusCode int
16		want           models.ArticleListResponse
17		mock           func(args args)
18	}{
19		{
20			name: "failed get all article",
21			fields: fields{
22				articleUsecase: mockUsecase,
23			},
24			mock: func(args args) {
25				var res []models.ArticleResponse
26				mockUsecase.On("GetAll", mock.Anything).Return(res, errors.New("got error")).Once()
27			},
28			wantStatusCode: http.StatusInternalServerError,
29			want: models.ArticleListResponse{
30				HeaderResponse: models.HeaderResponse{
31					Code:   http.StatusInternalServerError,
32					Status: "got error",
33				},
34			},
35		},
36		{
37			name: "success get all article",
38			fields: fields{
39				articleUsecase: mockUsecase,
40			},
41			mock: func(args args) {
42				var res = []models.ArticleResponse{
43					{
44						ID:       1,
45						Title:    "test",
46						Content:  "test content",
47						CreateAt: timeNow,
48						UpdateAt: timeNow,
49					},
50				}
51				mockUsecase.On("GetAll", mock.Anything).Return(res, nil).Once()
52			},
53			wantStatusCode: http.StatusOK,
54			want: models.ArticleListResponse{
55				HeaderResponse: models.HeaderResponse{
56					Code:   http.StatusOK,
57					Status: "OK",
58				},
59				Data: []models.ArticleResponse{
60					{
61						ID:       1,
62						Title:    "test",
63						Content:  "test content",
64						CreateAt: timeNow,
65						UpdateAt: timeNow,
66					},
67				},
68			},
69		},
70	}
71	for _, tt := range tests {
72		t.Run(tt.name, func(t *testing.T) {
73			req := httptest.NewRequest("GET", "/test", nil)
74			w := httptest.NewRecorder()
75
76			tt.mock(tt.args)
77
78			d := &Delivery{
79				articleUsecase: tt.fields.articleUsecase,
80				validate:       tt.fields.validate,
81			}
82			d.GetAll(w, req, tt.args.params)
83
84			resp := w.Result()
85			body, _ := io.ReadAll(resp.Body)
86
87			var result models.ArticleListResponse
88			err := json.Unmarshal(body, &result)
89			if err != nil {
90				t.Errorf("error unmarshal %v", err)
91			}
92
93			assert.Equal(t, tt.wantStatusCode, resp.StatusCode)
94			assert.Equal(t, tt.want, result)
95		})
96	}
97}

Unit test for GetByID

  1func TestDelivery_GetByID(t *testing.T) {
  2	mockUsecase := new(usecase.MockArticleUsecase)
  3	timeNow := time.Now().UTC()
  4	type fields struct {
  5		articleUsecase usecase.ArticleUsecase
  6		validate       *validator.Validate
  7	}
  8	type args struct {
  9		params httprouter.Params
 10	}
 11	tests := []struct {
 12		name           string
 13		fields         fields
 14		args           args
 15		wantStatusCode int
 16		wantErr        bool
 17		want           models.ArticleListResponse
 18		mock           func(args args)
 19	}{
 20		{
 21			name: "failed get by id article",
 22			fields: fields{
 23				articleUsecase: mockUsecase,
 24			},
 25			args: args{
 26				params: []httprouter.Param{{Key: "article_id", Value: "1"}},
 27			},
 28			mock: func(args args) {
 29				var res = models.ArticleResponse{}
 30				id, _ := strconv.ParseInt(args.params.ByName("article_id"), 0, 6)
 31				mockUsecase.On("GetByID", mock.Anything, id).Return(res, errors.New("got error")).Once()
 32			},
 33			wantStatusCode: http.StatusInternalServerError,
 34			want: models.ArticleListResponse{
 35				HeaderResponse: models.HeaderResponse{
 36					Code:   http.StatusInternalServerError,
 37					Status: "got error",
 38				},
 39			},
 40		},
 41		{
 42			name: "failed params not found",
 43			fields: fields{
 44				articleUsecase: mockUsecase,
 45			},
 46			args: args{
 47				params: []httprouter.Param{{Key: "article_id", Value: "a"}},
 48			},
 49			mock:           func(args args) {},
 50			wantStatusCode: http.StatusBadRequest,
 51			want: models.ArticleListResponse{
 52				HeaderResponse: models.HeaderResponse{
 53					Code:   http.StatusBadRequest,
 54					Status: "strconv.ParseInt: parsing \"a\": invalid syntax",
 55				},
 56			},
 57		},
 58		{
 59			name: "failed data not found",
 60			fields: fields{
 61				articleUsecase: mockUsecase,
 62			},
 63			args: args{
 64				params: []httprouter.Param{{Key: "article_id", Value: "1"}},
 65			},
 66			mock: func(args args) {
 67				var res = models.ArticleResponse{}
 68				id, _ := strconv.ParseInt(args.params.ByName("article_id"), 0, 64)
 69				mockUsecase.On("GetByID", mock.Anything, id).Return(res, nil).Once()
 70			},
 71			wantStatusCode: http.StatusNotFound,
 72			want: models.ArticleListResponse{
 73				HeaderResponse: models.HeaderResponse{
 74					Code:   http.StatusNotFound,
 75					Status: "data not found",
 76				},
 77			},
 78		},
 79		{
 80			name: "success get by id article",
 81			fields: fields{
 82				articleUsecase: mockUsecase,
 83			},
 84			args: args{
 85				params: []httprouter.Param{{Key: "article_id", Value: "1"}},
 86			},
 87			mock: func(args args) {
 88				var res = models.ArticleResponse{
 89					ID:       1,
 90					Title:    "test",
 91					Content:  "test content",
 92					CreateAt: timeNow,
 93					UpdateAt: timeNow,
 94				}
 95				id, _ := strconv.ParseInt(args.params.ByName("article_id"), 0, 64)
 96				mockUsecase.On("GetByID", mock.Anything, id).Return(res, nil).Once()
 97			},
 98			wantStatusCode: http.StatusOK,
 99			want: models.ArticleListResponse{
100				HeaderResponse: models.HeaderResponse{
101					Code:   http.StatusOK,
102					Status: "OK",
103				},
104				Data: []models.ArticleResponse{
105					{
106						ID:       1,
107						Title:    "test",
108						Content:  "test content",
109						CreateAt: timeNow,
110						UpdateAt: timeNow,
111					},
112				},
113			},
114		},
115	}
116	for _, tt := range tests {
117		t.Run(tt.name, func(t *testing.T) {
118			req := httptest.NewRequest("GET", "/test", nil)
119			w := httptest.NewRecorder()
120
121			tt.mock(tt.args)
122
123			d := &Delivery{
124				articleUsecase: tt.fields.articleUsecase,
125				validate:       tt.fields.validate,
126			}
127			d.GetByID(w, req, tt.args.params)
128			resp := w.Result()
129			body, _ := io.ReadAll(resp.Body)
130
131			var result models.ArticleListResponse
132			err := json.Unmarshal(body, &result)
133			if err != nil {
134				t.Errorf("error unmarshal %v", err)
135			}
136
137			assert.Equal(t, tt.wantStatusCode, resp.StatusCode)
138			assert.Equal(t, tt.want, result)
139		})
140	}
141}

unit test for Update

  1func TestDelivery_Update(t *testing.T) {
  2	mockUsecase := new(usecase.MockArticleUsecase)
  3	timeNow := time.Now().UTC()
  4	type fields struct {
  5		articleUsecase usecase.ArticleUsecase
  6		validate       *validator.Validate
  7	}
  8	type args struct {
  9		params  httprouter.Params
 10		request models.ArticleUpdateRequest
 11	}
 12	tests := []struct {
 13		name           string
 14		fields         fields
 15		args           args
 16		mock           func(args args)
 17		wantStatusCode int
 18		wantErr        bool
 19		want           models.ArticleListResponse
 20	}{
 21		{
 22			name: "failed when article_id not support",
 23			fields: fields{
 24				articleUsecase: mockUsecase,
 25			},
 26			args: args{
 27				params: []httprouter.Param{{Key: "article_id", Value: "a"}},
 28				request: models.ArticleUpdateRequest{
 29					ID:       1,
 30					Title:    "test data beneran",
 31					Content:  "test test data beneran",
 32					UpdateAt: timeNow,
 33				},
 34			},
 35			mock: func(args args) {
 36
 37			},
 38			wantErr:        true,
 39			wantStatusCode: http.StatusBadRequest,
 40			want: models.ArticleListResponse{
 41				HeaderResponse: models.HeaderResponse{
 42					Code:   http.StatusBadRequest,
 43					Status: "strconv.ParseInt: parsing \"a\": invalid syntax",
 44				},
 45			},
 46		},
 47		// {
 48		// 	name: "failed when encode body",
 49		// 	fields: fields{
 50		// 		articleUsecase: mockUsecase,
 51		// 		validate:       validator.New(),
 52		// 	},
 53		// 	args: args{
 54		// 		params: []httprouter.Param{{Key: "article_id", Value: "2"}},
 55		// 		request: models.ArticleUpdateRequest{
 56		// 			ID:       1,
 57		// 			Title:    "test",
 58		// 			Content:  "test",
 59		// 			UpdateAt: timeNow,
 60		// 		},
 61		// 	},
 62		// 	mock:           func(args args) {},
 63		// 	wantErr:        true,
 64		// 	wantStatusCode: http.StatusBadRequest,
 65		// 	want: models.ArticleListResponse{
 66		// 		HeaderResponse: models.HeaderResponse{
 67		// 			Code:   http.StatusBadRequest,
 68		// 			Status: "strconv.ParseInt: parsing \"a\": invalid syntax",
 69		// 		},
 70		// 	},
 71		// },
 72		{
 73			name: "failed when error validate",
 74			fields: fields{
 75				articleUsecase: mockUsecase,
 76				validate:       validator.New(),
 77			},
 78			args: args{
 79				params: []httprouter.Param{{Key: "article_id", Value: "2"}},
 80				request: models.ArticleUpdateRequest{
 81					ID:       1,
 82					Title:    "test",
 83					Content:  "test",
 84					UpdateAt: timeNow,
 85				},
 86			},
 87			mock:           func(args args) {},
 88			wantErr:        true,
 89			wantStatusCode: http.StatusBadRequest,
 90			want: models.ArticleListResponse{
 91				HeaderResponse: models.HeaderResponse{
 92					Code:   http.StatusBadRequest,
 93					Status: "Key: 'ArticleUpdateRequest.Title' Error:Field validation for 'Title' failed on the 'min' tag",
 94				},
 95			},
 96		},
 97		{
 98			name: "failed when update usecase was error",
 99			fields: fields{
100				articleUsecase: mockUsecase,
101				validate:       validator.New(),
102			},
103			args: args{
104				params: []httprouter.Param{{Key: "article_id", Value: "2"}},
105				request: models.ArticleUpdateRequest{
106					ID:       2,
107					Title:    "test data long",
108					Content:  "test",
109					UpdateAt: timeNow,
110				},
111			},
112			mock: func(args args) {
113				var res models.ArticleResponse
114				mockUsecase.On("Update", mock.Anything, args.request).Return(res, errors.New("got error")).Once()
115			},
116			wantErr:        true,
117			wantStatusCode: http.StatusInternalServerError,
118			want: models.ArticleListResponse{
119				HeaderResponse: models.HeaderResponse{
120					Code:   http.StatusInternalServerError,
121					Status: "got error",
122				},
123			},
124		},
125		{
126			name: "success update article",
127			fields: fields{
128				articleUsecase: mockUsecase,
129				validate:       validator.New(),
130			},
131			args: args{
132				params: []httprouter.Param{{Key: "article_id", Value: "2"}},
133				request: models.ArticleUpdateRequest{
134					ID:       2,
135					Title:    "test data long",
136					Content:  "test",
137					UpdateAt: timeNow,
138				},
139			},
140			mock: func(args args) {
141				var res models.ArticleResponse
142				mockUsecase.On("Update", mock.Anything, args.request).Return(res, nil).Once()
143			},
144			wantErr:        false,
145			wantStatusCode: http.StatusOK,
146			want: models.ArticleListResponse{
147				HeaderResponse: models.HeaderResponse{
148					Code:   http.StatusOK,
149					Status: "OK",
150				},
151				Data: []models.ArticleResponse{{}},
152			},
153		},
154	}
155	for _, tt := range tests {
156		t.Run(tt.name, func(t *testing.T) {
157			var b = &bytes.Buffer{}
158			if tt.args.request.Title != "" {
159				err := json.NewEncoder(b).Encode(tt.args.request)
160				if err != nil {
161					t.Fatal(err)
162				}
163			}
164
165			req := httptest.NewRequest("POST", "/test", b)
166			w := httptest.NewRecorder()
167
168			tt.mock(tt.args)
169
170			d := &Delivery{
171				articleUsecase: tt.fields.articleUsecase,
172				validate:       tt.fields.validate,
173			}
174
175			d.Update(w, req, tt.args.params)
176			resp := w.Result()
177			body, _ := io.ReadAll(resp.Body)
178
179			var result models.ArticleListResponse
180			err := json.Unmarshal(body, &result)
181			if err != nil {
182				t.Errorf("error unmarshal %v", err)
183			}
184
185			assert.Equal(t, tt.wantStatusCode, resp.StatusCode)
186			assert.Equal(t, tt.want, result)
187		})
188	}
189}

Unit test for Store

  1func TestDelivery_Store(t *testing.T) {
  2	mockUsecase := new(usecase.MockArticleUsecase)
  3	timeNow := time.Now().UTC()
  4	type fields struct {
  5		articleUsecase usecase.ArticleUsecase
  6		validate       *validator.Validate
  7	}
  8	type args struct {
  9		params  httprouter.Params
 10		request models.ArticleCreateRequest
 11	}
 12	tests := []struct {
 13		name           string
 14		fields         fields
 15		args           args
 16		mock           func(args args)
 17		wantStatusCode int
 18		wantErr        bool
 19		want           models.ArticleListResponse
 20	}{
 21		// {
 22		// 	name: "failed when parse json body",
 23		// 		articleUsecase: mockUsecase,
 24		// 		validate:       validator.New(),
 25		// 	},
 26		// 	args: args{
 27		// 		params: []httprouter.Param{{Key: "article_id", Value: "2"}},
 28		// 		request: models.ArticleUpdateRequest{
 29		// 			ID:       1,
 30		// 			Title:    "test",
 31		// 			Content:  "test",
 32		// 			UpdateAt: timeNow,
 33		// 		},
 34		// 	},
 35		// 	mock:           func(args args) {},
 36		// 	wantErr:        true,
 37		// 	wantStatusCode: http.StatusBadRequest,
 38		// 	want: models.ArticleListResponse{
 39		// 		HeaderResponse: models.HeaderResponse{
 40		// 			Code:   http.StatusBadRequest,
 41		// 			Status: "strconv.ParseInt: parsing \"a\": invalid syntax",
 42		// 		},
 43		// 	},
 44		// },
 45		// },
 46		{
 47			name: "failed when error validate",
 48			fields: fields{
 49				articleUsecase: mockUsecase,
 50				validate:       validator.New(),
 51			},
 52			args: args{
 53				params: []httprouter.Param{{Key: "article_id", Value: "2"}},
 54				request: models.ArticleCreateRequest{
 55					Title:    "test",
 56					Content:  "test",
 57					CreateAt: timeNow,
 58				},
 59			},
 60			mock:           func(args args) {},
 61			wantErr:        true,
 62			wantStatusCode: http.StatusBadRequest,
 63			want: models.ArticleListResponse{
 64				HeaderResponse: models.HeaderResponse{
 65					Code:   http.StatusBadRequest,
 66					Status: "Key: 'ArticleCreateRequest.Title' Error:Field validation for 'Title' failed on the 'min' tag",
 67				},
 68			},
 69		},
 70		{
 71			name: "failed when update usecase was error",
 72			fields: fields{
 73				articleUsecase: mockUsecase,
 74				validate:       validator.New(),
 75			},
 76			args: args{
 77				params: []httprouter.Param{{Key: "article_id", Value: "2"}},
 78				request: models.ArticleCreateRequest{
 79					Title:    "test data long",
 80					Content:  "test",
 81					CreateAt: timeNow,
 82				},
 83			},
 84			mock: func(args args) {
 85				var res models.ArticleResponse
 86				mockUsecase.On("Store", mock.Anything, args.request).Return(res, errors.New("got error")).Once()
 87			},
 88			wantErr:        true,
 89			wantStatusCode: http.StatusInternalServerError,
 90			want: models.ArticleListResponse{
 91				HeaderResponse: models.HeaderResponse{
 92					Code:   http.StatusInternalServerError,
 93					Status: "got error",
 94				},
 95			},
 96		},
 97		{
 98			name: "success update article",
 99			fields: fields{
100				articleUsecase: mockUsecase,
101				validate:       validator.New(),
102			},
103			args: args{
104				params: []httprouter.Param{{Key: "article_id", Value: "2"}},
105				request: models.ArticleCreateRequest{
106					Title:    "test data long",
107					Content:  "test",
108					CreateAt: timeNow,
109				},
110			},
111			mock: func(args args) {
112				var res models.ArticleResponse
113				mockUsecase.On("Store", mock.Anything, args.request).Return(res, nil).Once()
114			},
115			wantErr:        false,
116			wantStatusCode: http.StatusOK,
117			want: models.ArticleListResponse{
118				HeaderResponse: models.HeaderResponse{
119					Code:   http.StatusOK,
120					Status: "OK",
121				},
122				Data: []models.ArticleResponse{{}},
123			},
124		},
125	}
126	for _, tt := range tests {
127		t.Run(tt.name, func(t *testing.T) {
128			var b = &bytes.Buffer{}
129			if tt.args.request.Title != "" {
130				err := json.NewEncoder(b).Encode(tt.args.request)
131				if err != nil {
132					t.Fatal(err)
133				}
134			}
135
136			req := httptest.NewRequest("POST", "/test", b)
137			w := httptest.NewRecorder()
138
139			tt.mock(tt.args)
140
141			d := &Delivery{
142				articleUsecase: tt.fields.articleUsecase,
143				validate:       tt.fields.validate,
144			}
145
146			d.Store(w, req, tt.args.params)
147			resp := w.Result()
148			body, _ := io.ReadAll(resp.Body)
149
150			var result models.ArticleListResponse
151			err := json.Unmarshal(body, &result)
152			if err != nil {
153				t.Errorf("error unmarshal %v", err)
154			}
155			assert.Equal(t, tt.wantStatusCode, resp.StatusCode)
156			assert.Equal(t, tt.want, result)
157		})
158	}
159}

Unit test Delete

  1func TestDelivery_Delete(t *testing.T) {
  2	mockUsecase := new(usecase.MockArticleUsecase)
  3	type fields struct {
  4		articleUsecase usecase.ArticleUsecase
  5		validate       *validator.Validate
  6	}
  7	type args struct {
  8		params  httprouter.Params
  9		request models.ArticleCreateRequest
 10	}
 11	tests := []struct {
 12		name           string
 13		fields         fields
 14		args           args
 15		mock           func(args args)
 16		wantStatusCode int
 17		wantErr        bool
 18		want           models.ArticleListResponse
 19	}{
 20		{
 21			name: "failed delete by id article",
 22			fields: fields{
 23				articleUsecase: mockUsecase,
 24			},
 25			args: args{
 26				params: []httprouter.Param{{Key: "article_id", Value: "1"}},
 27			},
 28			mock: func(args args) {
 29				id, _ := strconv.ParseInt(args.params.ByName("article_id"), 0, 6)
 30				mockUsecase.On("Delete", mock.Anything, id).Return(false, errors.New("got error")).Once()
 31			},
 32			wantStatusCode: http.StatusInternalServerError,
 33			want: models.ArticleListResponse{
 34				HeaderResponse: models.HeaderResponse{
 35					Code:   http.StatusInternalServerError,
 36					Status: "got error",
 37				},
 38			},
 39		},
 40		{
 41			name: "failed params not found",
 42			fields: fields{
 43				articleUsecase: mockUsecase,
 44			},
 45			args: args{
 46				params: []httprouter.Param{{Key: "article_id", Value: "a"}},
 47			},
 48			mock:           func(args args) {},
 49			wantStatusCode: http.StatusBadRequest,
 50			want: models.ArticleListResponse{
 51				HeaderResponse: models.HeaderResponse{
 52					Code:   http.StatusBadRequest,
 53					Status: "strconv.ParseInt: parsing \"a\": invalid syntax",
 54				},
 55			},
 56		},
 57		{
 58			name: "failed data not found",
 59			fields: fields{
 60				articleUsecase: mockUsecase,
 61			},
 62			args: args{
 63				params: []httprouter.Param{{Key: "article_id", Value: "0"}},
 64			},
 65			mock: func(args args) {
 66				id, _ := strconv.ParseInt(args.params.ByName("article_id"), 0, 64)
 67				mockUsecase.On("Delete", mock.Anything, id).Return(false, nil).Once()
 68			},
 69			wantStatusCode: http.StatusNotFound,
 70			want: models.ArticleListResponse{
 71				HeaderResponse: models.HeaderResponse{
 72					Code:   http.StatusNotFound,
 73					Status: "article_id was not zero",
 74				},
 75			},
 76		},
 77		{
 78			name: "success delete by id article",
 79			fields: fields{
 80				articleUsecase: mockUsecase,
 81			},
 82			args: args{
 83				params: []httprouter.Param{{Key: "article_id", Value: "1"}},
 84			},
 85			mock: func(args args) {
 86				id, _ := strconv.ParseInt(args.params.ByName("article_id"), 0, 64)
 87				mockUsecase.On("Delete", mock.Anything, id).Return(true, nil).Once()
 88			},
 89			wantStatusCode: http.StatusOK,
 90			want: models.ArticleListResponse{
 91				HeaderResponse: models.HeaderResponse{
 92					Code:   http.StatusOK,
 93					Status: "OK",
 94				},
 95			},
 96		},
 97		{
 98			name: "delete by article_id but data not found",
 99			fields: fields{
100				articleUsecase: mockUsecase,
101			},
102			args: args{
103				params: []httprouter.Param{{Key: "article_id", Value: "1"}},
104			},
105			mock: func(args args) {
106				id, _ := strconv.ParseInt(args.params.ByName("article_id"), 0, 64)
107				mockUsecase.On("Delete", mock.Anything, id).Return(false, nil).Once()
108			},
109			wantStatusCode: http.StatusInternalServerError,
110			wantErr:        true,
111			want: models.ArticleListResponse{
112				HeaderResponse: models.HeaderResponse{
113					Code:   http.StatusInternalServerError,
114					Status: "unknown error",
115				},
116			},
117		},
118	}
119	for _, tt := range tests {
120		t.Run(tt.name, func(t *testing.T) {
121			var b = &bytes.Buffer{}
122			if tt.args.request.Title != "" {
123				err := json.NewEncoder(b).Encode(tt.args.request)
124				if err != nil {
125					t.Fatal(err)
126				}
127			}
128
129			req := httptest.NewRequest("GET", "/test", b)
130			w := httptest.NewRecorder()
131
132			tt.mock(tt.args)
133
134			d := &Delivery{
135				articleUsecase: tt.fields.articleUsecase,
136				validate:       tt.fields.validate,
137			}
138			d.Delete(w, req, tt.args.params)
139			resp := w.Result()
140			body, _ := io.ReadAll(resp.Body)
141
142			var result models.ArticleListResponse
143			err := json.Unmarshal(body, &result)
144			if err != nil {
145				t.Errorf("error unmarshal %v", err)
146			}
147			assert.Equal(t, tt.wantStatusCode, resp.StatusCode)
148			assert.Equal(t, tt.want, result)
149		})
150	}
151}

All unit tests have been made so that all our functions can be tested properly and adjust to the needs of friends. This unit test is very important when we want to make improvements or add needs when there are changes, the unit test is used to test the existing flow and the newly added flow so that no errors occur in the system in the future.

Furthermore, to make it easier to run unit tests we need to add the unit test command to the Makefile as follows

make

1mock:
2	go generate ./...
3
4test:
5	go test -race -cover ./...

The mock command is used to re-generate when we add or change a function in an interface that has a mock. As for test we use it to run unit test commands from all functions in this project.

Here is an example of our results running

bash

 1➜ make test 
 2go test -race -cover ./...
 3?       github.com/santekno/learn-golang-restful/cmd  [no test files]
 4?       github.com/santekno/learn-golang-restful/internal/repository  [no test files]
 5?       github.com/santekno/learn-golang-restful/internal/usecase     [no test files]
 6ok      github.com/santekno/learn-golang-restful/internal/delivery/http       (cached)        coverage: 94.1% of statements
 7ok      github.com/santekno/learn-golang-restful/internal/middleware  (cached)        coverage: 100.0% of statements
 8ok      github.com/santekno/learn-golang-restful/internal/models      (cached)        coverage: 100.0% of statements
 9ok      github.com/santekno/learn-golang-restful/internal/repository/mysql    (cached)        coverage: 94.7% of statements
10?       github.com/santekno/learn-golang-restful/pkg/database [no test files]
11ok      github.com/santekno/learn-golang-restful/internal/usecase/article     (cached)        coverage: 100.0% of statements
12ok      github.com/santekno/learn-golang-restful/pkg/middleware-chain (cached)        coverage: 100.0% of statements
13ok      github.com/santekno/learn-golang-restful/pkg/util     (cached)        coverage: 83.3% of statements

Go 28 Jul 2026

11 Add Unit Tests Using Mockery

Unit Test Repository

Create initialitation unit test

Unit test for GetAll function

Create unit test for GetByID

Create unit test for Update function

Create Unit test for Store function

Create unit test for Delete function

Creating a Usecase level unit test

Create unit test for GetAll

Create Unit test for GetByID

Create unit test for Update

Create unit test for Store

Create unit test for Delete

Creating Unit tests on Handlers

Unit test for GetAll

Unit test for GetByID

unit test for Update

Unit test for Store

Unit test Delete

Related Articles

Plan Mode in Claude Code: Build a Solid Golang Implementation Plan

Non-Functional Specifications: Performance, Security, Scalability

Your First OpenAPI Spec with Claude: Contract-First API Design

The "Interview Yourself" Pattern: Clarification Technique with Claude

💬 Comments