Платформа ЦРНП "Мирокод" для разработки проектов
https://git.mirocod.ru
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
419 lines
12 KiB
419 lines
12 KiB
package base |
|
|
|
import ( |
|
"net/url" |
|
"os" |
|
"testing" |
|
"time" |
|
|
|
"code.gitea.io/gitea/modules/setting" |
|
|
|
"github.com/Unknwon/i18n" |
|
macaroni18n "github.com/go-macaron/i18n" |
|
"github.com/stretchr/testify/assert" |
|
) |
|
|
|
var BaseDate time.Time |
|
|
|
// time durations |
|
const ( |
|
DayDur = 24 * time.Hour |
|
WeekDur = 7 * DayDur |
|
MonthDur = 30 * DayDur |
|
YearDur = 12 * MonthDur |
|
) |
|
|
|
func TestMain(m *testing.M) { |
|
// setup |
|
macaroni18n.I18n(macaroni18n.Options{ |
|
Directory: "../../options/locale/", |
|
DefaultLang: "en-US", |
|
Langs: []string{"en-US"}, |
|
Names: []string{"english"}, |
|
}) |
|
BaseDate = time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC) |
|
|
|
// run the tests |
|
retVal := m.Run() |
|
|
|
os.Exit(retVal) |
|
} |
|
|
|
func TestEncodeMD5(t *testing.T) { |
|
assert.Equal(t, |
|
"3858f62230ac3c915f300c664312c63f", |
|
EncodeMD5("foobar"), |
|
) |
|
} |
|
|
|
func TestEncodeSha1(t *testing.T) { |
|
assert.Equal(t, |
|
"8843d7f92416211de9ebb963ff4ce28125932878", |
|
EncodeSha1("foobar"), |
|
) |
|
} |
|
|
|
func TestEncodeSha256(t *testing.T) { |
|
assert.Equal(t, |
|
"c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2", |
|
EncodeSha256("foobar"), |
|
) |
|
} |
|
|
|
func TestShortSha(t *testing.T) { |
|
assert.Equal(t, "veryverylo", ShortSha("veryverylong")) |
|
} |
|
|
|
func TestDetectEncoding(t *testing.T) { |
|
testSuccess := func(b []byte, expected string) { |
|
encoding, err := DetectEncoding(b) |
|
assert.NoError(t, err) |
|
assert.Equal(t, expected, encoding) |
|
} |
|
// utf-8 |
|
b := []byte("just some ascii") |
|
testSuccess(b, "UTF-8") |
|
|
|
// utf-8-sig: "hey" (with BOM) |
|
b = []byte{0xef, 0xbb, 0xbf, 0x68, 0x65, 0x79} |
|
testSuccess(b, "UTF-8") |
|
|
|
// utf-16: "hey<accented G>" |
|
b = []byte{0xff, 0xfe, 0x68, 0x00, 0x65, 0x00, 0x79, 0x00, 0xf4, 0x01} |
|
testSuccess(b, "UTF-16LE") |
|
|
|
// iso-8859-1: d<accented e>cor<newline> |
|
b = []byte{0x44, 0xe9, 0x63, 0x6f, 0x72, 0x0a} |
|
encoding, err := DetectEncoding(b) |
|
assert.NoError(t, err) |
|
// due to a race condition in `chardet` library, it could either detect |
|
// "ISO-8859-1" or "IS0-8859-2" here. Technically either is correct, so |
|
// we accept either. |
|
assert.Contains(t, encoding, "ISO-8859") |
|
|
|
setting.Repository.AnsiCharset = "placeholder" |
|
testSuccess(b, "placeholder") |
|
|
|
// invalid bytes |
|
b = []byte{0xfa} |
|
_, err = DetectEncoding(b) |
|
assert.Error(t, err) |
|
} |
|
|
|
func TestBasicAuthDecode(t *testing.T) { |
|
_, _, err := BasicAuthDecode("?") |
|
assert.Equal(t, "illegal base64 data at input byte 0", err.Error()) |
|
|
|
user, pass, err := BasicAuthDecode("Zm9vOmJhcg==") |
|
assert.NoError(t, err) |
|
assert.Equal(t, "foo", user) |
|
assert.Equal(t, "bar", pass) |
|
} |
|
|
|
func TestBasicAuthEncode(t *testing.T) { |
|
assert.Equal(t, "Zm9vOmJhcg==", BasicAuthEncode("foo", "bar")) |
|
} |
|
|
|
// TODO: Test PBKDF2() |
|
// TODO: Test VerifyTimeLimitCode() |
|
// TODO: Test CreateTimeLimitCode() |
|
|
|
func TestHashEmail(t *testing.T) { |
|
assert.Equal(t, |
|
"d41d8cd98f00b204e9800998ecf8427e", |
|
HashEmail(""), |
|
) |
|
assert.Equal(t, |
|
"353cbad9b58e69c96154ad99f92bedc7", |
|
HashEmail("gitea@example.com"), |
|
) |
|
} |
|
|
|
const gravatarSource = "https://secure.gravatar.com/avatar/" |
|
|
|
func disableGravatar() { |
|
setting.EnableFederatedAvatar = false |
|
setting.LibravatarService = nil |
|
setting.DisableGravatar = true |
|
} |
|
|
|
func enableGravatar(t *testing.T) { |
|
setting.DisableGravatar = false |
|
var err error |
|
setting.GravatarSourceURL, err = url.Parse(gravatarSource) |
|
assert.NoError(t, err) |
|
} |
|
|
|
func TestSizedAvatarLink(t *testing.T) { |
|
disableGravatar() |
|
assert.Equal(t, "/img/avatar_default.png", |
|
SizedAvatarLink("gitea@example.com", 100)) |
|
|
|
enableGravatar(t) |
|
assert.Equal(t, |
|
"https://secure.gravatar.com/avatar/353cbad9b58e69c96154ad99f92bedc7?d=identicon&s=100", |
|
SizedAvatarLink("gitea@example.com", 100), |
|
) |
|
} |
|
|
|
func TestAvatarLink(t *testing.T) { |
|
disableGravatar() |
|
assert.Equal(t, "/img/avatar_default.png", AvatarLink("gitea@example.com")) |
|
|
|
enableGravatar(t) |
|
assert.Equal(t, |
|
"https://secure.gravatar.com/avatar/353cbad9b58e69c96154ad99f92bedc7?d=identicon", |
|
AvatarLink("gitea@example.com"), |
|
) |
|
} |
|
|
|
func TestComputeTimeDiff(t *testing.T) { |
|
// test that for each offset in offsets, |
|
// computeTimeDiff(base + offset) == (offset, str) |
|
test := func(base int64, str string, offsets ...int64) { |
|
for _, offset := range offsets { |
|
diff, diffStr := computeTimeDiff(base+offset, "en") |
|
assert.Equal(t, offset, diff) |
|
assert.Equal(t, str, diffStr) |
|
} |
|
} |
|
test(0, "now", 0) |
|
test(1, "1 second", 0) |
|
test(2, "2 seconds", 0) |
|
test(Minute, "1 minute", 0, 1, 30, Minute-1) |
|
test(2*Minute, "2 minutes", 0, Minute-1) |
|
test(Hour, "1 hour", 0, 1, Hour-1) |
|
test(5*Hour, "5 hours", 0, Hour-1) |
|
test(Day, "1 day", 0, 1, Day-1) |
|
test(5*Day, "5 days", 0, Day-1) |
|
test(Week, "1 week", 0, 1, Week-1) |
|
test(3*Week, "3 weeks", 0, 4*Day+25000) |
|
test(Month, "1 month", 0, 1, Month-1) |
|
test(10*Month, "10 months", 0, Month-1) |
|
test(Year, "1 year", 0, Year-1) |
|
test(3*Year, "3 years", 0, Year-1) |
|
} |
|
|
|
func TestMinutesToFriendly(t *testing.T) { |
|
// test that a number of minutes yields the expected string |
|
test := func(expected string, minutes int) { |
|
actual := MinutesToFriendly(minutes, "en") |
|
assert.Equal(t, expected, actual) |
|
} |
|
test("1 minute", 1) |
|
test("2 minutes", 2) |
|
test("1 hour", 60) |
|
test("1 hour, 1 minute", 61) |
|
test("1 hour, 2 minutes", 62) |
|
test("2 hours", 120) |
|
} |
|
|
|
func TestTimeSince(t *testing.T) { |
|
assert.Equal(t, "now", timeSince(BaseDate, BaseDate, "en")) |
|
|
|
// test that each diff in `diffs` yields the expected string |
|
test := func(expected string, diffs ...time.Duration) { |
|
for _, diff := range diffs { |
|
actual := timeSince(BaseDate, BaseDate.Add(diff), "en") |
|
assert.Equal(t, i18n.Tr("en", "tool.ago", expected), actual) |
|
actual = timeSince(BaseDate.Add(diff), BaseDate, "en") |
|
assert.Equal(t, i18n.Tr("en", "tool.from_now", expected), actual) |
|
} |
|
} |
|
test("1 second", time.Second, time.Second+50*time.Millisecond) |
|
test("2 seconds", 2*time.Second, 2*time.Second+50*time.Millisecond) |
|
test("1 minute", time.Minute, time.Minute+30*time.Second) |
|
test("2 minutes", 2*time.Minute, 2*time.Minute+30*time.Second) |
|
test("1 hour", time.Hour, time.Hour+30*time.Minute) |
|
test("2 hours", 2*time.Hour, 2*time.Hour+30*time.Minute) |
|
test("1 day", DayDur, DayDur+12*time.Hour) |
|
test("2 days", 2*DayDur, 2*DayDur+12*time.Hour) |
|
test("1 week", WeekDur, WeekDur+3*DayDur) |
|
test("2 weeks", 2*WeekDur, 2*WeekDur+3*DayDur) |
|
test("1 month", MonthDur, MonthDur+15*DayDur) |
|
test("2 months", 2*MonthDur, 2*MonthDur+15*DayDur) |
|
test("1 year", YearDur, YearDur+6*MonthDur) |
|
test("2 years", 2*YearDur, 2*YearDur+6*MonthDur) |
|
} |
|
|
|
func TestTimeSincePro(t *testing.T) { |
|
assert.Equal(t, "now", timeSincePro(BaseDate, BaseDate, "en")) |
|
|
|
// test that a difference of `diff` yields the expected string |
|
test := func(expected string, diff time.Duration) { |
|
actual := timeSincePro(BaseDate, BaseDate.Add(diff), "en") |
|
assert.Equal(t, expected, actual) |
|
assert.Equal(t, "future", timeSincePro(BaseDate.Add(diff), BaseDate, "en")) |
|
} |
|
test("1 second", time.Second) |
|
test("2 seconds", 2*time.Second) |
|
test("1 minute", time.Minute) |
|
test("1 minute, 1 second", time.Minute+time.Second) |
|
test("1 minute, 59 seconds", time.Minute+59*time.Second) |
|
test("2 minutes", 2*time.Minute) |
|
test("1 hour", time.Hour) |
|
test("1 hour, 1 second", time.Hour+time.Second) |
|
test("1 hour, 59 minutes, 59 seconds", time.Hour+59*time.Minute+59*time.Second) |
|
test("2 hours", 2*time.Hour) |
|
test("1 day", DayDur) |
|
test("1 day, 23 hours, 59 minutes, 59 seconds", |
|
DayDur+23*time.Hour+59*time.Minute+59*time.Second) |
|
test("2 days", 2*DayDur) |
|
test("1 week", WeekDur) |
|
test("2 weeks", 2*WeekDur) |
|
test("1 month", MonthDur) |
|
test("3 months", 3*MonthDur) |
|
test("1 year", YearDur) |
|
test("2 years, 3 months, 1 week, 2 days, 4 hours, 12 minutes, 17 seconds", |
|
2*YearDur+3*MonthDur+WeekDur+2*DayDur+4*time.Hour+ |
|
12*time.Minute+17*time.Second) |
|
} |
|
|
|
func TestHtmlTimeSince(t *testing.T) { |
|
setting.TimeFormat = time.UnixDate |
|
// test that `diff` yields a result containing `expected` |
|
test := func(expected string, diff time.Duration) { |
|
actual := htmlTimeSince(BaseDate, BaseDate.Add(diff), "en") |
|
assert.Contains(t, actual, `title="Sat Jan 1 00:00:00 UTC 2000"`) |
|
assert.Contains(t, actual, expected) |
|
} |
|
test("1 second", time.Second) |
|
test("3 minutes", 3*time.Minute+5*time.Second) |
|
test("1 day", DayDur+18*time.Hour) |
|
test("1 week", WeekDur+6*DayDur) |
|
test("3 months", 3*MonthDur+3*WeekDur) |
|
test("2 years", 2*YearDur) |
|
test("3 years", 3*YearDur+11*MonthDur+4*WeekDur) |
|
} |
|
|
|
func TestFileSize(t *testing.T) { |
|
var size int64 = 512 |
|
assert.Equal(t, "512B", FileSize(size)) |
|
size *= 1024 |
|
assert.Equal(t, "512KB", FileSize(size)) |
|
size *= 1024 |
|
assert.Equal(t, "512MB", FileSize(size)) |
|
size *= 1024 |
|
assert.Equal(t, "512GB", FileSize(size)) |
|
size *= 1024 |
|
assert.Equal(t, "512TB", FileSize(size)) |
|
size *= 1024 |
|
assert.Equal(t, "512PB", FileSize(size)) |
|
size *= 4 |
|
assert.Equal(t, "2.0EB", FileSize(size)) |
|
} |
|
|
|
func TestSubtract(t *testing.T) { |
|
toFloat64 := func(n interface{}) float64 { |
|
switch v := n.(type) { |
|
case int: |
|
return float64(v) |
|
case int8: |
|
return float64(v) |
|
case int16: |
|
return float64(v) |
|
case int32: |
|
return float64(v) |
|
case int64: |
|
return float64(v) |
|
case float32: |
|
return float64(v) |
|
case float64: |
|
return v |
|
default: |
|
return 0.0 |
|
} |
|
} |
|
values := []interface{}{ |
|
int(-3), |
|
int8(14), |
|
int16(81), |
|
int32(-156), |
|
int64(1528), |
|
float32(3.5), |
|
float64(-15.348), |
|
} |
|
for _, left := range values { |
|
for _, right := range values { |
|
expected := toFloat64(left) - toFloat64(right) |
|
sub := Subtract(left, right) |
|
assert.InDelta(t, expected, sub, 1e-3) |
|
} |
|
} |
|
} |
|
|
|
func TestEllipsisString(t *testing.T) { |
|
assert.Equal(t, "...", EllipsisString("foobar", 0)) |
|
assert.Equal(t, "...", EllipsisString("foobar", 1)) |
|
assert.Equal(t, "...", EllipsisString("foobar", 2)) |
|
assert.Equal(t, "...", EllipsisString("foobar", 3)) |
|
assert.Equal(t, "f...", EllipsisString("foobar", 4)) |
|
assert.Equal(t, "fo...", EllipsisString("foobar", 5)) |
|
assert.Equal(t, "foobar", EllipsisString("foobar", 6)) |
|
assert.Equal(t, "foobar", EllipsisString("foobar", 10)) |
|
} |
|
|
|
func TestTruncateString(t *testing.T) { |
|
assert.Equal(t, "", TruncateString("foobar", 0)) |
|
assert.Equal(t, "f", TruncateString("foobar", 1)) |
|
assert.Equal(t, "fo", TruncateString("foobar", 2)) |
|
assert.Equal(t, "foo", TruncateString("foobar", 3)) |
|
assert.Equal(t, "foob", TruncateString("foobar", 4)) |
|
assert.Equal(t, "fooba", TruncateString("foobar", 5)) |
|
assert.Equal(t, "foobar", TruncateString("foobar", 6)) |
|
assert.Equal(t, "foobar", TruncateString("foobar", 7)) |
|
} |
|
|
|
func TestStringsToInt64s(t *testing.T) { |
|
testSuccess := func(input []string, expected []int64) { |
|
result, err := StringsToInt64s(input) |
|
assert.NoError(t, err) |
|
assert.Equal(t, expected, result) |
|
} |
|
testSuccess([]string{}, []int64{}) |
|
testSuccess([]string{"-1234"}, []int64{-1234}) |
|
testSuccess([]string{"1", "4", "16", "64", "256"}, |
|
[]int64{1, 4, 16, 64, 256}) |
|
|
|
_, err := StringsToInt64s([]string{"-1", "a", "$"}) |
|
assert.Error(t, err) |
|
} |
|
|
|
func TestInt64sToStrings(t *testing.T) { |
|
assert.Equal(t, []string{}, Int64sToStrings([]int64{})) |
|
assert.Equal(t, |
|
[]string{"1", "4", "16", "64", "256"}, |
|
Int64sToStrings([]int64{1, 4, 16, 64, 256}), |
|
) |
|
} |
|
|
|
func TestInt64sToMap(t *testing.T) { |
|
assert.Equal(t, map[int64]bool{}, Int64sToMap([]int64{})) |
|
assert.Equal(t, |
|
map[int64]bool{1: true, 4: true, 16: true}, |
|
Int64sToMap([]int64{1, 4, 16}), |
|
) |
|
} |
|
|
|
func TestIsLetter(t *testing.T) { |
|
assert.True(t, IsLetter('a')) |
|
assert.True(t, IsLetter('e')) |
|
assert.True(t, IsLetter('q')) |
|
assert.True(t, IsLetter('z')) |
|
assert.True(t, IsLetter('A')) |
|
assert.True(t, IsLetter('E')) |
|
assert.True(t, IsLetter('Q')) |
|
assert.True(t, IsLetter('Z')) |
|
assert.True(t, IsLetter('_')) |
|
assert.False(t, IsLetter('-')) |
|
assert.False(t, IsLetter('1')) |
|
assert.False(t, IsLetter('$')) |
|
} |
|
|
|
func TestIsTextFile(t *testing.T) { |
|
assert.True(t, IsTextFile([]byte{})) |
|
assert.True(t, IsTextFile([]byte("lorem ipsum"))) |
|
} |
|
|
|
// TODO: IsImageFile(), currently no idea how to test |
|
// TODO: IsPDFFile(), currently no idea how to test
|
|
|