From 53354ba4f915019d97f8b7264048598921ff6c4d Mon Sep 17 00:00:00 2001 From: Frederic BIDON Date: Tue, 16 Oct 2018 19:52:06 +0200 Subject: [PATCH] Linting * Comply with golangci-lint linting rules * Refactored unit test to reduce code duplication * Augmented test coverage Signed-off-by: Frederic BIDON --- .golangci.yml | 5 +- date_test.go | 2 +- default.go | 10 +- default_test.go | 721 ++++++++++++------------------------------------ duration.go | 2 +- format_test.go | 20 +- 6 files changed, 193 insertions(+), 567 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index 4029779..a90f7e3 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -4,16 +4,17 @@ linters-settings: golint: min-confidence: 0 gocyclo: - min-complexity: 25 + min-complexity: 30 maligned: suggest-new: true dupl: threshold: 100 goconst: min-len: 2 - min-occurrences: 2 + min-occurrences: 4 linters: enable-all: true disable: - maligned + - lll diff --git a/date_test.go b/date_test.go index 4a7f215..40f5174 100644 --- a/date_test.go +++ b/date_test.go @@ -77,7 +77,7 @@ func TestDate_Scan(t *testing.T) { values := []interface{}{str, []byte(str), ref} for _, value := range values { result := Date{} - (&result).Scan(value) + _ = (&result).Scan(value) assert.Equal(t, date, result, "value: %#v", value) } diff --git a/default.go b/default.go index 13235ec..639dfad 100644 --- a/default.go +++ b/default.go @@ -112,7 +112,7 @@ func IsUUID5(str string) bool { return rxUUID5.MatchString(str) } -// Validates an email address. +// IsEmail validates an email address. func IsEmail(str string) bool { addr, e := mail.ParseAddress(str) return e == nil && addr.Address != "" @@ -197,13 +197,7 @@ func init() { Default.Add("password", &pw, func(_ string) bool { return true }) } -/* unused: -var formatCheckers = map[string]Validator{ - "byte": govalidator.IsBase64, -} -*/ - -// Base64 represents a base64 encoded string +// Base64 represents a base64 encoded string, using URLEncoding alphabet // // swagger:strfmt byte type Base64 []byte diff --git a/default_test.go b/default_test.go index 0dc940a..3b3695e 100644 --- a/default_test.go +++ b/default_test.go @@ -15,6 +15,13 @@ package strfmt import ( + "database/sql" + "database/sql/driver" + "encoding" + "encoding/json" + "fmt" + "reflect" + "strings" "testing" "github.com/globalsign/mgo/bson" @@ -22,87 +29,15 @@ import ( "github.com/stretchr/testify/assert" ) -func testValid(t *testing.T, name, value string) { - ok := Default.Validates(name, value) - if !ok { - t.Errorf("expected %s of type %s to be valid", value, name) - } -} - -func testInvalid(t *testing.T, name, value string) { - ok := Default.Validates(name, value) - if ok { - t.Errorf("expected %s of type %s to be invalid", value, name) - } -} - func TestFormatURI(t *testing.T) { uri := URI("http://somewhere.com") - str := string("http://somewhereelse.com") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := uri.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, URI("http://somewhereelse.com"), string(b)) - - b, err = uri.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("http://somewhereelse.com"), b) - - err = uri.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, URI("http://somewhereelse.com"), string(b)) - - b, err = uri.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&uri) - assert.NoError(t, err) - - var uriCopy URI - err = bson.Unmarshal(bsonData, &uriCopy) - assert.NoError(t, err) - assert.Equal(t, uri, uriCopy) - - testValid(t, "uri", str) - testInvalid(t, "uri", "somewhere.com") + str := "http://somewhereelse.com" + testStringFormat(t, &uri, "uri", str, []string{}, []string{"somewhere.com"}) } func TestFormatEmail(t *testing.T) { email := Email("somebody@somewhere.com") str := string("somebodyelse@somewhere.com") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := email.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, Email("somebodyelse@somewhere.com"), string(b)) - - b, err = email.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("somebodyelse@somewhere.com"), b) - - err = email.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, Email(str), string(b)) - - b, err = email.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&email) - assert.NoError(t, err) - - var emailCopy Email - err = bson.Unmarshal(bsonData, &emailCopy) - assert.NoError(t, err) - assert.Equal(t, email, emailCopy) - - testValid(t, "email", str) - testInvalid(t, "email", "somebody@somewhere@com") - validEmails := []string{ "blah@gmail.com", "test@d.verylongtoplevel", @@ -124,184 +59,52 @@ func TestFormatEmail(t *testing.T) { "api@piston.ninja", } - for _, eml := range validEmails { - testValid(t, "email", eml) - } + testStringFormat(t, &email, "email", str, validEmails, []string{"somebody@somewhere@com"}) } func TestFormatHostname(t *testing.T) { hostname := Hostname("somewhere.com") str := string("somewhere.com") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := hostname.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, Hostname("somewhere.com"), string(b)) - - b, err = hostname.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("somewhere.com"), b) - - err = hostname.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, Hostname(str), string(b)) - - b, err = hostname.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&hostname) - assert.NoError(t, err) - - var hostnameCopy Hostname - err = bson.Unmarshal(bsonData, &hostnameCopy) - assert.NoError(t, err) - assert.Equal(t, hostname, hostnameCopy) - - testValid(t, "hostname", str) - testInvalid(t, "hostname", "somewhere.com!") + veryLongStr := strings.Repeat("a", 256) + longStr := strings.Repeat("a", 64) + longAddrSegment := strings.Join([]string{"x", "y", longStr}, ".") + invalidHostnames := []string{ + "somewhere.com!", + veryLongStr, + longAddrSegment, + } + testStringFormat(t, &hostname, "hostname", str, []string{}, invalidHostnames) } func TestFormatIPv4(t *testing.T) { ipv4 := IPv4("192.168.254.1") str := string("192.168.254.2") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := ipv4.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, IPv4("192.168.254.2"), string(b)) - - b, err = ipv4.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("192.168.254.2"), b) - - err = ipv4.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, IPv4(str), string(b)) - - b, err = ipv4.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&ipv4) - assert.NoError(t, err) - - var ipv4Copy IPv4 - err = bson.Unmarshal(bsonData, &ipv4Copy) - assert.NoError(t, err) - assert.Equal(t, ipv4, ipv4Copy) - - testValid(t, "ipv4", str) - testInvalid(t, "ipv4", "192.168.254.2.2") + testStringFormat(t, &ipv4, "ipv4", str, []string{}, []string{"198.168.254.2.2"}) } func TestFormatIPv6(t *testing.T) { ipv6 := IPv6("::1") str := string("::2") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := ipv6.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, IPv6("::2"), string(b)) - - b, err = ipv6.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("::2"), b) - - err = ipv6.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, IPv6(str), string(b)) - - b, err = ipv6.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&ipv6) - assert.NoError(t, err) - - var ipv6Copy IPv6 - err = bson.Unmarshal(bsonData, &ipv6Copy) - assert.NoError(t, err) - assert.Equal(t, ipv6, ipv6Copy) - - testValid(t, "ipv6", str) - testInvalid(t, "ipv6", "127.0.0.1") + // TODO: test ipv6 zones + testStringFormat(t, &ipv6, "ipv6", str, []string{}, []string{"127.0.0.1"}) } func TestFormatMAC(t *testing.T) { mac := MAC("01:02:03:04:05:06") str := string("06:05:04:03:02:01") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := mac.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, MAC("06:05:04:03:02:01"), string(b)) - - b, err = mac.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("06:05:04:03:02:01"), b) - - err = mac.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, MAC(str), string(b)) - - b, err = mac.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&mac) - assert.NoError(t, err) - - var macCopy MAC - err = bson.Unmarshal(bsonData, &macCopy) - assert.NoError(t, err) - assert.Equal(t, mac, macCopy) - - testValid(t, "mac", str) - testInvalid(t, "mac", "01:02:03:04:05") + testStringFormat(t, &mac, "mac", str, []string{}, []string{"01:02:03:04:05"}) } func TestFormatUUID3(t *testing.T) { first3 := uuid.NewMD5(uuid.NameSpace_URL, []byte("somewhere.com")) other3 := uuid.NewMD5(uuid.NameSpace_URL, []byte("somewhereelse.com")) uuid3 := UUID3(first3.String()) - str := string(other3.String()) - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := uuid3.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, UUID3(other3.String()), string(b)) - - b, err = uuid3.MarshalText() - assert.NoError(t, err) - assert.EqualValues(t, []byte(other3.String()), b) - - err = uuid3.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, UUID3(str), string(b)) - - b, err = uuid3.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&uuid3) - assert.NoError(t, err) - - var uuid3Copy UUID3 - err = bson.Unmarshal(bsonData, &uuid3Copy) - assert.NoError(t, err) - assert.Equal(t, uuid3, uuid3Copy) - - testValid(t, "uuid3", str) - testInvalid(t, "uuid3", "not-a-uuid") + str := other3.String() + testStringFormat(t, &uuid3, "uuid3", str, []string{}, []string{"not-a-uuid"}) + // special case for zero UUID var uuidZero UUID3 - err = uuidZero.UnmarshalJSON([]byte(jsonNull)) + err := uuidZero.UnmarshalJSON([]byte(jsonNull)) assert.NoError(t, err) assert.EqualValues(t, UUID3(""), uuidZero) } @@ -310,39 +113,12 @@ func TestFormatUUID4(t *testing.T) { first4 := uuid.NewRandom() other4 := uuid.NewRandom() uuid4 := UUID4(first4.String()) - str := string(other4.String()) - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := uuid4.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, UUID4(other4.String()), string(b)) - - b, err = uuid4.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte(other4.String()), b) - - err = uuid4.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, UUID4(str), string(b)) - - b, err = uuid4.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&uuid4) - assert.NoError(t, err) - - var uuid4Copy UUID4 - err = bson.Unmarshal(bsonData, &uuid4Copy) - assert.NoError(t, err) - assert.Equal(t, uuid4, uuid4Copy) - - testValid(t, "uuid4", str) - testInvalid(t, "uuid4", "not-a-uuid") + str := other4.String() + testStringFormat(t, &uuid4, "uuid4", str, []string{}, []string{"not-a-uuid"}) + // special case for zero UUID var uuidZero UUID4 - err = uuidZero.UnmarshalJSON([]byte(jsonNull)) + err := uuidZero.UnmarshalJSON([]byte(jsonNull)) assert.NoError(t, err) assert.EqualValues(t, UUID4(""), uuidZero) } @@ -351,39 +127,12 @@ func TestFormatUUID5(t *testing.T) { first5 := uuid.NewSHA1(uuid.NameSpace_URL, []byte("somewhere.com")) other5 := uuid.NewSHA1(uuid.NameSpace_URL, []byte("somewhereelse.com")) uuid5 := UUID5(first5.String()) - str := string(other5.String()) - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := uuid5.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, UUID5(other5.String()), string(b)) - - b, err = uuid5.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte(other5.String()), b) - - err = uuid5.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, UUID5(str), string(b)) - - b, err = uuid5.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&uuid5) - assert.NoError(t, err) - - var uuid5Copy UUID5 - err = bson.Unmarshal(bsonData, &uuid5Copy) - assert.NoError(t, err) - assert.Equal(t, uuid5, uuid5Copy) - - testValid(t, "uuid5", str) - testInvalid(t, "uuid5", "not-a-uuid") + str := other5.String() + testStringFormat(t, &uuid5, "uuid5", str, []string{}, []string{"not-a-uuid"}) + // special case for zero UUID var uuidZero UUID5 - err = uuidZero.UnmarshalJSON([]byte(jsonNull)) + err := uuidZero.UnmarshalJSON([]byte(jsonNull)) assert.NoError(t, err) assert.EqualValues(t, UUID5(""), uuidZero) } @@ -392,39 +141,12 @@ func TestFormatUUID(t *testing.T) { first5 := uuid.NewSHA1(uuid.NameSpace_URL, []byte("somewhere.com")) other5 := uuid.NewSHA1(uuid.NameSpace_URL, []byte("somewhereelse.com")) uuid := UUID(first5.String()) - str := string(other5.String()) - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := uuid.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, UUID(other5.String()), string(b)) - - b, err = uuid.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte(other5.String()), b) - - err = uuid.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, UUID(str), string(b)) - - b, err = uuid.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&uuid) - assert.NoError(t, err) - - var uuidCopy UUID - err = bson.Unmarshal(bsonData, &uuidCopy) - assert.NoError(t, err) - assert.Equal(t, uuid, uuidCopy) - - testValid(t, "uuid", str) - testInvalid(t, "uuid", "not-a-uuid") + str := other5.String() + testStringFormat(t, &uuid, "uuid", str, []string{}, []string{"not-a-uuid"}) + // special case for zero UUID var uuidZero UUID - err = uuidZero.UnmarshalJSON([]byte(jsonNull)) + err := uuidZero.UnmarshalJSON([]byte(jsonNull)) assert.NoError(t, err) assert.EqualValues(t, UUID(""), uuidZero) } @@ -432,305 +154,214 @@ func TestFormatUUID(t *testing.T) { func TestFormatISBN(t *testing.T) { isbn := ISBN("0321751043") str := string("0321751043") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := isbn.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, ISBN("0321751043"), string(b)) - - b, err = isbn.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("0321751043"), b) - - err = isbn.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, ISBN(str), string(b)) - - b, err = isbn.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&isbn) - assert.NoError(t, err) - - var isbnCopy ISBN - err = bson.Unmarshal(bsonData, &isbnCopy) - assert.NoError(t, err) - assert.Equal(t, isbn, isbnCopy) - - testValid(t, "isbn", str) - testInvalid(t, "isbn", "836217463") // bad checksum + testStringFormat(t, &isbn, "isbn", str, []string{}, []string{"836217463"}) // bad checksum } func TestFormatISBN10(t *testing.T) { isbn10 := ISBN10("0321751043") str := string("0321751043") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := isbn10.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, ISBN10("0321751043"), string(b)) - - b, err = isbn10.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("0321751043"), b) - - err = isbn10.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, ISBN10(str), string(b)) - - b, err = isbn10.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&isbn10) - assert.NoError(t, err) - - var isbn10Copy ISBN10 - err = bson.Unmarshal(bsonData, &isbn10Copy) - assert.NoError(t, err) - assert.Equal(t, isbn10, isbn10Copy) - - testValid(t, "isbn10", str) - testInvalid(t, "isbn10", "836217463") // bad checksum + testStringFormat(t, &isbn10, "isbn10", str, []string{}, []string{"836217463"}) // bad checksum } func TestFormatISBN13(t *testing.T) { isbn13 := ISBN13("978-0321751041") str := string("978-0321751041") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := isbn13.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, ISBN13("978-0321751041"), string(b)) - - b, err = isbn13.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("978-0321751041"), b) - - err = isbn13.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, ISBN13(str), string(b)) - - b, err = isbn13.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&isbn13) - assert.NoError(t, err) - - var isbn13Copy ISBN13 - err = bson.Unmarshal(bsonData, &isbn13Copy) - assert.NoError(t, err) - assert.Equal(t, isbn13, isbn13Copy) - - testValid(t, "isbn13", str) - testInvalid(t, "isbn13", "978-0321751042") // bad checksum + testStringFormat(t, &isbn13, "isbn13", str, []string{}, []string{"978-0321751042"}) // bad checksum } func TestFormatHexColor(t *testing.T) { hexColor := HexColor("#FFFFFF") str := string("#000000") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := hexColor.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, HexColor("#000000"), string(b)) - - b, err = hexColor.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("#000000"), b) - - err = hexColor.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, HexColor(str), string(b)) - - b, err = hexColor.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&hexColor) - assert.NoError(t, err) - - var hexColorCopy HexColor - err = bson.Unmarshal(bsonData, &hexColorCopy) - assert.NoError(t, err) - assert.Equal(t, hexColor, hexColorCopy) - - testValid(t, "hexcolor", str) - testInvalid(t, "hexcolor", "#fffffffz") + testStringFormat(t, &hexColor, "hexcolor", str, []string{}, []string{"#fffffffz"}) } func TestFormatRGBColor(t *testing.T) { rgbColor := RGBColor("rgb(255,255,255)") str := string("rgb(0,0,0)") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := rgbColor.UnmarshalText(b) - assert.NoError(t, err) - assert.EqualValues(t, RGBColor("rgb(0,0,0)"), string(b)) - - b, err = rgbColor.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("rgb(0,0,0)"), b) - - err = rgbColor.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, RGBColor(str), string(b)) - - b, err = rgbColor.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&rgbColor) - assert.NoError(t, err) - - var rgbColorCopy RGBColor - err = bson.Unmarshal(bsonData, &rgbColorCopy) - assert.NoError(t, err) - assert.Equal(t, rgbColor, rgbColorCopy) - - testValid(t, "rgbcolor", str) - testInvalid(t, "rgbcolor", "rgb(300,0,0)") + testStringFormat(t, &rgbColor, "rgbcolor", str, []string{}, []string{"rgb(300,0,0)"}) } func TestFormatSSN(t *testing.T) { ssn := SSN("111-11-1111") str := string("999 99 9999") + testStringFormat(t, &ssn, "ssn", str, []string{}, []string{"999 99 999"}) +} + +func TestFormatCreditCard(t *testing.T) { + creditCard := CreditCard("4111-1111-1111-1111") + str := string("4012-8888-8888-1881") + testStringFormat(t, &creditCard, "creditcard", str, []string{}, []string{"9999-9999-9999-999"}) +} + +func TestFormatPassword(t *testing.T) { + password := Password("super secret stuff here") + testStringFormat(t, &password, "password", "super secret!!!", []string{"even more secret"}, []string{}) +} + +func TestFormatBase64(t *testing.T) { + b64 := Base64("ZWxpemFiZXRocG9zZXk=") + str := string("ZWxpemFiZXRocG9zZXk=") b := []byte(str) bj := []byte("\"" + str + "\"") - err := ssn.UnmarshalText(b) + err := b64.UnmarshalText(b) assert.NoError(t, err) - assert.EqualValues(t, SSN("999 99 9999"), string(b)) + assert.EqualValues(t, Base64("ZWxpemFiZXRocG9zZXk="), string(b)) - b, err = ssn.MarshalText() + b, err = b64.MarshalText() assert.NoError(t, err) - assert.Equal(t, []byte("999 99 9999"), b) + assert.Equal(t, []byte("ZWxpemFiZXRocG9zZXk="), b) - err = ssn.UnmarshalJSON(bj) + err = b64.UnmarshalJSON(bj) assert.NoError(t, err) - assert.EqualValues(t, SSN(str), string(b)) + assert.EqualValues(t, Base64(str), string(b)) - b, err = ssn.MarshalJSON() + b, err = b64.MarshalJSON() assert.NoError(t, err) assert.Equal(t, bj, b) - bsonData, err := bson.Marshal(&ssn) - assert.NoError(t, err) - - var ssnCopy SSN - err = bson.Unmarshal(bsonData, &ssnCopy) - assert.NoError(t, err) - assert.Equal(t, ssn, ssnCopy) - - testValid(t, "ssn", str) - testInvalid(t, "ssn", "999 99 999") -} - -func TestFormatCreditCard(t *testing.T) { - creditCard := CreditCard("4111-1111-1111-1111") - str := string("4012-8888-8888-1881") - b := []byte(str) - bj := []byte("\"" + str + "\"") - - err := creditCard.UnmarshalText(b) + bsonData, err := bson.Marshal(&b64) assert.NoError(t, err) - assert.EqualValues(t, CreditCard("4012-8888-8888-1881"), string(b)) - b, err = creditCard.MarshalText() + var b64Copy Base64 + err = bson.Unmarshal(bsonData, &b64Copy) assert.NoError(t, err) - assert.Equal(t, []byte("4012-8888-8888-1881"), b) + assert.Equal(t, b64, b64Copy) - err = creditCard.UnmarshalJSON(bj) - assert.NoError(t, err) - assert.EqualValues(t, CreditCard(str), string(b)) + testValid(t, "byte", str) + testInvalid(t, "byte", "ZWxpemFiZXRocG9zZXk") // missing pad char - b, err = creditCard.MarshalJSON() + // Valuer interface + b64 = Base64("ZWxpemFiZXRocG9zZXk=") + sqlvalue, err := b64.Value() assert.NoError(t, err) - assert.Equal(t, bj, b) - - bsonData, err := bson.Marshal(&creditCard) + sqlvalueAsString, ok := sqlvalue.(string) + if assert.Truef(t, ok, "[%s]Value: expected driver value to be a string", "byte") { + assert.EqualValuesf(t, str, sqlvalueAsString, "[%s]Value: expected %v and %v to be equal", "byte", sqlvalue, str) + } + // Scanner interface + b64 = Base64("") + err = b64.Scan(str) assert.NoError(t, err) + b64AsStr := b64.String() + assert.EqualValues(t, str, b64AsStr) - var creditCardCopy CreditCard - err = bson.Unmarshal(bsonData, &creditCardCopy) + err = b64.Scan([]byte(str)) assert.NoError(t, err) - assert.Equal(t, creditCard, creditCardCopy) + b64AsStr = b64.String() + assert.EqualValues(t, str, b64AsStr) - testValid(t, "creditcard", str) - testInvalid(t, "creditcard", "9999-9999-9999-999") // bad checksum + err = b64.Scan(123) + assert.Error(t, err) } -func TestFormatPassword(t *testing.T) { - password := Password("super secret stuff here") - str := string("even more secret") - b := []byte(str) - bj := []byte("\"" + str + "\"") +type testableFormat interface { + encoding.TextMarshaler + encoding.TextUnmarshaler + json.Marshaler + json.Unmarshaler + bson.Getter + bson.Setter + fmt.Stringer + sql.Scanner + driver.Valuer +} - err := password.UnmarshalText(b) +func testStringFormat(t *testing.T, what testableFormat, format, with string, validSamples, invalidSamples []string) { + // text encoding interface + b := []byte(with) + err := what.UnmarshalText(b) assert.NoError(t, err) - assert.EqualValues(t, Password("even more secret"), string(b)) - b, err = password.MarshalText() - assert.NoError(t, err) - assert.Equal(t, []byte("even more secret"), b) + val := reflect.Indirect(reflect.ValueOf(what)) + strVal := val.String() + assert.Equalf(t, with, strVal, "[%s]UnmarshalText: expected %v and %v to be value equal", format, strVal, with) - err = password.UnmarshalJSON(bj) + b, err = what.MarshalText() assert.NoError(t, err) - assert.EqualValues(t, Password(str), string(b)) + assert.Equalf(t, []byte(with), b, "[%s]MarshalText: expected %v and %v to be value equal as []byte", format, string(b), with) - b, err = password.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) + // Stringer + strVal = what.String() + assert.Equalf(t, []byte(with), b, "[%s]String: expected %v and %v to be equal", strVal, with) - bsonData, err := bson.Marshal(&password) + // JSON encoding interface + bj := []byte("\"" + with + "\"") + err = what.UnmarshalJSON(bj) assert.NoError(t, err) + val = reflect.Indirect(reflect.ValueOf(what)) + strVal = val.String() + assert.EqualValuesf(t, with, strVal, "[%s]UnmarshalJSON: expected %v and %v to be value equal", format, strVal, with) - var passwordCopy Password - err = bson.Unmarshal(bsonData, &passwordCopy) + b, err = what.MarshalJSON() assert.NoError(t, err) - assert.Equal(t, password, passwordCopy) + assert.Equalf(t, bj, b, "[%s]MarshalJSON: expected %v and %v to be value equal as []byte", format, string(b), with) - // everything is valid - testValid(t, "password", str) -} + // bson encoding interface + bsonData, err := bson.Marshal(&what) + assert.NoError(t, err) -func TestFormatBase64(t *testing.T) { - b64 := Base64("ZWxpemFiZXRocG9zZXk=") - str := string("ZWxpemFiZXRocG9zZXk=") - b := []byte(str) - bj := []byte("\"" + str + "\"") + resetValue(t, format, what) - err := b64.UnmarshalText(b) + err = bson.Unmarshal(bsonData, what) assert.NoError(t, err) - assert.EqualValues(t, Base64("ZWxpemFiZXRocG9zZXk="), string(b)) + val = reflect.Indirect(reflect.ValueOf(what)) + strVal = val.String() + assert.EqualValuesf(t, with, strVal, "[%s]bson.Unmarshal: expected %v and %v to be equal (reset value) ", format, what, with) - b, err = b64.MarshalText() + // Scanner interface + resetValue(t, format, what) + err = what.Scan(with) assert.NoError(t, err) - assert.Equal(t, []byte("ZWxpemFiZXRocG9zZXk="), b) + val = reflect.Indirect(reflect.ValueOf(what)) + strVal = val.String() + assert.EqualValuesf(t, with, strVal, "[%s]Scan: expected %v and %v to be value equal", format, strVal, with) - err = b64.UnmarshalJSON(bj) + err = what.Scan([]byte(with)) assert.NoError(t, err) - assert.EqualValues(t, Base64(str), string(b)) + val = reflect.Indirect(reflect.ValueOf(what)) + strVal = val.String() + assert.EqualValuesf(t, with, strVal, "[%s]Scan: expected %v and %v to be value equal", format, strVal, with) - b, err = b64.MarshalJSON() - assert.NoError(t, err) - assert.Equal(t, bj, b) + err = what.Scan(123) + assert.Error(t, err) - bsonData, err := bson.Marshal(&b64) + // Valuer interface + sqlvalue, err := what.Value() assert.NoError(t, err) + sqlvalueAsString, ok := sqlvalue.(string) + if assert.Truef(t, ok, "[%s]Value: expected driver value to be a string", format) { + assert.EqualValuesf(t, with, sqlvalueAsString, "[%s]Value: expected %v and %v to be equal", format, sqlvalue, with) + } - var b64Copy Base64 - err = bson.Unmarshal(bsonData, &b64Copy) + // validation with Registry + for _, valid := range append(validSamples, with) { + testValid(t, format, valid) + } + + for _, invalid := range invalidSamples { + testInvalid(t, format, invalid) + } +} + +func resetValue(t *testing.T, format string, what encoding.TextUnmarshaler) { + err := what.UnmarshalText([]byte("reset value")) assert.NoError(t, err) - assert.Equal(t, b64, b64Copy) + val := reflect.Indirect(reflect.ValueOf(what)) + strVal := val.String() + assert.Equalf(t, "reset value", strVal, "[%s]UnmarshalText: expected %v and %v to be equal (reset value) ", format, strVal, "reset value") +} - testValid(t, "byte", str) - testInvalid(t, "byte", "ZWxpemFiZXRocG9zZXk") // missing pad char +func testValid(t *testing.T, name, value string) { + ok := Default.Validates(name, value) + if !ok { + t.Errorf("expected %q of type %s to be valid", value, name) + } +} + +func testInvalid(t *testing.T, name, value string) { + ok := Default.Validates(name, value) + if ok { + t.Errorf("expected %q of type %s to be invalid", value, name) + } } diff --git a/duration.go b/duration.go index 28df8e4..61fd6d3 100644 --- a/duration.go +++ b/duration.go @@ -121,7 +121,7 @@ func ParseDuration(cand string) (time.Duration, error) { if ok { return dur, nil } - return 0, fmt.Errorf("Unable to parse %s as duration", cand) + return 0, fmt.Errorf("unable to parse %s as duration", cand) } // Scan reads a Duration value from database driver type. diff --git a/format_test.go b/format_test.go index 9c9fa3f..096eaf8 100644 --- a/format_test.go +++ b/format_test.go @@ -131,12 +131,12 @@ type testStruct struct { D Date `json:"d,omitempty"` DT DateTime `json:"dt,omitempty"` Dur Duration `json:"dur,omitempty"` - Uri URI `json:"uri,omitempty"` + URI URI `json:"uri,omitempty"` Eml Email `json:"eml,omitempty"` - Uuid UUID `json:"uuid,omitempty"` - Uuid3 UUID3 `json:"uuid3,omitempty"` - Uuid4 UUID4 `json:"uuid4,omitempty"` - Uuid5 UUID5 `json:"uuid5,omitempty"` + UUID UUID `json:"uuid,omitempty"` + UUID3 UUID3 `json:"uuid3,omitempty"` + UUID4 UUID4 `json:"uuid4,omitempty"` + UUID5 UUID5 `json:"uuid5,omitempty"` Hn Hostname `json:"hn,omitempty"` Ipv4 IPv4 `json:"ipv4,omitempty"` Ipv6 IPv6 `json:"ipv6,omitempty"` @@ -187,12 +187,12 @@ func TestDecodeHook(t *testing.T) { D: Date(date), DT: dt, Dur: Duration(dur), - Uri: URI("http://www.dummy.com"), + URI: URI("http://www.dummy.com"), Eml: Email("dummy@dummy.com"), - Uuid: UUID("a8098c1a-f86e-11da-bd1a-00112444be1e"), - Uuid3: UUID3("bcd02e22-68f0-3046-a512-327cca9def8f"), - Uuid4: UUID4("025b0d74-00a2-4048-bf57-227c5111bb34"), - Uuid5: UUID5("886313e1-3b8a-5372-9b90-0c9aee199e5d"), + UUID: UUID("a8098c1a-f86e-11da-bd1a-00112444be1e"), + UUID3: UUID3("bcd02e22-68f0-3046-a512-327cca9def8f"), + UUID4: UUID4("025b0d74-00a2-4048-bf57-227c5111bb34"), + UUID5: UUID5("886313e1-3b8a-5372-9b90-0c9aee199e5d"), Hn: Hostname("somewhere.com"), Ipv4: IPv4("192.168.254.1"), Ipv6: IPv6("::1"),