2018-02-20 07:50:42 -05:00
|
|
|
// Copyright 2018 The Gitea Authors. All rights reserved.
|
2024-08-04 14:46:05 -04:00
|
|
|
// Copyright 2024 The Forgejo Authors. All rights reserved.
|
2022-11-27 13:20:29 -05:00
|
|
|
// SPDX-License-Identifier: MIT
|
2018-02-20 07:50:42 -05:00
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
package util_test
|
2018-02-20 07:50:42 -05:00
|
|
|
|
|
|
|
import (
|
2024-08-04 14:46:05 -04:00
|
|
|
"bytes"
|
|
|
|
"crypto/rand"
|
2021-05-10 02:45:17 -04:00
|
|
|
"regexp"
|
2019-11-12 21:27:11 -05:00
|
|
|
"strings"
|
2018-02-20 07:50:42 -05:00
|
|
|
"testing"
|
|
|
|
|
2024-02-29 13:52:49 -05:00
|
|
|
"code.gitea.io/gitea/modules/optional"
|
2024-08-04 14:46:05 -04:00
|
|
|
"code.gitea.io/gitea/modules/test"
|
|
|
|
"code.gitea.io/gitea/modules/util"
|
2024-02-29 13:52:49 -05:00
|
|
|
|
2018-02-20 07:50:42 -05:00
|
|
|
"github.com/stretchr/testify/assert"
|
2024-07-30 15:41:10 -04:00
|
|
|
"github.com/stretchr/testify/require"
|
2018-02-20 07:50:42 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
func TestURLJoin(t *testing.T) {
|
|
|
|
type test struct {
|
|
|
|
Expected string
|
|
|
|
Base string
|
|
|
|
Elements []string
|
|
|
|
}
|
|
|
|
newTest := func(expected, base string, elements ...string) test {
|
|
|
|
return test{Expected: expected, Base: base, Elements: elements}
|
|
|
|
}
|
|
|
|
for _, test := range []test{
|
|
|
|
newTest("https://try.gitea.io/a/b/c",
|
|
|
|
"https://try.gitea.io", "a/b", "c"),
|
|
|
|
newTest("https://try.gitea.io/a/b/c",
|
|
|
|
"https://try.gitea.io/", "/a/b/", "/c/"),
|
|
|
|
newTest("https://try.gitea.io/a/c",
|
|
|
|
"https://try.gitea.io/", "/a/./b/", "../c/"),
|
|
|
|
newTest("a/b/c",
|
|
|
|
"a", "b/c/"),
|
|
|
|
newTest("a/b/d",
|
|
|
|
"a/", "b/c/", "/../d/"),
|
2018-05-28 23:51:42 -04:00
|
|
|
newTest("https://try.gitea.io/a/b/c#d",
|
|
|
|
"https://try.gitea.io", "a/b", "c#d"),
|
2018-05-30 09:23:43 -04:00
|
|
|
newTest("/a/b/d",
|
|
|
|
"/a/", "b/c/", "/../d/"),
|
|
|
|
newTest("/a/b/c",
|
|
|
|
"/a", "b/c/"),
|
|
|
|
newTest("/a/b/c#hash",
|
|
|
|
"/a", "b/c#hash"),
|
2018-02-20 07:50:42 -05:00
|
|
|
} {
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, test.Expected, util.URLJoin(test.Base, test.Elements...))
|
2018-02-20 07:50:42 -05:00
|
|
|
}
|
|
|
|
}
|
2018-06-26 10:45:18 -04:00
|
|
|
|
2019-01-21 06:45:32 -05:00
|
|
|
func TestIsEmptyString(t *testing.T) {
|
|
|
|
cases := []struct {
|
|
|
|
s string
|
|
|
|
expected bool
|
|
|
|
}{
|
|
|
|
{"", true},
|
|
|
|
{" ", true},
|
|
|
|
{" ", true},
|
|
|
|
{" a", false},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, v := range cases {
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, v.expected, util.IsEmptyString(v.s))
|
2019-01-21 06:45:32 -05:00
|
|
|
}
|
|
|
|
}
|
2019-11-12 21:27:11 -05:00
|
|
|
|
|
|
|
func Test_NormalizeEOL(t *testing.T) {
|
|
|
|
data1 := []string{
|
|
|
|
"",
|
|
|
|
"This text starts with empty lines",
|
|
|
|
"another",
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
"Some other empty lines in the middle",
|
|
|
|
"more.",
|
|
|
|
"And more.",
|
|
|
|
"Ends with empty lines too.",
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
}
|
|
|
|
|
|
|
|
data2 := []string{
|
|
|
|
"This text does not start with empty lines",
|
|
|
|
"another",
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
"Some other empty lines in the middle",
|
|
|
|
"more.",
|
|
|
|
"And more.",
|
|
|
|
"Ends without EOLtoo.",
|
|
|
|
}
|
|
|
|
|
|
|
|
buildEOLData := func(data []string, eol string) []byte {
|
|
|
|
return []byte(strings.Join(data, eol))
|
|
|
|
}
|
|
|
|
|
|
|
|
dos := buildEOLData(data1, "\r\n")
|
|
|
|
unix := buildEOLData(data1, "\n")
|
|
|
|
mac := buildEOLData(data1, "\r")
|
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, unix, util.NormalizeEOL(dos))
|
|
|
|
assert.Equal(t, unix, util.NormalizeEOL(mac))
|
|
|
|
assert.Equal(t, unix, util.NormalizeEOL(unix))
|
2019-11-12 21:27:11 -05:00
|
|
|
|
|
|
|
dos = buildEOLData(data2, "\r\n")
|
|
|
|
unix = buildEOLData(data2, "\n")
|
|
|
|
mac = buildEOLData(data2, "\r")
|
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, unix, util.NormalizeEOL(dos))
|
|
|
|
assert.Equal(t, unix, util.NormalizeEOL(mac))
|
|
|
|
assert.Equal(t, unix, util.NormalizeEOL(unix))
|
2019-11-12 21:27:11 -05:00
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, []byte("one liner"), util.NormalizeEOL([]byte("one liner")))
|
|
|
|
assert.Equal(t, []byte("\n"), util.NormalizeEOL([]byte("\n")))
|
|
|
|
assert.Equal(t, []byte("\ntwo liner"), util.NormalizeEOL([]byte("\ntwo liner")))
|
|
|
|
assert.Equal(t, []byte("two liner\n"), util.NormalizeEOL([]byte("two liner\n")))
|
|
|
|
assert.Equal(t, []byte{}, util.NormalizeEOL([]byte{}))
|
2019-11-12 21:27:11 -05:00
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, []byte("mix\nand\nmatch\n."), util.NormalizeEOL([]byte("mix\r\nand\rmatch\n.")))
|
2019-11-12 21:27:11 -05:00
|
|
|
}
|
2021-05-10 02:45:17 -04:00
|
|
|
|
|
|
|
func Test_RandomInt(t *testing.T) {
|
2024-08-04 14:46:05 -04:00
|
|
|
randInt, err := util.CryptoRandomInt(255)
|
2024-07-30 15:41:10 -04:00
|
|
|
assert.GreaterOrEqual(t, randInt, int64(0))
|
|
|
|
assert.LessOrEqual(t, randInt, int64(255))
|
|
|
|
require.NoError(t, err)
|
2021-05-10 02:45:17 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
func Test_RandomString(t *testing.T) {
|
2024-08-04 14:46:05 -04:00
|
|
|
str1, err := util.CryptoRandomString(32)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2021-05-10 02:45:17 -04:00
|
|
|
matches, err := regexp.MatchString(`^[a-zA-Z0-9]{32}$`, str1)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2021-05-10 02:45:17 -04:00
|
|
|
assert.True(t, matches)
|
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
str2, err := util.CryptoRandomString(32)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2021-05-10 02:45:17 -04:00
|
|
|
matches, err = regexp.MatchString(`^[a-zA-Z0-9]{32}$`, str1)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2021-05-10 02:45:17 -04:00
|
|
|
assert.True(t, matches)
|
|
|
|
|
|
|
|
assert.NotEqual(t, str1, str2)
|
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
str3, err := util.CryptoRandomString(256)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2021-05-10 02:45:17 -04:00
|
|
|
matches, err = regexp.MatchString(`^[a-zA-Z0-9]{256}$`, str3)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2021-05-10 02:45:17 -04:00
|
|
|
assert.True(t, matches)
|
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
str4, err := util.CryptoRandomString(256)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2021-05-10 02:45:17 -04:00
|
|
|
matches, err = regexp.MatchString(`^[a-zA-Z0-9]{256}$`, str4)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2021-05-10 02:45:17 -04:00
|
|
|
assert.True(t, matches)
|
|
|
|
|
|
|
|
assert.NotEqual(t, str3, str4)
|
|
|
|
}
|
2021-10-12 14:11:35 -04:00
|
|
|
|
2022-01-04 10:13:52 -05:00
|
|
|
func Test_RandomBytes(t *testing.T) {
|
2024-08-04 14:46:05 -04:00
|
|
|
bytes1, err := util.CryptoRandomBytes(32)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2022-01-04 10:13:52 -05:00
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
bytes2, err := util.CryptoRandomBytes(32)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2022-01-04 10:13:52 -05:00
|
|
|
|
|
|
|
assert.NotEqual(t, bytes1, bytes2)
|
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
bytes3, err := util.CryptoRandomBytes(256)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2022-01-04 10:13:52 -05:00
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
bytes4, err := util.CryptoRandomBytes(256)
|
2024-07-30 15:41:10 -04:00
|
|
|
require.NoError(t, err)
|
2022-01-04 10:13:52 -05:00
|
|
|
|
|
|
|
assert.NotEqual(t, bytes3, bytes4)
|
|
|
|
}
|
|
|
|
|
2024-02-29 13:52:49 -05:00
|
|
|
func TestOptionalBoolParse(t *testing.T) {
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, optional.None[bool](), util.OptionalBoolParse(""))
|
|
|
|
assert.Equal(t, optional.None[bool](), util.OptionalBoolParse("x"))
|
2021-10-12 14:11:35 -04:00
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, optional.Some(false), util.OptionalBoolParse("0"))
|
|
|
|
assert.Equal(t, optional.Some(false), util.OptionalBoolParse("f"))
|
|
|
|
assert.Equal(t, optional.Some(false), util.OptionalBoolParse("False"))
|
2021-10-12 14:11:35 -04:00
|
|
|
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, optional.Some(true), util.OptionalBoolParse("1"))
|
|
|
|
assert.Equal(t, optional.Some(true), util.OptionalBoolParse("t"))
|
|
|
|
assert.Equal(t, optional.Some(true), util.OptionalBoolParse("True"))
|
2021-10-12 14:11:35 -04:00
|
|
|
}
|
2022-02-01 07:59:25 -05:00
|
|
|
|
|
|
|
// Test case for any function which accepts and returns a single string.
|
|
|
|
type StringTest struct {
|
|
|
|
in, out string
|
|
|
|
}
|
|
|
|
|
|
|
|
var upperTests = []StringTest{
|
|
|
|
{"", ""},
|
|
|
|
{"ONLYUPPER", "ONLYUPPER"},
|
|
|
|
{"abc", "ABC"},
|
|
|
|
{"AbC123", "ABC123"},
|
|
|
|
{"azAZ09_", "AZAZ09_"},
|
|
|
|
{"longStrinGwitHmixofsmaLLandcAps", "LONGSTRINGWITHMIXOFSMALLANDCAPS"},
|
|
|
|
{"long\u0250string\u0250with\u0250nonascii\u2C6Fchars", "LONG\u0250STRING\u0250WITH\u0250NONASCII\u2C6FCHARS"},
|
|
|
|
{"\u0250\u0250\u0250\u0250\u0250", "\u0250\u0250\u0250\u0250\u0250"},
|
|
|
|
{"a\u0080\U0010FFFF", "A\u0080\U0010FFFF"},
|
|
|
|
{"lél", "LéL"},
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestToUpperASCII(t *testing.T) {
|
|
|
|
for _, tc := range upperTests {
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, util.ToUpperASCII(tc.in), tc.out)
|
2022-02-01 07:59:25 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkToUpper(b *testing.B) {
|
|
|
|
for _, tc := range upperTests {
|
|
|
|
b.Run(tc.in, func(b *testing.B) {
|
|
|
|
for i := 0; i < b.N; i++ {
|
2024-08-04 14:46:05 -04:00
|
|
|
util.ToUpperASCII(tc.in)
|
2022-02-01 07:59:25 -05:00
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
2022-05-10 17:55:54 -04:00
|
|
|
|
|
|
|
func TestToTitleCase(t *testing.T) {
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, `Foo Bar Baz`, util.ToTitleCase(`foo bar baz`))
|
|
|
|
assert.Equal(t, `Foo Bar Baz`, util.ToTitleCase(`FOO BAR BAZ`))
|
2022-05-10 17:55:54 -04:00
|
|
|
}
|
2023-07-07 01:31:56 -04:00
|
|
|
|
|
|
|
func TestToPointer(t *testing.T) {
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, "abc", *util.ToPointer("abc"))
|
|
|
|
assert.Equal(t, 123, *util.ToPointer(123))
|
2023-07-07 01:31:56 -04:00
|
|
|
abc := "abc"
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.NotSame(t, &abc, util.ToPointer(abc))
|
2023-07-07 01:31:56 -04:00
|
|
|
val123 := 123
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.NotSame(t, &val123, util.ToPointer(val123))
|
2023-07-07 01:31:56 -04:00
|
|
|
}
|
2024-03-28 16:40:35 -04:00
|
|
|
|
|
|
|
func TestReserveLineBreakForTextarea(t *testing.T) {
|
2024-08-04 14:46:05 -04:00
|
|
|
assert.Equal(t, "test\ndata", util.ReserveLineBreakForTextarea("test\r\ndata"))
|
|
|
|
assert.Equal(t, "test\ndata\n", util.ReserveLineBreakForTextarea("test\r\ndata\r\n"))
|
|
|
|
}
|
|
|
|
|
|
|
|
const (
|
|
|
|
testPublicKey = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAOhB7/zzhC+HXDdGOdLwJln5NYwm6UNXx3chmQSVTG4\n"
|
|
|
|
testPrivateKey = `-----BEGIN OPENSSH PRIVATE KEY-----
|
|
|
|
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtz
|
|
|
|
c2gtZWQyNTUxOQAAACADoQe/884Qvh1w3RjnS8CZZ+TWMJulDV8d3IZkElUxuAAA
|
|
|
|
AIggISIjICEiIwAAAAtzc2gtZWQyNTUxOQAAACADoQe/884Qvh1w3RjnS8CZZ+TW
|
|
|
|
MJulDV8d3IZkElUxuAAAAEAAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0e
|
|
|
|
HwOhB7/zzhC+HXDdGOdLwJln5NYwm6UNXx3chmQSVTG4AAAAAAECAwQF
|
|
|
|
-----END OPENSSH PRIVATE KEY-----` + "\n"
|
|
|
|
)
|
|
|
|
|
|
|
|
func TestGeneratingEd25519Keypair(t *testing.T) {
|
|
|
|
defer test.MockProtect(&rand.Reader)()
|
|
|
|
|
|
|
|
// Only 32 bytes needs to be provided to generate a ed25519 keypair.
|
|
|
|
// And another 32 bytes are required, which is included as random value
|
|
|
|
// in the OpenSSH format.
|
|
|
|
b := make([]byte, 64)
|
|
|
|
for i := 0; i < 64; i++ {
|
|
|
|
b[i] = byte(i)
|
|
|
|
}
|
|
|
|
rand.Reader = bytes.NewReader(b)
|
|
|
|
|
|
|
|
publicKey, privateKey, err := util.GenerateSSHKeypair()
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.EqualValues(t, testPublicKey, string(publicKey))
|
|
|
|
assert.EqualValues(t, testPrivateKey, string(privateKey))
|
2024-03-28 16:40:35 -04:00
|
|
|
}
|
2024-11-01 11:18:29 -04:00
|
|
|
|
|
|
|
func TestOptionalArg(t *testing.T) {
|
|
|
|
foo := func(other any, optArg ...int) int {
|
|
|
|
return util.OptionalArg(optArg)
|
|
|
|
}
|
|
|
|
bar := func(other any, optArg ...int) int {
|
|
|
|
return util.OptionalArg(optArg, 42)
|
|
|
|
}
|
|
|
|
assert.Equal(t, 0, foo(nil))
|
|
|
|
assert.Equal(t, 100, foo(nil, 100))
|
|
|
|
assert.Equal(t, 42, bar(nil))
|
|
|
|
assert.Equal(t, 100, bar(nil, 100))
|
|
|
|
}
|