code.gitea.io/gitea@v1.19.3/modules/base/tool_test.go (about)

     1  // Copyright 2020 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package base
     5  
     6  import (
     7  	"os"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestEncodeMD5(t *testing.T) {
    15  	assert.Equal(t,
    16  		"3858f62230ac3c915f300c664312c63f",
    17  		EncodeMD5("foobar"),
    18  	)
    19  }
    20  
    21  func TestEncodeSha1(t *testing.T) {
    22  	assert.Equal(t,
    23  		"8843d7f92416211de9ebb963ff4ce28125932878",
    24  		EncodeSha1("foobar"),
    25  	)
    26  }
    27  
    28  func TestEncodeSha256(t *testing.T) {
    29  	assert.Equal(t,
    30  		"c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2",
    31  		EncodeSha256("foobar"),
    32  	)
    33  }
    34  
    35  func TestShortSha(t *testing.T) {
    36  	assert.Equal(t, "veryverylo", ShortSha("veryverylong"))
    37  }
    38  
    39  func TestBasicAuthDecode(t *testing.T) {
    40  	_, _, err := BasicAuthDecode("?")
    41  	assert.Equal(t, "illegal base64 data at input byte 0", err.Error())
    42  
    43  	user, pass, err := BasicAuthDecode("Zm9vOmJhcg==")
    44  	assert.NoError(t, err)
    45  	assert.Equal(t, "foo", user)
    46  	assert.Equal(t, "bar", pass)
    47  
    48  	_, _, err = BasicAuthDecode("aW52YWxpZA==")
    49  	assert.Error(t, err)
    50  
    51  	_, _, err = BasicAuthDecode("invalid")
    52  	assert.Error(t, err)
    53  }
    54  
    55  func TestBasicAuthEncode(t *testing.T) {
    56  	assert.Equal(t, "Zm9vOmJhcg==", BasicAuthEncode("foo", "bar"))
    57  	assert.Equal(t, "MjM6IjotLS0t", BasicAuthEncode("23:\"", "----"))
    58  }
    59  
    60  func TestVerifyTimeLimitCode(t *testing.T) {
    61  	tc := []struct {
    62  		data    string
    63  		minutes int
    64  		code    string
    65  		valid   bool
    66  	}{{
    67  		data:    "data",
    68  		minutes: 2,
    69  		code:    testCreateTimeLimitCode(t, "data", 2),
    70  		valid:   true,
    71  	}, {
    72  		data:    "abc123-ß",
    73  		minutes: 1,
    74  		code:    testCreateTimeLimitCode(t, "abc123-ß", 1),
    75  		valid:   true,
    76  	}, {
    77  		data:    "data",
    78  		minutes: 2,
    79  		code:    "2021012723240000005928251dac409d2c33a6eb82c63410aaad569bed",
    80  		valid:   false,
    81  	}}
    82  	for _, test := range tc {
    83  		actualValid := VerifyTimeLimitCode(test.data, test.minutes, test.code)
    84  		assert.Equal(t, test.valid, actualValid, "data: '%s' code: '%s' should be valid: %t", test.data, test.code, test.valid)
    85  	}
    86  }
    87  
    88  func testCreateTimeLimitCode(t *testing.T, data string, m int) string {
    89  	result0 := CreateTimeLimitCode(data, m, nil)
    90  	result1 := CreateTimeLimitCode(data, m, time.Now().Format("200601021504"))
    91  	result2 := CreateTimeLimitCode(data, m, time.Unix(time.Now().Unix()+int64(time.Minute)*int64(m), 0).Format("200601021504"))
    92  
    93  	assert.Equal(t, result0, result1)
    94  	assert.NotEqual(t, result0, result2)
    95  
    96  	assert.True(t, len(result0) != 0)
    97  	return result0
    98  }
    99  
   100  func TestFileSize(t *testing.T) {
   101  	var size int64 = 512
   102  	assert.Equal(t, "512 B", FileSize(size))
   103  	size *= 1024
   104  	assert.Equal(t, "512 KiB", FileSize(size))
   105  	size *= 1024
   106  	assert.Equal(t, "512 MiB", FileSize(size))
   107  	size *= 1024
   108  	assert.Equal(t, "512 GiB", FileSize(size))
   109  	size *= 1024
   110  	assert.Equal(t, "512 TiB", FileSize(size))
   111  	size *= 1024
   112  	assert.Equal(t, "512 PiB", FileSize(size))
   113  	size *= 4
   114  	assert.Equal(t, "2.0 EiB", FileSize(size))
   115  }
   116  
   117  func TestPrettyNumber(t *testing.T) {
   118  	assert.Equal(t, "23,342,432", PrettyNumber(23342432))
   119  	assert.Equal(t, "23,342,432", PrettyNumber(int32(23342432)))
   120  	assert.Equal(t, "0", PrettyNumber(0))
   121  	assert.Equal(t, "-100,000", PrettyNumber(-100000))
   122  }
   123  
   124  func TestSubtract(t *testing.T) {
   125  	toFloat64 := func(n interface{}) float64 {
   126  		switch v := n.(type) {
   127  		case int:
   128  			return float64(v)
   129  		case int8:
   130  			return float64(v)
   131  		case int16:
   132  			return float64(v)
   133  		case int32:
   134  			return float64(v)
   135  		case int64:
   136  			return float64(v)
   137  		case float32:
   138  			return float64(v)
   139  		case float64:
   140  			return v
   141  		default:
   142  			return 0.0
   143  		}
   144  	}
   145  	values := []interface{}{
   146  		int(-3),
   147  		int8(14),
   148  		int16(81),
   149  		int32(-156),
   150  		int64(1528),
   151  		float32(3.5),
   152  		float64(-15.348),
   153  	}
   154  	for _, left := range values {
   155  		for _, right := range values {
   156  			expected := toFloat64(left) - toFloat64(right)
   157  			sub := Subtract(left, right)
   158  			assert.InDelta(t, expected, sub, 1e-3)
   159  		}
   160  	}
   161  }
   162  
   163  func TestEllipsisString(t *testing.T) {
   164  	assert.Equal(t, "...", EllipsisString("foobar", 0))
   165  	assert.Equal(t, "...", EllipsisString("foobar", 1))
   166  	assert.Equal(t, "...", EllipsisString("foobar", 2))
   167  	assert.Equal(t, "...", EllipsisString("foobar", 3))
   168  	assert.Equal(t, "f...", EllipsisString("foobar", 4))
   169  	assert.Equal(t, "fo...", EllipsisString("foobar", 5))
   170  	assert.Equal(t, "foobar", EllipsisString("foobar", 6))
   171  	assert.Equal(t, "foobar", EllipsisString("foobar", 10))
   172  	assert.Equal(t, "测...", EllipsisString("测试文本一二三四", 4))
   173  	assert.Equal(t, "测试...", EllipsisString("测试文本一二三四", 5))
   174  	assert.Equal(t, "测试文...", EllipsisString("测试文本一二三四", 6))
   175  	assert.Equal(t, "测试文本一二三四", EllipsisString("测试文本一二三四", 10))
   176  }
   177  
   178  func TestTruncateString(t *testing.T) {
   179  	assert.Equal(t, "", TruncateString("foobar", 0))
   180  	assert.Equal(t, "f", TruncateString("foobar", 1))
   181  	assert.Equal(t, "fo", TruncateString("foobar", 2))
   182  	assert.Equal(t, "foo", TruncateString("foobar", 3))
   183  	assert.Equal(t, "foob", TruncateString("foobar", 4))
   184  	assert.Equal(t, "fooba", TruncateString("foobar", 5))
   185  	assert.Equal(t, "foobar", TruncateString("foobar", 6))
   186  	assert.Equal(t, "foobar", TruncateString("foobar", 7))
   187  	assert.Equal(t, "测试文本", TruncateString("测试文本一二三四", 4))
   188  	assert.Equal(t, "测试文本一", TruncateString("测试文本一二三四", 5))
   189  	assert.Equal(t, "测试文本一二", TruncateString("测试文本一二三四", 6))
   190  	assert.Equal(t, "测试文本一二三", TruncateString("测试文本一二三四", 7))
   191  }
   192  
   193  func TestStringsToInt64s(t *testing.T) {
   194  	testSuccess := func(input []string, expected []int64) {
   195  		result, err := StringsToInt64s(input)
   196  		assert.NoError(t, err)
   197  		assert.Equal(t, expected, result)
   198  	}
   199  	testSuccess([]string{}, []int64{})
   200  	testSuccess([]string{"-1234"}, []int64{-1234})
   201  	testSuccess([]string{"1", "4", "16", "64", "256"},
   202  		[]int64{1, 4, 16, 64, 256})
   203  
   204  	_, err := StringsToInt64s([]string{"-1", "a", "$"})
   205  	assert.Error(t, err)
   206  }
   207  
   208  func TestInt64sToStrings(t *testing.T) {
   209  	assert.Equal(t, []string{}, Int64sToStrings([]int64{}))
   210  	assert.Equal(t,
   211  		[]string{"1", "4", "16", "64", "256"},
   212  		Int64sToStrings([]int64{1, 4, 16, 64, 256}),
   213  	)
   214  }
   215  
   216  func TestInt64sContains(t *testing.T) {
   217  	assert.True(t, Int64sContains([]int64{6, 44324, 4324, 32, 1, 2323}, 1))
   218  	assert.True(t, Int64sContains([]int64{2323}, 2323))
   219  	assert.False(t, Int64sContains([]int64{6, 44324, 4324, 32, 1, 2323}, 232))
   220  }
   221  
   222  func TestIsLetter(t *testing.T) {
   223  	assert.True(t, IsLetter('a'))
   224  	assert.True(t, IsLetter('e'))
   225  	assert.True(t, IsLetter('q'))
   226  	assert.True(t, IsLetter('z'))
   227  	assert.True(t, IsLetter('A'))
   228  	assert.True(t, IsLetter('E'))
   229  	assert.True(t, IsLetter('Q'))
   230  	assert.True(t, IsLetter('Z'))
   231  	assert.True(t, IsLetter('_'))
   232  	assert.False(t, IsLetter('-'))
   233  	assert.False(t, IsLetter('1'))
   234  	assert.False(t, IsLetter('$'))
   235  	assert.False(t, IsLetter(0x00))
   236  	assert.False(t, IsLetter(0x93))
   237  }
   238  
   239  // TODO: Test EntryIcon
   240  
   241  func TestSetupGiteaRoot(t *testing.T) {
   242  	_ = os.Setenv("GITEA_ROOT", "test")
   243  	assert.Equal(t, "test", SetupGiteaRoot())
   244  	_ = os.Setenv("GITEA_ROOT", "")
   245  	assert.NotEqual(t, "test", SetupGiteaRoot())
   246  }
   247  
   248  func TestFormatNumberSI(t *testing.T) {
   249  	assert.Equal(t, "125", FormatNumberSI(int(125)))
   250  	assert.Equal(t, "1.3k", FormatNumberSI(int64(1317)))
   251  	assert.Equal(t, "21.3M", FormatNumberSI(21317675))
   252  	assert.Equal(t, "45.7G", FormatNumberSI(45721317675))
   253  	assert.Equal(t, "", FormatNumberSI("test"))
   254  }