2020-04-05 09:20:50 +03:00
// Copyright 2020 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.
2016-11-06 03:53:11 +03:00
package base
2016-11-07 02:32:32 +03:00
import (
2017-12-03 14:55:13 +03:00
"net/url"
2016-11-07 02:32:32 +03:00
"testing"
2016-11-07 23:13:38 +03:00
2016-11-10 19:24:48 +03:00
"code.gitea.io/gitea/modules/setting"
2017-12-03 14:55:13 +03:00
2016-11-07 23:13:38 +03:00
"github.com/stretchr/testify/assert"
2016-11-07 02:32:32 +03:00
)
2016-11-06 03:53:11 +03:00
func TestEncodeMD5 ( t * testing . T ) {
2016-11-07 23:49:50 +03:00
assert . Equal ( t ,
"3858f62230ac3c915f300c664312c63f" ,
EncodeMD5 ( "foobar" ) ,
)
2016-11-06 03:53:11 +03:00
}
func TestEncodeSha1 ( t * testing . T ) {
2016-11-07 23:49:50 +03:00
assert . Equal ( t ,
"8843d7f92416211de9ebb963ff4ce28125932878" ,
EncodeSha1 ( "foobar" ) ,
)
2016-11-06 03:53:11 +03:00
}
2019-05-04 18:45:34 +03:00
func TestEncodeSha256 ( t * testing . T ) {
assert . Equal ( t ,
"c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2" ,
EncodeSha256 ( "foobar" ) ,
)
}
2016-11-06 03:53:11 +03:00
func TestShortSha ( t * testing . T ) {
2016-11-07 22:28:03 +03:00
assert . Equal ( t , "veryverylo" , ShortSha ( "veryverylong" ) )
2016-11-06 03:53:11 +03:00
}
func TestBasicAuthDecode ( t * testing . T ) {
2016-11-07 22:28:03 +03:00
_ , _ , err := BasicAuthDecode ( "?" )
assert . Equal ( t , "illegal base64 data at input byte 0" , err . Error ( ) )
2016-11-06 03:53:11 +03:00
user , pass , err := BasicAuthDecode ( "Zm9vOmJhcg==" )
2016-11-07 22:28:03 +03:00
assert . NoError ( t , err )
assert . Equal ( t , "foo" , user )
assert . Equal ( t , "bar" , pass )
2016-11-06 03:53:11 +03:00
}
func TestBasicAuthEncode ( t * testing . T ) {
2016-11-07 22:28:03 +03:00
assert . Equal ( t , "Zm9vOmJhcg==" , BasicAuthEncode ( "foo" , "bar" ) )
2016-11-06 03:53:11 +03:00
}
// TODO: Test PBKDF2()
// TODO: Test VerifyTimeLimitCode()
// TODO: Test CreateTimeLimitCode()
func TestHashEmail ( t * testing . T ) {
2016-11-07 23:49:50 +03:00
assert . Equal ( t ,
"d41d8cd98f00b204e9800998ecf8427e" ,
HashEmail ( "" ) ,
)
assert . Equal ( t ,
"353cbad9b58e69c96154ad99f92bedc7" ,
HashEmail ( "gitea@example.com" ) ,
)
2016-11-06 03:53:11 +03:00
}
2017-12-03 14:55:13 +03:00
const gravatarSource = "https://secure.gravatar.com/avatar/"
func disableGravatar ( ) {
2016-11-07 23:13:38 +03:00
setting . EnableFederatedAvatar = false
setting . LibravatarService = nil
setting . DisableGravatar = true
2017-12-03 14:55:13 +03:00
}
2016-11-07 23:13:38 +03:00
2017-12-03 14:55:13 +03:00
func enableGravatar ( t * testing . T ) {
2016-11-07 23:13:38 +03:00
setting . DisableGravatar = false
2017-12-03 14:55:13 +03:00
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 ) ,
)
}
2016-11-07 02:32:32 +03:00
func TestFileSize ( t * testing . T ) {
2019-06-12 22:41:28 +03:00
var size int64 = 512
2020-02-03 22:50:37 +03:00
assert . Equal ( t , "512 B" , FileSize ( size ) )
2019-06-12 22:41:28 +03:00
size *= 1024
2020-02-03 22:50:37 +03:00
assert . Equal ( t , "512 KiB" , FileSize ( size ) )
2019-06-12 22:41:28 +03:00
size *= 1024
2020-02-03 22:50:37 +03:00
assert . Equal ( t , "512 MiB" , FileSize ( size ) )
2019-06-12 22:41:28 +03:00
size *= 1024
2020-02-03 22:50:37 +03:00
assert . Equal ( t , "512 GiB" , FileSize ( size ) )
2019-06-12 22:41:28 +03:00
size *= 1024
2020-02-03 22:50:37 +03:00
assert . Equal ( t , "512 TiB" , FileSize ( size ) )
2019-06-12 22:41:28 +03:00
size *= 1024
2020-02-03 22:50:37 +03:00
assert . Equal ( t , "512 PiB" , FileSize ( size ) )
2019-06-12 22:41:28 +03:00
size *= 4
2020-02-03 22:50:37 +03:00
assert . Equal ( t , "2.0 EiB" , FileSize ( size ) )
2016-11-07 02:32:32 +03:00
}
2016-12-22 11:58:04 +03:00
func TestSubtract ( t * testing . T ) {
toFloat64 := func ( n interface { } ) float64 {
2019-05-28 18:45:54 +03:00
switch v := n . ( type ) {
2016-12-22 11:58:04 +03:00
case int :
2019-05-28 18:45:54 +03:00
return float64 ( v )
2016-12-22 11:58:04 +03:00
case int8 :
2019-05-28 18:45:54 +03:00
return float64 ( v )
2016-12-22 11:58:04 +03:00
case int16 :
2019-05-28 18:45:54 +03:00
return float64 ( v )
2016-12-22 11:58:04 +03:00
case int32 :
2019-05-28 18:45:54 +03:00
return float64 ( v )
2016-12-22 11:58:04 +03:00
case int64 :
2019-05-28 18:45:54 +03:00
return float64 ( v )
2016-12-22 11:58:04 +03:00
case float32 :
2019-05-28 18:45:54 +03:00
return float64 ( v )
2016-12-22 11:58:04 +03:00
case float64 :
2019-05-28 18:45:54 +03:00
return v
2016-12-22 11:58:04 +03:00
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 )
}
}
}
2016-11-07 23:27:14 +03:00
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 ) )
}
2016-11-07 23:37:08 +03:00
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 ) )
}
2016-11-07 23:49:50 +03:00
func TestStringsToInt64s ( t * testing . T ) {
2016-12-22 11:58:04 +03:00
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 } )
2016-11-07 23:49:50 +03:00
2016-12-22 11:58:04 +03:00
_ , err := StringsToInt64s ( [ ] string { "-1" , "a" , "$" } )
assert . Error ( t , err )
2016-11-07 23:49:50 +03:00
}
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 } ) ,
)
}
2016-11-08 00:08:50 +03:00
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 } ) ,
)
}
2016-11-08 00:44:25 +03:00
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 ( '$' ) )
}
2016-11-08 01:15:02 +03:00
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