change: refactor and lint code (#2)

* change (build): remove vendor

+ remove vendor directory
+ use go mod instead
+ reduce code base in repository

* chore (lint): fix lint warnings

* change (keyvalue): refactor keyvalue package

+ create unittest
+ change some error handling in keyvalue package

* change (git): update .gitignore

go.mod

@@ -3,6 +3,7 @@ module github.com/zalopay-oss/tokeny
 go 1.14
 
 require (
+	github.com/DATA-DOG/go-sqlmock v1.5.0
 	github.com/atotto/clipboard v0.1.2
 	github.com/golang/mock v1.4.4
 	github.com/manifoldco/promptui v0.7.0

go.sum

@@ -1,4 +1,6 @@
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
+github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 github.com/PuerkitoBio/goquery v1.5.1/go.mod h1:GsLWisAFVj4WgDibEWF4pvYnkVQBpKBKeU+7zCJoLcc=
 github.com/andybalholm/cascadia v1.1.0/go.mod h1:GsXiBklL0woXo1j/WYWtSYYC4ouU9PqHO0sqidkEA4Y=
 github.com/atotto/clipboard v0.1.2 h1:YZCtFu5Ie8qX2VmVTBnrqLSiU9XOWwqNRmdT3gIQzbY=

main.go

@@ -2,15 +2,16 @@ package main
 
 import (
 	"fmt"
+	"log"
+	"os"
+	"os/user"
+
 	"github.com/urfave/cli/v2"
 	"github.com/zalopay-oss/tokeny/pkg/keyvalue"
 	"github.com/zalopay-oss/tokeny/pkg/password"
 	"github.com/zalopay-oss/tokeny/pkg/session"
 	"github.com/zalopay-oss/tokeny/pkg/tokeny"
 	"github.com/zalopay-oss/tokeny/pkg/tokenycli"
-	"log"
-	"os"
-	"os/user"
 )
 
 func main() {

pkg/crypto/utils.go

@@ -1,12 +1,17 @@
+// nolint: gosec
 package crypto
 
 import (
 	"crypto/hmac"
 	"crypto/sha1"
+	"log"
 )
 
 func ComputeHMACSHA1(key []byte, data []byte) []byte {
 	h := hmac.New(sha1.New, key)
-	h.Write(data)
+	_, err := h.Write(data)
+	if err != nil {
+		log.Fatalln(err)
+	}
 	return h.Sum(nil)
 }

pkg/hotp/hotp.go

@@ -3,18 +3,28 @@ package hotp
 import (
 	"encoding/binary"
 	"fmt"
+	"math"
+
 	"github.com/zalopay-oss/tokeny/pkg/crypto"
 	"github.com/zalopay-oss/tokeny/pkg/utils"
-	"math"
 )
 
 func Generate(key []byte, counter []byte, otpLength int) string {
 	hash := crypto.ComputeHMACSHA1(key, counter)
-	offset := hash[19] & 0xf
-	truncatedHash := hash[offset : offset+4]
-	truncatedHash[0] = truncatedHash[0] & 0x7f
+	truncatedHash := truncate(hash)
 	hNum := binary.BigEndian.Uint32(truncatedHash)
 	otp := hNum % (uint32)(math.Pow10(otpLength))
 	result := utils.Padding0(fmt.Sprint(otp), otpLength)
 	return result
 }
+
+func truncate(hash []byte) []byte {
+	var (
+		last4BitFilter byte = 0xf
+		firstBitFilter byte = 0x7f
+	)
+	offset := hash[19] & last4BitFilter
+	truncatedHash := hash[offset : offset+4]
+	truncatedHash[0] &= firstBitFilter
+	return truncatedHash
+}

pkg/keyvalue/sqlStore.go

@@ -2,9 +2,10 @@ package keyvalue
 
 import (
 	"database/sql"
+	"log"
+
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/pkg/errors"
-	"log"
 )
 
 const (
@@ -36,13 +37,6 @@ func (s *sqlStore) ensureTable() error {
 	return err
 }
 
-func (s *sqlStore) logErr(err error) {
-	if err == nil {
-		return
-	}
-	log.Printf("%q", err)
-}
-
 func (s *sqlStore) Set(key string, value string) error {
 	exist, err := s.exist(key)
 	if err != nil {
@@ -76,12 +70,19 @@ func (s *sqlStore) Get(key string) (string, error) {
 		return "", err
 	}
 
+	defer func() {
+		err := stmt.Close()
+		if err != nil {
+			log.Fatalln(err)
+		}
+	}()
+
 	var value string
 	err = stmt.QueryRow(key).Scan(&value)
+	if errors.Is(err, sql.ErrNoRows) {
+		return "", ErrNoRecord
+	}
 	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return "", ErrNoRecord
-		}
 		return "", err
 	}
 
@@ -94,46 +95,63 @@ func (s *sqlStore) Delete(key string) error {
 		return err
 	}
 
-	var value string
-	err = stmt.QueryRow(key).Scan(&value)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return ErrNoRecord
+	defer func() {
+		err := stmt.Close()
+		if err != nil {
+			log.Fatalln(err)
 		}
+	}()
+
+	err = stmt.QueryRow(key).Err()
+	if errors.Is(err, sql.ErrNoRows) {
+		return ErrNoRecord
+	}
+	if err != nil {
 		return err
 	}
 
-	_, err = s.db.Exec(_deleteSQL, key)
-	if err != nil {
+	if _, err := s.db.Exec(_deleteSQL, key); err != nil {
 		return err
 	}
 	return nil
 }
 
 func (s *sqlStore) GetAllWithPrefixed(keyPrefix string) ([]KeyValue, error) {
 	stmt, err := s.db.Prepare(_allPrefixedSQL)
+	defer func() {
+		err := stmt.Close()
+		if err != nil {
+			log.Fatalln(err)
+		}
+	}()
 	if err != nil {
 		return nil, err
 	}
 
 	result := make([]KeyValue, 0)
 
-	r, err := stmt.Query(keyPrefix + "%")
+	rows, err := stmt.Query(keyPrefix + "%")
 	if err != nil {
 		return nil, err
 	}
-	defer r.Close()
 
-	for r.Next() {
+	defer func() {
+		if rows.Err() != nil {
+			log.Fatalln(rows.Err())
+		}
+		err := rows.Close()
+		if err != nil {
+			log.Fatalln(err)
+		}
+	}()
+
+	for rows.Next() {
 		var k, v string
-		err = r.Scan(&k, &v)
+		err = rows.Scan(&k, &v)
 		if err != nil {
 			return nil, err
 		}
 		result = append(result, KeyValue{Key: k, Value: v})
 	}
-	if err := r.Err(); err != nil {
-		return nil, err
-	}
 	return result, nil
 }

pkg/keyvalue/sqlStore_test.go

@@ -0,0 +1,117 @@
+package keyvalue
+
+import (
+	"database/sql"
+	"testing"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	_ "github.com/mattn/go-sqlite3"
+	"github.com/stretchr/testify/suite"
+)
+
+type sqlStoreTestSuite struct {
+	suite.Suite
+	sqlDB *sql.DB
+	mock  sqlmock.Sqlmock
+}
+
+func (s *sqlStoreTestSuite) SetupTest() {
+	conn, mock, err := sqlmock.New(
+		sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual),
+	)
+	if err != nil {
+		s.Fail("error creating db connection", err)
+	}
+	s.sqlDB = conn
+	s.mock = mock
+}
+
+func (s *sqlStoreTestSuite) TearDownTest() {
+	s.mock.ExpectClose()
+	err := s.sqlDB.Close()
+	if err != nil {
+		s.Fail("error closing db connection", err)
+	}
+	if err := s.mock.ExpectationsWereMet(); err != nil {
+		s.Fail("all expectation were not met", err)
+	}
+}
+
+func (s *sqlStoreTestSuite) TestGetSuccessfully() {
+	key := "foo"
+	expected := "bar"
+	s.mock.ExpectPrepare(_selectSQL).
+		ExpectQuery().
+		WithArgs(key).
+		WillReturnRows(sqlmock.NewRows([]string{"v"}).AddRow(expected))
+
+	// Do test
+	store := &sqlStore{s.sqlDB}
+	result, err := store.Get(key)
+	s.NoError(err)
+	s.Equal(expected, result, "expect result = %s", expected)
+	if err := s.mock.ExpectationsWereMet(); err != nil {
+		s.Fail("all expectation were not met", err)
+	}
+
+}
+func (s *sqlStoreTestSuite) TestGetEmptyKey() {
+	key := "foo"
+	s.mock.ExpectPrepare(_selectSQL).
+		ExpectQuery().
+		WithArgs(key).
+		WillReturnError(sql.ErrNoRows)
+
+	// Do test
+	store := &sqlStore{s.sqlDB}
+	result, err := store.Get(key)
+	s.EqualError(err, ErrNoRecord.Error())
+	s.Empty(result)
+	if err := s.mock.ExpectationsWereMet(); err != nil {
+		s.Fail("all expectation were not met", err)
+	}
+
+}
+
+func (s *sqlStoreTestSuite) TestDeleteSuccessfully() {
+	key := "foo"
+	s.mock.ExpectPrepare(_selectSQL).
+		ExpectQuery().
+		WithArgs(key).
+		WillReturnRows(
+			sqlmock.NewRows([]string{"k", "v"}).
+				AddRow(key, "bar"),
+		)
+	s.mock.ExpectExec(_deleteSQL).
+		WithArgs(key).
+		WillReturnResult(sqlmock.NewResult(1, 1))
+
+	// Do test
+	store := &sqlStore{s.sqlDB}
+	err := store.Delete(key)
+	s.NoError(err)
+	if err := s.mock.ExpectationsWereMet(); err != nil {
+		s.Fail("all expectation were not met", err)
+	}
+
+}
+func (s *sqlStoreTestSuite) TestDeleteEmptyKey() {
+	key := "foo"
+	s.mock.ExpectPrepare(_selectSQL).
+		ExpectQuery().
+		WithArgs(key).
+		WillReturnError(sql.ErrNoRows)
+
+	// Do test
+	store := &sqlStore{s.sqlDB}
+	err := store.Delete(key)
+	s.EqualError(err, ErrNoRecord.Error())
+	if err := s.mock.ExpectationsWereMet(); err != nil {
+		s.Fail("all expectation were not met", err)
+	}
+
+}
+
+func TestSqlStore(t *testing.T) {
+	suite.Run(t, new(sqlStoreTestSuite))
+}

pkg/password/errors.go

@@ -4,6 +4,6 @@ import "github.com/pkg/errors"
 
 var (
 	ErrPasswordsMismatch = errors.New("passwords do not match")
-	ErrNotRegistered = errors.New("have not registered yet")
-	ErrWrongPassword = errors.New("wrong password")
+	ErrNotRegistered     = errors.New("have not registered yet")
+	ErrWrongPassword     = errors.New("wrong password")
 )

pkg/password/manager.go

@@ -2,8 +2,9 @@ package password
 
 import (
 	"encoding/hex"
-	"github.com/zalopay-oss/tokeny/pkg/keyvalue"
+
 	"github.com/pkg/errors"
+	"github.com/zalopay-oss/tokeny/pkg/keyvalue"
 	"golang.org/x/crypto/bcrypt"
 )
 
@@ -75,4 +76,3 @@ func (m *manager) Login(pwd string) error {
 
 	return nil
 }
-

pkg/session/manager.go

@@ -3,9 +3,10 @@ package session
 import (
 	"errors"
 	"fmt"
-	"github.com/zalopay-oss/tokeny/pkg/keyvalue"
 	"strconv"
 	"time"
+
+	"github.com/zalopay-oss/tokeny/pkg/keyvalue"
 )
 
 const (

pkg/tokeny/errors.go

@@ -3,6 +3,6 @@ package tokeny
 import "github.com/pkg/errors"
 
 var (
-	ErrNoEntryFound = errors.New("no entry found")
+	ErrNoEntryFound       = errors.New("no entry found")
 	ErrEntryExistedBefore = errors.New("entry existed before")
 )

pkg/tokeny/repository.go

@@ -2,10 +2,11 @@ package tokeny
 
 import (
 	"errors"
-	"github.com/zalopay-oss/tokeny/pkg/keyvalue"
-	"github.com/zalopay-oss/tokeny/pkg/totp"
 	"strings"
 	"unicode"
+
+	"github.com/zalopay-oss/tokeny/pkg/keyvalue"
+	"github.com/zalopay-oss/tokeny/pkg/totp"
 )
 
 const (
@@ -85,7 +86,7 @@ func (r *repository) List() ([]string, error) {
 	if err != nil {
 		return nil, err
 	}
-	result := make([]string, len(kvs), len(kvs))
+	result := make([]string, len(kvs))
 	for i, kv := range kvs {
 		result[i] = strings.TrimPrefix(kv.Key, entryKeyPrefix)
 	}