git/lancet
1
0
Fork 0
mirror of https://github.com/duke-git/lancet.git synced 2026-02-15 02:02:27 +08:00
Code Issues Projects Releases Wiki Activity

refactor: rewrite all unit test functions with assert

Browse Source
This commit is contained in:
dudaodong
2022-01-09 15:34:17 +08:00
parent 9da7115169
commit d3525dfe8f
1 changed files with 86 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

286
validator/validator_test.go
View File

@@ -7,277 +7,163 @@ import (
) )
func TestIsNumberStr(t *testing.T) { func TestIsNumberStr(t *testing.T) {
isNumberStr(t, "3.", true) assert := internal.NewAssert(t, "TestIsNumberStr")
isNumberStr(t, "+3.", true)
isNumberStr(t, "-3.", true)
isNumberStr(t, "+3e2", true)
isNumberStr(t, "abc", false)
}
func isNumberStr(t *testing.T, source string, expected bool) { assert.Equal(true, IsNumberStr("3."))
res := IsNumberStr(source) assert.Equal(true, IsNumberStr("+3."))
if res != expected { assert.Equal(true, IsNumberStr("-3."))
internal.LogFailedTestInfo(t, "IsNumberStr", source, expected, res) assert.Equal(true, IsNumberStr("+3e2"))
t.FailNow() assert.Equal(false, IsNumberStr("abc"))
}
} }
func TestIsFloatStr(t *testing.T) { func TestIsFloatStr(t *testing.T) {
isFloatStr(t, "3.", true) assert := internal.NewAssert(t, "TestIsFloatStr")
isFloatStr(t, "+3.", true)
isFloatStr(t, "-3.", true)
isFloatStr(t, "12", true)
isFloatStr(t, "abc", false)
}
func isFloatStr(t *testing.T, source string, expected bool) { assert.Equal(true, IsFloatStr("3."))
res := IsFloatStr(source) assert.Equal(true, IsFloatStr("+3."))
if res != expected { assert.Equal(true, IsFloatStr("-3."))
internal.LogFailedTestInfo(t, "IsFloatStr", source, expected, res) assert.Equal(true, IsFloatStr("12"))
t.FailNow() assert.Equal(false, IsFloatStr("abc"))
}
} }
func TestIsIntStr(t *testing.T) { func TestIsIntStr(t *testing.T) {
isIntStr(t, "+3", true) assert := internal.NewAssert(t, "TestIsIntStr")
isIntStr(t, "-3", true)
isIntStr(t, "3.", false)
isIntStr(t, "abc", false)
}
func isIntStr(t *testing.T, source string, expected bool) { assert.Equal(true, IsIntStr("+3"))
res := IsIntStr(source) assert.Equal(true, IsIntStr("-3"))
if res != expected { assert.Equal(false, IsIntStr("3."))
internal.LogFailedTestInfo(t, "IsIntStr", source, expected, res) assert.Equal(false, IsIntStr("abc"))
t.FailNow()
}
} }
func TestIsIp(t *testing.T) { func TestIsIp(t *testing.T) {
isIp(t, "127.0.0.1", true) assert := internal.NewAssert(t, "TestIsIntStr")
isIp(t, "::0:0:0:0:0:0:1", true)
isIp(t, "120.0.0", false)
isIp(t, "abc", false)
}
func isIp(t *testing.T, source string, expected bool) { assert.Equal(true, IsIp("127.0.0.1"))
res := IsIp(source) assert.Equal(true, IsIp("::0:0:0:0:0:0:1"))
if res != expected { assert.Equal(false, IsIp("127.0.0"))
internal.LogFailedTestInfo(t, "IsIp", source, expected, res) assert.Equal(false, IsIp("127"))
t.FailNow()
}
} }
func TestIsIpV4(t *testing.T) { func TestIsIpV4(t *testing.T) {
isIpV4(t, "127.0.0.1", true) assert := internal.NewAssert(t, "TestIsIpV4")
isIpV4(t, "::0:0:0:0:0:0:1", false)
}
func isIpV4(t *testing.T, source string, expected bool) { assert.Equal(true, IsIpV4("127.0.0.1"))
res := IsIpV4(source) assert.Equal(false, IsIpV4("::0:0:0:0:0:0:1"))
if res != expected {
internal.LogFailedTestInfo(t, "IsIpV4", source, expected, res)
t.FailNow()
}
} }
func TestIsIpV6(t *testing.T) { func TestIsIpV6(t *testing.T) {
isIpV6(t, "127.0.0.1", false) assert := internal.NewAssert(t, "TestIsIpV6")
isIpV6(t, "::0:0:0:0:0:0:1", true)
}
func isIpV6(t *testing.T, source string, expected bool) { assert.Equal(false, IsIpV6("127.0.0.1"))
res := IsIpV6(source) assert.Equal(true, IsIpV6("::0:0:0:0:0:0:1"))
if res != expected {
internal.LogFailedTestInfo(t, "IsIpV6", source, expected, res)
t.FailNow()
}
} }
func TestIsDns(t *testing.T) { func TestIsDns(t *testing.T) {
isDns(t, "abc.com", true) assert := internal.NewAssert(t, "TestIsDns")
isDns(t, "a.b.com", false)
}
func isDns(t *testing.T, source string, expected bool) { assert.Equal(true, IsDns("abc.com"))
res := IsDns(source) assert.Equal(false, IsDns("a.b.com"))
if res != expected {
internal.LogFailedTestInfo(t, "IsDns", source, expected, res)
t.FailNow()
}
} }
func TestIsEmail(t *testing.T) { func TestIsEmail(t *testing.T) {
isEmail(t, "abc@xyz.com", true) assert := internal.NewAssert(t, "TestIsEmail")
isEmail(t, "a.b@@com", false)
}
func isEmail(t *testing.T, source string, expected bool) { assert.Equal(true, IsEmail("abc@xyz.com"))
res := IsEmail(source) assert.Equal(false, IsEmail("a.b@@com"))
if res != expected {
internal.LogFailedTestInfo(t, "IsEmail", source, expected, res)
t.FailNow()
}
} }
func TestContainChinese(t *testing.T) { func TestContainChinese(t *testing.T) {
containChinese(t, "你好", true) assert := internal.NewAssert(t, "TestContainChinese")
containChinese(t, "hello", false)
containChinese(t, "hello你好", true)
}
func containChinese(t *testing.T, source string, expected bool) { assert.Equal(true, ContainChinese("你好"))
res := ContainChinese(source) assert.Equal(true, ContainChinese("你好hello"))
if res != expected { assert.Equal(false, ContainChinese("hello"))
internal.LogFailedTestInfo(t, "IsContainChineseChar", source, expected, res)
t.FailNow()
}
} }
func TestIsChineseMobile(t *testing.T) { func TestIsChineseMobile(t *testing.T) {
isChineseMobile(t, "13263527980", true) assert := internal.NewAssert(t, "TestIsChineseMobile")
isChineseMobile(t, "434324324", false)
}
func isChineseMobile(t *testing.T, source string, expected bool) { assert.Equal(true, IsChineseMobile("13263527980"))
res := IsChineseMobile(source) assert.Equal(false, IsChineseMobile("434324324"))
if res != expected {
internal.LogFailedTestInfo(t, "IsChineseMobile", source, expected, res)
t.FailNow()
}
} }
func TestIsChinesePhone(t *testing.T) { func TestIsChinesePhone(t *testing.T) {
isChinesePhone(t, "010-32116675", true) assert := internal.NewAssert(t, "TestIsChinesePhone")
isChinesePhone(t, "0464-8756213", true)
isChinesePhone(t, "123-87562", false) assert.Equal(true, IsChinesePhone("010-32116675"))
} assert.Equal(true, IsChinesePhone("0464-8756213"))
assert.Equal(false, IsChinesePhone("123-87562"))
func isChinesePhone(t *testing.T, source string, expected bool) {
res := IsChinesePhone(source)
if res != expected {
internal.LogFailedTestInfo(t, "IsChinesePhone", source, expected, res)
t.FailNow()
}
} }
func TestIsChineseIdNum(t *testing.T) { func TestIsChineseIdNum(t *testing.T) {
isChineseIdNum(t, "210911192105130715", true) assert := internal.NewAssert(t, "TestIsChineseIdNum")
isChineseIdNum(t, "21091119210513071X", true)
isChineseIdNum(t, "21091119210513071x", true)
isChineseIdNum(t, "123456", false)
}
func isChineseIdNum(t *testing.T, source string, expected bool) { assert.Equal(true, IsChineseIdNum("210911192105130715"))
res := IsChineseIdNum(source) assert.Equal(true, IsChineseIdNum("21091119210513071X"))
if res != expected { assert.Equal(true, IsChineseIdNum("21091119210513071x"))
internal.LogFailedTestInfo(t, "IsChineseIdNum", source, expected, res) assert.Equal(false, IsChineseIdNum("123456"))
t.FailNow()
}
} }
func TestIsCreditCard(t *testing.T) { func TestIsCreditCard(t *testing.T) {
isCreditCard(t, "4111111111111111", true) assert := internal.NewAssert(t, "TestIsCreditCard")
isCreditCard(t, "123456", false)
}
func isCreditCard(t *testing.T, source string, expected bool) { assert.Equal(true, IsCreditCard("4111111111111111"))
res := IsCreditCard(source) assert.Equal(false, IsCreditCard("123456"))
if res != expected {
internal.LogFailedTestInfo(t, "IsCreditCard", source, expected, res)
t.FailNow()
}
} }
func TestIsBase64(t *testing.T) { func TestIsBase64(t *testing.T) {
isBase64(t, "aGVsbG8=", true) assert := internal.NewAssert(t, "TestIsBase64")
isBase64(t, "123456", false)
}
func isBase64(t *testing.T, source string, expected bool) { assert.Equal(true, IsBase64("aGVsbG8="))
res := IsBase64(source) assert.Equal(false, IsBase64("123456"))
if res != expected {
internal.LogFailedTestInfo(t, "IsBase64", source, expected, res)
t.FailNow()
}
} }
func TestIsEmptyString(t *testing.T) { func TestIsEmptyString(t *testing.T) {
isEmptyString(t, "111", false) assert := internal.NewAssert(t, "TestIsEmptyString")
isEmptyString(t, " ", false)
isEmptyString(t, "\t", false)
isEmptyString(t, "", true)
}
func isEmptyString(t *testing.T, source string, expected bool) { assert.Equal(true, IsEmptyString(""))
res := IsEmptyString(source) assert.Equal(false, IsEmptyString("111"))
if res != expected { assert.Equal(false, IsEmptyString(" "))
internal.LogFailedTestInfo(t, "IsEmptyString", source, expected, res) assert.Equal(false, IsEmptyString("\t"))
t.FailNow()
}
} }
func TestIsAlpha(t *testing.T) { func TestIsAlpha(t *testing.T) {
isAlpha(t, "abc", true) assert := internal.NewAssert(t, "TestIsAlpha")
isAlpha(t, "111", false)
isAlpha(t, " ", false)
isAlpha(t, "\t", false)
isAlpha(t, "", false)
}
func isAlpha(t *testing.T, source string, expected bool) { assert.Equal(true, IsAlpha("abc"))
res := IsAlpha(source) assert.Equal(false, IsAlpha("111"))
if res != expected { assert.Equal(false, IsAlpha(" "))
internal.LogFailedTestInfo(t, "IsAlpha", source, expected, res) assert.Equal(false, IsAlpha("\t"))
t.FailNow() assert.Equal(false, IsAlpha(""))
}
} }
func TestIsRegexMatch(t *testing.T) { func TestIsRegexMatch(t *testing.T) {
isRegexMatch(t, "abc", `^[a-zA-Z]+$`, true) assert := internal.NewAssert(t, "TestIsRegexMatch")
isRegexMatch(t, "1ab", `^[a-zA-Z]+$`, false)
isRegexMatch(t, "111", `^[a-zA-Z]+$`, false)
isRegexMatch(t, "", `^[a-zA-Z]+$`, false)
}
func isRegexMatch(t *testing.T, source, regex string, expected bool) { assert.Equal(true, IsRegexMatch("abc", `^[a-zA-Z]+$`))
res := IsRegexMatch(source, regex) assert.Equal(false, IsRegexMatch("1ab", `^[a-zA-Z]+$`))
if res != expected { assert.Equal(false, IsRegexMatch("", `^[a-zA-Z]+$`))
internal.LogFailedTestInfo(t, "IsRegexMatch", source, expected, res)
t.FailNow()
}
} }
func TestIsStrongPassword(t *testing.T) { func TestIsStrongPassword(t *testing.T) {
isStrongPassword(t, "abc", 3, false) assert := internal.NewAssert(t, "TestIsStrongPassword")
isStrongPassword(t, "abc123", 6, false)
isStrongPassword(t, "abcABC", 6, false)
isStrongPassword(t, "abc123@#$", 9, false)
isStrongPassword(t, "abcABC123@#$", 16, false)
isStrongPassword(t, "abcABC123@#$", 12, true)
isStrongPassword(t, "abcABC123@#$", 10, true)
}
func isStrongPassword(t *testing.T, source string, length int, expected bool) { assert.Equal(false, IsStrongPassword("abc", 3))
res := IsStrongPassword(source, length) assert.Equal(false, IsStrongPassword("abc123", 6))
if res != expected { assert.Equal(false, IsStrongPassword("abcABC", 6))
internal.LogFailedTestInfo(t, "IsStrongPassword", source, expected, res) assert.Equal(false, IsStrongPassword("abc123@#$", 9))
t.FailNow() assert.Equal(false, IsStrongPassword("abcABC123@#$", 16))
} assert.Equal(true, IsStrongPassword("abcABC123@#$", 12))
assert.Equal(true, IsStrongPassword("abcABC123@#$", 10))
} }
func TestIsWeakPassword(t *testing.T) { func TestIsWeakPassword(t *testing.T) {
isWeakPassword(t, "abc", true) assert := internal.NewAssert(t, "TestIsWeakPassword")
isWeakPassword(t, "123", true)
isWeakPassword(t, "abc123", true)
isWeakPassword(t, "abcABC123", true)
isWeakPassword(t, "abc123@#$", false)
}
func isWeakPassword(t *testing.T, source string, expected bool) { assert.Equal(true, IsWeakPassword("abc"))
res := IsWeakPassword(source) assert.Equal(true, IsWeakPassword("123"))
if res != expected { assert.Equal(true, IsWeakPassword("abc123"))
internal.LogFailedTestInfo(t, "IsWeakPassword", source, expected, res) assert.Equal(true, IsWeakPassword("abcABC123"))
t.FailNow() assert.Equal(false, IsWeakPassword("abc123@#$"))
}
} }