--- /dev/null
+// +build pam
+
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package pam
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestPamAuth(t *testing.T) {
+ result, err := Auth("gitea", "user1", "false-pwd")
+ assert.Error(t, err)
+ assert.EqualValues(t, "Authentication failure", err.Error())
+ assert.Len(t, result, 0)
+}
test("v1.20.0", "v1.2.0", false)
test("v1.20.0", "v1.29.0", true)
test("v1.20.0", "v1.20.0", false)
- test("abc", "bcd", "abc" < "bcd")
+ test("abc", "bcd", true)
test("a-1-a", "a-1-b", true)
test("2", "12", true)
- test("a", "ab", "a" < "ab")
+ test("a", "ab", true)
}
}
// IsLetter reports whether the rune is a letter (category L).
-// https://github.com/golang/go/blob/master/src/go/scanner/scanner.go#L257
+// https://github.com/golang/go/blob/c3b4918/src/go/scanner/scanner.go#L342
func IsLetter(ch rune) bool {
return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= 0x80 && unicode.IsLetter(ch)
}
package base
import (
+ "encoding/base64"
+ "os"
"testing"
+ "time"
"github.com/stretchr/testify/assert"
)
func TestBasicAuthEncode(t *testing.T) {
assert.Equal(t, "Zm9vOmJhcg==", BasicAuthEncode("foo", "bar"))
+ assert.Equal(t, "MjM6IjotLS0t", BasicAuthEncode("23:\"", "----"))
}
-// TODO: Test PBKDF2()
-// TODO: Test VerifyTimeLimitCode()
-// TODO: Test CreateTimeLimitCode()
+func TestVerifyTimeLimitCode(t *testing.T) {
+ tc := []struct {
+ data string
+ minutes int
+ code string
+ valid bool
+ }{{
+ data: "data",
+ minutes: 2,
+ code: testCreateTimeLimitCode(t, "data", 2),
+ valid: true,
+ }, {
+ data: "abc123-ß",
+ minutes: 1,
+ code: testCreateTimeLimitCode(t, "abc123-ß", 1),
+ valid: true,
+ }, {
+ data: "data",
+ minutes: 2,
+ code: "2021012723240000005928251dac409d2c33a6eb82c63410aaad569bed",
+ valid: false,
+ }}
+ for _, test := range tc {
+ actualValid := VerifyTimeLimitCode(test.data, test.minutes, test.code)
+ assert.Equal(t, test.valid, actualValid, "data: '%s' code: '%s' should be valid: %t", test.data, test.code, test.valid)
+ }
+}
+
+func testCreateTimeLimitCode(t *testing.T, data string, m int) string {
+ result0 := CreateTimeLimitCode(data, m, nil)
+ result1 := CreateTimeLimitCode(data, m, time.Now().Format("200601021504"))
+ result2 := CreateTimeLimitCode(data, m, time.Unix(time.Now().Unix()+int64(time.Minute)*int64(m), 0).Format("200601021504"))
+
+ assert.Equal(t, result0, result1)
+ assert.NotEqual(t, result0, result2)
+
+ assert.True(t, len(result0) != 0)
+ return result0
+}
func TestFileSize(t *testing.T) {
var size int64 = 512
assert.Equal(t, "2.0 EiB", FileSize(size))
}
+func TestPrettyNumber(t *testing.T) {
+ assert.Equal(t, "23,342,432", PrettyNumber(23342432))
+ assert.Equal(t, "0", PrettyNumber(0))
+ assert.Equal(t, "-100,000", PrettyNumber(-100000))
+}
+
func TestSubtract(t *testing.T) {
toFloat64 := func(n interface{}) float64 {
switch v := n.(type) {
)
}
+func TestInt64sContains(t *testing.T) {
+ assert.Equal(t, map[int64]bool{}, Int64sToMap([]int64{}))
+ assert.Equal(t, true, Int64sContains([]int64{6, 44324, 4324, 32, 1, 2323}, 1))
+ assert.Equal(t, true, Int64sContains([]int64{2323}, 2323))
+ assert.Equal(t, false, Int64sContains([]int64{6, 44324, 4324, 32, 1, 2323}, 232))
+}
+
func TestIsLetter(t *testing.T) {
assert.True(t, IsLetter('a'))
assert.True(t, IsLetter('e'))
assert.False(t, IsLetter('-'))
assert.False(t, IsLetter('1'))
assert.False(t, IsLetter('$'))
+ assert.False(t, IsLetter(0x00))
+ assert.False(t, IsLetter(0x93))
}
func TestDetectContentTypeLongerThanSniffLen(t *testing.T) {
Comment Comment Comment --><svg></svg>`)))
}
+// IsRepresentableAsText
+
func TestIsTextFile(t *testing.T) {
assert.True(t, IsTextFile([]byte{}))
assert.True(t, IsTextFile([]byte("lorem ipsum")))
}
+func TestIsImageFile(t *testing.T) {
+ png, _ := base64.StdEncoding.DecodeString("iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAG0lEQVQYlWN4+vTpf3SMDTAMBYXYBLFpHgoKAeiOf0SGE9kbAAAAAElFTkSuQmCC")
+ assert.True(t, IsImageFile(png))
+ assert.False(t, IsImageFile([]byte("plain text")))
+}
+
func TestIsSVGImageFile(t *testing.T) {
assert.True(t, IsSVGImageFile([]byte("<svg></svg>")))
assert.True(t, IsSVGImageFile([]byte(" <svg></svg>")))
<foo></foo>`)))
}
+func TestIsPDFFile(t *testing.T) {
+ pdf, _ := base64.StdEncoding.DecodeString("JVBERi0xLjYKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0ZpbHRlci9GbGF0ZURlY29kZT4+CnN0cmVhbQp4nF3NPwsCMQwF8D2f4s2CNYk1baF0EHRwOwg4iJt/NsFb/PpevUE4Mjwe")
+ assert.True(t, IsPDFFile(pdf))
+ assert.False(t, IsPDFFile([]byte("plain text")))
+}
+
+func TestIsVideoFile(t *testing.T) {
+ mp4, _ := base64.StdEncoding.DecodeString("AAAAGGZ0eXBtcDQyAAAAAGlzb21tcDQyAAEI721vb3YAAABsbXZoZAAAAADaBlwX2gZcFwAAA+gA")
+ assert.True(t, IsVideoFile(mp4))
+ assert.False(t, IsVideoFile([]byte("plain text")))
+}
+
+func TestIsAudioFile(t *testing.T) {
+ mp3, _ := base64.StdEncoding.DecodeString("SUQzBAAAAAABAFRYWFgAAAASAAADbWFqb3JfYnJhbmQAbXA0MgBUWFhYAAAAEQAAA21pbm9yX3Zl")
+ assert.True(t, IsAudioFile(mp3))
+ assert.False(t, IsAudioFile([]byte("plain text")))
+}
+
+// TODO: Test EntryIcon
+
+func TestSetupGiteaRoot(t *testing.T) {
+ _ = os.Setenv("GITEA_ROOT", "test")
+ assert.EqualValues(t, "test", SetupGiteaRoot())
+ _ = os.Setenv("GITEA_ROOT", "")
+ assert.NotEqual(t, "test", SetupGiteaRoot())
+}
+
func TestFormatNumberSI(t *testing.T) {
assert.Equal(t, "125", FormatNumberSI(int(125)))
assert.Equal(t, "1.3k", FormatNumberSI(int64(1317)))
assert.Equal(t, "45.7G", FormatNumberSI(45721317675))
assert.Equal(t, "", FormatNumberSI("test"))
}
-
-// TODO: IsImageFile(), currently no idea how to test
-// TODO: IsPDFFile(), currently no idea how to test
--- /dev/null
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package cache
+
+import (
+ "fmt"
+ "testing"
+ "time"
+
+ "code.gitea.io/gitea/modules/setting"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func createTestCache() {
+ conn, _ = newCache(setting.Cache{
+ Adapter: "memory",
+ TTL: time.Minute,
+ })
+}
+
+func TestNewContext(t *testing.T) {
+ assert.NoError(t, NewContext())
+
+ setting.CacheService.Cache = setting.Cache{Enabled: true, Adapter: "redis", Conn: "some random string"}
+ con, err := newCache(setting.Cache{
+ Adapter: "rand",
+ Conn: "false conf",
+ Interval: 100,
+ })
+ assert.Error(t, err)
+ assert.Nil(t, con)
+}
+
+func TestGetCache(t *testing.T) {
+ createTestCache()
+
+ assert.NotNil(t, GetCache())
+}
+
+func TestGetString(t *testing.T) {
+ createTestCache()
+
+ data, err := GetString("key", func() (string, error) {
+ return "", fmt.Errorf("some error")
+ })
+ assert.Error(t, err)
+ assert.Equal(t, "", data)
+
+ data, err = GetString("key", func() (string, error) {
+ return "", nil
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, "", data)
+
+ // data, err = GetString("key", func() (string, error) {
+ // return "some data", nil
+ // })
+ // assert.NoError(t, err)
+ // assert.Equal(t, "", data)
+ // Remove("key")
+
+ data, err = GetString("key", func() (string, error) {
+ return "some data", nil
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, "some data", data)
+
+ // data, err = GetString("key", func() (string, error) {
+ // return "", fmt.Errorf("some error")
+ // })
+ // assert.NoError(t, err)
+ // assert.Equal(t, "some data", data)
+
+ // TODO: uncommented code works in IDE but not with go test
+}
+
+func TestGetInt(t *testing.T) {
+ createTestCache()
+
+ data, err := GetInt("key", func() (int, error) {
+ return 0, fmt.Errorf("some error")
+ })
+ assert.Error(t, err)
+ assert.Equal(t, 0, data)
+
+ data, err = GetInt("key", func() (int, error) {
+ return 0, nil
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, 0, data)
+
+ // data, err = GetInt("key", func() (int, error) {
+ // return 100, nil
+ // })
+ // assert.NoError(t, err)
+ // assert.Equal(t, 0, data)
+ // Remove("key")
+
+ data, err = GetInt("key", func() (int, error) {
+ return 100, nil
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, 100, data)
+
+ // data, err = GetInt("key", func() (int, error) {
+ // return 0, fmt.Errorf("some error")
+ // })
+ // assert.NoError(t, err)
+ // assert.Equal(t, 100, data)
+
+ // TODO: uncommented code works in IDE but not with go test
+}
+func TestGetInt64(t *testing.T) {
+ createTestCache()
+
+ data, err := GetInt64("key", func() (int64, error) {
+ return 0, fmt.Errorf("some error")
+ })
+ assert.Error(t, err)
+ assert.EqualValues(t, 0, data)
+
+ data, err = GetInt64("key", func() (int64, error) {
+ return 0, nil
+ })
+ assert.NoError(t, err)
+ assert.EqualValues(t, 0, data)
+
+ // data, err = GetInt64("key", func() (int64, error) {
+ // return 100, nil
+ // })
+ // assert.NoError(t, err)
+ // assert.EqualValues(t, 0, data)
+ // Remove("key")
+
+ data, err = GetInt64("key", func() (int64, error) {
+ return 100, nil
+ })
+ assert.NoError(t, err)
+ assert.EqualValues(t, 100, data)
+
+ // data, err = GetInt64("key", func() (int, error) {
+ // return 0, fmt.Errorf("some error")
+ // })
+ // assert.NoError(t, err)
+ // assert.EqualValues(t, 100, data)
+
+ // TODO: uncommented code works in IDE but not with go test
+}
--- /dev/null
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package convert
+
+import (
+ "testing"
+
+ _ "github.com/mattn/go-sqlite3"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestToCorrectPageSize(t *testing.T) {
+ assert.EqualValues(t, 30, ToCorrectPageSize(0))
+ assert.EqualValues(t, 30, ToCorrectPageSize(-10))
+ assert.EqualValues(t, 20, ToCorrectPageSize(20))
+ assert.EqualValues(t, 50, ToCorrectPageSize(100))
+}
+
+func TestToGitServiceType(t *testing.T) {
+ tc := []struct {
+ typ string
+ enum int
+ }{{
+ typ: "github", enum: 2,
+ }, {
+ typ: "gitea", enum: 3,
+ }, {
+ typ: "gitlab", enum: 4,
+ }, {
+ typ: "gogs", enum: 5,
+ }, {
+ typ: "trash", enum: 1,
+ }}
+ for _, test := range tc {
+ assert.EqualValues(t, test.enum, ToGitServiceType(test.typ))
+ }
+}
projects / gitea.git / commitdiff