From 84f2e8fcd5d363e8c4d78c750b3feaf47e6a5903 Mon Sep 17 00:00:00 2001 From: Kamaleshwar Date: Sun, 6 Oct 2024 16:42:43 +0200 Subject: [PATCH] [-] use testify package for assertions --- currency_test.go | 173 +++++++++++-------------------------------- go.mod | 2 + go.sum | 19 +++++ operations_test.go | 181 ++++++++++++--------------------------------- 4 files changed, 110 insertions(+), 265 deletions(-) create mode 100644 go.sum diff --git a/currency_test.go b/currency_test.go index df60e1f..758af50 100644 --- a/currency_test.go +++ b/currency_test.go @@ -1,10 +1,11 @@ package currency import ( - "errors" "fmt" "strconv" "testing" + + "github.com/stretchr/testify/assert" ) type output struct { @@ -87,6 +88,7 @@ var newTests = []struct { } func TestNew(t *testing.T) { + asserter := assert.New(t) for _, nT := range newTests { cur, err := New( nT.inp.main, @@ -96,44 +98,24 @@ func TestNew(t *testing.T) { nT.inp.fulabel, nT.inp.fushare) if err != nil { - if !errors.Is(err, nT.out.err) { - t.Fatal(err) - } + asserter.ErrorIs(err, nT.out.err) continue } - if cur.Main != nT.out.main { - t.Log("Expected:", nT.out.main, "got:", cur.Main) - t.Fail() - } - - if cur.Fractional != nT.out.fractional { - t.Log("Expected:", nT.out.fractional, "got:", cur.Fractional) - t.Fail() - } + asserter.Equal(nT.out.main, cur.Main) + asserter.Equal(nT.out.fractional, cur.Fractional) + asserter.Equal(nT.out.float, cur.Float64()) + asserter.Equal(nT.out.totalfractional, cur.FractionalTotal()) cur.PrefixSymbol = true - str := cur.String() - if str != nT.out.str { - t.Log("Expected:", nT.out.str, "got:", str) - t.Fail() - } - - if cur.Float64() != nT.out.float { - t.Log("Expected:", nT.out.float, "got:", cur.Float64()) - t.Fail() - } + asserter.Equal(nT.out.str, cur.String()) - ft := cur.FractionalTotal() - if ft != nT.out.totalfractional { - t.Log("Expected:", nT.out.totalfractional, "got:", ft) - t.Fail() - } } } func TestNewFractional(t *testing.T) { + asserter := assert.New(t) for _, nT := range newTests { cur, err := NewFractional( nT.inp.totalfractional, @@ -143,43 +125,23 @@ func TestNewFractional(t *testing.T) { nT.inp.fushare) if err != nil { - if !errors.Is(err, nT.out.err) { - t.Fatal(err) - } + asserter.ErrorIs(err, nT.out.err) continue } - if cur.Main != nT.out.main { - t.Log("Expected:", nT.out.main, "got:", cur.Main) - t.Fail() - } - - if cur.Fractional != nT.out.fractional { - t.Log("Expected:", nT.out.fractional, "got:", cur.Fractional) - t.Fail() - } + asserter.Equal(nT.out.main, cur.Main) + asserter.Equal(nT.out.fractional, cur.Fractional) + asserter.Equal(nT.out.float, cur.Float64()) + asserter.Equal(nT.out.totalfractional, cur.FractionalTotal()) cur.PrefixSymbol = true - str := cur.String() - if str != nT.out.str { - t.Log("Expected:", nT.out.str, "got:", str) - t.Fail() - } - - if cur.Float64() != nT.out.float { - t.Log("Expected:", nT.out.float, "got:", cur.Float64()) - t.Fail() - } - - ft := cur.FractionalTotal() - if ft != nT.out.totalfractional { - t.Log("Expected:", nT.out.totalfractional, "got:", ft) - t.Fail() - } + asserter.Equal(nT.out.str, cur.String()) } } func TestParseStr(t *testing.T) { + asserter := assert.New(t) + for _, nT := range newTests { cur, err := ParseString( nT.inp.str, @@ -189,51 +151,25 @@ func TestParseStr(t *testing.T) { nT.inp.fushare) if err != nil { - if !errors.Is(err, nT.out.err) { - t.Fatal(err) - } + asserter.ErrorIs(err, nT.out.err) continue } - if cur.Main != nT.out.main { - t.Log("Expected:", nT.out.main, "got:", cur.Main) - t.Fail() - } - - if cur.Fractional != nT.out.fractional { - t.Log("Expected:", nT.out.fractional, "got:", cur.Fractional) - t.Fail() - } + asserter.Equal(nT.out.main, cur.Main) + asserter.Equal(nT.out.fractional, cur.Fractional) + asserter.Equal(nT.out.float, cur.Float64()) + asserter.Equal(nT.out.totalfractional, cur.FractionalTotal()) cur.PrefixSymbol = true - str := cur.String() - if str != nT.out.str { - t.Log("Expected:", nT.out.str, "got:", str) - t.Fail() - } - - if cur.Float64() != nT.out.float { - t.Log("Expected:", nT.out.float, "got:", cur.Float64()) - t.Fail() - } - - ft := cur.FractionalTotal() - if ft != nT.out.totalfractional { - t.Log("Expected:", nT.out.totalfractional, "got:", ft) - t.Fail() - } + asserter.Equal(nT.out.str, cur.String()) } - // code: "INR", - // symbol: "₹", - // fulabel: "paise", _, err := ParseString("", "INR", "₹", "paise", 0) - if !errors.Is(err, strconv.ErrSyntax) { - t.Error(err) - } + asserter.ErrorIs(err, strconv.ErrSyntax) } func TestParseFloat64(t *testing.T) { + asserter := assert.New(t) for _, nT := range newTests { cur, err := ParseFloat64( nT.inp.float, @@ -243,43 +179,21 @@ func TestParseFloat64(t *testing.T) { nT.inp.fushare) if err != nil { - if !errors.Is(err, nT.out.err) { - t.Fatal(err) - } + asserter.ErrorIs(err, nT.out.err) continue } - - if cur.Main != nT.out.main { - t.Log("Expected:", nT.out.main, "got:", cur.Main) - t.Fail() - } - - if cur.Fractional != nT.out.fractional { - t.Log("Expected:", nT.out.fractional, "got:", cur.Fractional) - t.Fail() - } + asserter.Equal(nT.out.main, cur.Main) + asserter.Equal(nT.out.fractional, cur.Fractional) + asserter.Equal(nT.out.float, cur.Float64()) + asserter.Equal(nT.out.totalfractional, cur.FractionalTotal()) cur.PrefixSymbol = true - str := cur.String() - if str != nT.out.str { - t.Log("Expected:", nT.out.str, "got:", str) - t.Fail() - } - - if cur.Float64() != nT.out.float { - t.Log("Expected:", nT.out.float, "got:", cur.Float64()) - t.Fail() - } - - ft := cur.FractionalTotal() - if ft != nT.out.totalfractional { - t.Log("Expected:", nT.out.totalfractional, "got:", ft) - t.Fail() - } + asserter.Equal(nT.out.str, cur.String()) } } func TestFormat(t *testing.T) { + asserter := assert.New(t) c, _ := New(12, 75, "INR", "₹", "paise", 100) list := []struct { Verb string @@ -329,34 +243,31 @@ func TestFormat(t *testing.T) { c.SuffixSymbol = l.Suffix formatstr := "%" + l.Verb - str := fmt.Sprintf(formatstr, c) - if str != l.Expected { - t.Errorf("Format string: %s, Expected '%s', got '%s'", formatstr, l.Expected, str) - } + asserter.Equal(l.Expected, fmt.Sprintf(formatstr, c)) } } func BenchmarkNew(t *testing.B) { for i := 0; i < t.N; i++ { - New(10, 50, "INR", "₹", "paise", 100) + _, _ = New(10, 50, "INR", "₹", "paise", 100) } } func BenchmarkNewFractional(t *testing.B) { for i := 0; i < t.N; i++ { - NewFractional(1005, "INR", "₹", "paise", 100) + _, _ = NewFractional(1005, "INR", "₹", "paise", 100) } } func BenchmarkParseFloat64(t *testing.B) { for i := 0; i < t.N; i++ { - ParseFloat64(10.05, "INR", "₹", "paise", 100) + _, _ = ParseFloat64(10.05, "INR", "₹", "paise", 100) } } func BenchmarkParseString(t *testing.B) { for i := 0; i < t.N; i++ { - ParseString("10.05", "INR", "₹", "paise", 100) + _, _ = ParseString("10.05", "INR", "₹", "paise", 100) } } @@ -364,21 +275,21 @@ func BenchmarkString(t *testing.B) { cur1, _ := New(10, 5, "INR", "₹", "paise", 100) cur1.PrefixSymbol = true for i := 0; i < t.N; i++ { - cur1.String() + _ = cur1.String() } } func BenchmarkStringNoPrefix(t *testing.B) { cur1, _ := New(10, 5, "INR", "₹", "paise", 100) for i := 0; i < t.N; i++ { - cur1.StringWithoutSymbols() + _ = cur1.StringWithoutSymbols() } } func BenchmarkFloat64(t *testing.B) { cur1, _ := New(10, 5, "INR", "₹", "paise", 100) for i := 0; i < t.N; i++ { - cur1.Float64() + _ = cur1.Float64() } } @@ -386,7 +297,7 @@ func BenchmarkFractionalTotal(t *testing.B) { cur1, _ := New(1, 0, "INR", "₹", "paise", 100) for i := 0; i < t.N; i++ { - cur1.FractionalTotal() + _ = cur1.FractionalTotal() } } diff --git a/go.mod b/go.mod index 9918ac5..98ac14a 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,5 @@ module github.com/naughtygopher/currency/v2 go 1.14 + +require github.com/stretchr/testify v1.9.0 diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..8f0c6a1 --- /dev/null +++ b/go.sum @@ -0,0 +1,19 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/operations_test.go b/operations_test.go index 2bc3a02..cb4e61d 100644 --- a/operations_test.go +++ b/operations_test.go @@ -2,187 +2,100 @@ package currency import ( "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestUpdateWithFractional(t *testing.T) { + requirer := require.New(t) + asserter := assert.New(t) + cur, err := New(1, 0, "INR", "₹", "paise", 100) - if err != nil { - t.Fatal(err) - } - cur.UpdateWithFractional(1005) - if cur.Main != 10 { - t.Log("Expected 10, got:", cur.Main) - t.Fail() - } + requirer.NoError(err) - if cur.Fractional != 5 { - t.Log("Expected 5, got:", cur.Fractional) - t.Fail() - } + cur.UpdateWithFractional(1005) + asserter.Equal(10, cur.Main) + asserter.Equal(5, cur.Fractional) cur.PrefixSymbol = true - s := cur.String() - if s != "₹10.05" { - t.Log("Expected ₹10.05, got:", s) - t.Fail() - } - - if cur.Float64() != 10.05 { - t.Log("Expected 10.05, got:", cur.Float64()) - t.Fail() - } - + asserter.Equal("₹10.05", cur.String()) + asserter.Equal(10.05, cur.Float64()) } func TestAdd(t *testing.T) { + requirer := require.New(t) + asserter := assert.New(t) + cur1, err := New(10, 99, "INR", "₹", "paise", 100) - if err != nil { - t.Log(err) - t.Fail() - return - } + requirer.NoError(err) cur2, err := New(10, 99, "INR", "₹", "paise", 100) - if err != nil { - t.Log(err) - t.Fail() - return - } + requirer.NoError(err) cur1.Add(*cur2) - if cur1.Main != 21 { - t.Log("Expected 21, got:", cur1.Main) - t.Fail() - } - - if cur1.Fractional != 98 { - t.Log("Expected 98, got:", cur1.Fractional) - t.Fail() - } + asserter.Equal(21, cur1.Main) + asserter.Equal(98, cur1.Fractional) + asserter.Equal(21.91, cur1.Float64()) cur1.PrefixSymbol = true - str := cur1.String() - if str != "₹21.98" { - t.Log("Expected ₹21.98, got:", str) - t.Fail() - } - - if cur1.Float64() != 21.98 { - t.Log("Expected 21.98, got:", cur1.Float64()) - t.Fail() - } + asserter.Equal("₹21.98", cur1.String()) } func TestAdd2(t *testing.T) { + requirer := require.New(t) + asserter := assert.New(t) + cur1, err := New(10, 99, "INR", "₹", "paise", 100) - if err != nil { - t.Log(err) - t.Fail() - return - } + requirer.NoError(err) cur2, err := New(-10, 99, "INR", "₹", "paise", 100) - if err != nil { - t.Log(err) - t.Fail() - return - } + requirer.NoError(err) cur1.Add(*cur2) - if cur1.Main != 0 { - t.Log("Expected 0, got:", cur1.Main) - t.Fail() - } - - if cur1.Fractional != 0 { - t.Log("Expected 0, got:", cur1.Fractional) - t.Fail() - } + asserter.Equal(0, cur1.Main) + asserter.Equal(0, cur1.Fractional) + asserter.Equal(0.00, cur1.Float64()) cur1.PrefixSymbol = true - str := cur1.String() - if str != "₹0.00" { - t.Log("Expected ₹0.00, got:", str) - t.Fail() - } - - if cur1.Float64() != 0.00 { - t.Log("Expected 0.00, got:", cur1.Float64()) - t.Fail() - } + asserter.Equal("₹0.00", cur1.String()) } func TestAdd3(t *testing.T) { + requirer := require.New(t) + asserter := assert.New(t) + cur1, err := New(-10, 25, "INR", "₹", "paise", 100) - if err != nil { - t.Log(err) - t.Fail() - return - } + requirer.NoError(err) cur2, err := New(-10, 25, "INR", "₹", "paise", 100) - if err != nil { - t.Log(err) - t.Fail() - return - } + requirer.NoError(err) cur1.Add(*cur2) - if cur1.Main != -20 { - t.Log("Expected -20, got:", cur1.Main) - t.Fail() - } - if cur1.Fractional != 50 { - t.Log("Expected 50, got:", cur1.Fractional) - t.Fail() - } + asserter.Equal(-20, cur1.Main) + asserter.Equal(50, cur1.Fractional) + asserter.Equal(-20.50, cur1.Float64()) cur1.PrefixSymbol = true - str := cur1.String() - if str != "-₹20.50" { - t.Log("Expected -₹20.50, got:", str) - t.Fail() - } - - if cur1.Float64() != -20.50 { - t.Log("Expected -20.50, got:", cur1.Float64()) - t.Fail() - } + asserter.Equal("-₹20.50", cur1.String()) } func TestAddInt(t *testing.T) { + requirer := require.New(t) + asserter := assert.New(t) + cur, err := New(10, 99, "INR", "₹", "paise", 100) - if err != nil { - t.Log(err) - t.Fail() - return - } + requirer.NoError(err) cur.AddInt(10, 10) - - if cur.Main != 21 { - t.Log("Expected:", 21, "got:", cur.Main) - t.Fail() - } - - if cur.Fractional != 9 { - t.Log("Expected:", 9, "got:", cur.Fractional) - t.Fail() - } + asserter.Equal(21, cur.Main) + asserter.Equal(9, cur.Fractional) + asserter.Equal(21.09, cur.Float64()) cur.PrefixSymbol = true - str := cur.String() - if str != "₹21.09" { - t.Log("Expected:", "₹21.09", "got:", str) - t.Fail() - } - - if cur.Float64() != 21.09 { - t.Log("Expected:", 21.09, "got:", cur.Float64()) - t.Fail() - } + asserter.Equal("₹21.09", cur.String()) } func TestSubtract(t *testing.T) {