2020-04-05 01:20:50 -05:00
// Copyright 2020 The Gitea Authors. All rights reserved.
2022-11-27 13:20:29 -05:00
// SPDX-License-Identifier: MIT
2020-04-05 01:20:50 -05:00
2016-11-06 01:53:11 +01:00
package base
2016-11-07 00:32:32 +01:00
import (
2024-05-20 23:12:50 +08:00
"crypto/sha1"
"fmt"
2016-11-07 00:32:32 +01:00
"testing"
2021-01-28 19:08:11 +01:00
"time"
2016-11-07 21:13:38 +01:00
2024-05-20 23:12:50 +08:00
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/test"
2016-11-07 21:13:38 +01:00
"github.com/stretchr/testify/assert"
2016-11-07 00:32:32 +01:00
)
2016-11-06 01:53:11 +01:00
2019-05-04 11:45:34 -04:00
func TestEncodeSha256 ( t * testing . T ) {
assert . Equal ( t ,
"c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2" ,
EncodeSha256 ( "foobar" ) ,
)
}
2016-11-06 01:53:11 +01:00
func TestShortSha ( t * testing . T ) {
2016-11-07 20:28:03 +01:00
assert . Equal ( t , "veryverylo" , ShortSha ( "veryverylong" ) )
2016-11-06 01:53:11 +01:00
}
func TestBasicAuthDecode ( t * testing . T ) {
2016-11-07 20:28:03 +01:00
_ , _ , err := BasicAuthDecode ( "?" )
assert . Equal ( t , "illegal base64 data at input byte 0" , err . Error ( ) )
2016-11-06 01:53:11 +01:00
user , pass , err := BasicAuthDecode ( "Zm9vOmJhcg==" )
2016-11-07 20:28:03 +01:00
assert . NoError ( t , err )
assert . Equal ( t , "foo" , user )
assert . Equal ( t , "bar" , pass )
2020-12-18 02:51:28 +01:00
_ , _ , err = BasicAuthDecode ( "aW52YWxpZA==" )
assert . Error ( t , err )
_ , _ , err = BasicAuthDecode ( "invalid" )
assert . Error ( t , err )
2024-07-23 14:43:03 +02:00
_ , _ , err = BasicAuthDecode ( "YWxpY2U=" ) // "alice", no colon
assert . Error ( t , err )
2016-11-06 01:53:11 +01:00
}
2021-01-28 19:08:11 +01:00
func TestVerifyTimeLimitCode ( t * testing . T ) {
2024-05-20 23:12:50 +08:00
defer test . MockVariableValue ( & setting . InstallLock , true ) ( )
initGeneralSecret := func ( secret string ) {
setting . InstallLock = true
setting . CfgProvider , _ = setting . NewConfigProviderFromData ( fmt . Sprintf ( `
[ oauth2 ]
JWT_SECRET = % s
` , secret ) )
setting . LoadCommonSettings ( )
2021-01-28 19:08:11 +01:00
}
2024-05-20 23:12:50 +08:00
initGeneralSecret ( "KZb_QLUd4fYVyxetjxC4eZkrBgWM2SndOOWDNtgUUko" )
now := time . Now ( )
t . Run ( "TestGenericParameter" , func ( t * testing . T ) {
time2000 := time . Date ( 2000 , 1 , 2 , 3 , 4 , 5 , 0 , time . Local )
assert . Equal ( t , "2000010203040000026fa5221b2731b7cf80b1b506f5e39e38c115fee5" , CreateTimeLimitCode ( "test-sha1" , 2 , time2000 , sha1 . New ( ) ) )
assert . Equal ( t , "2000010203040000026fa5221b2731b7cf80b1b506f5e39e38c115fee5" , CreateTimeLimitCode ( "test-sha1" , 2 , "200001020304" , sha1 . New ( ) ) )
assert . Equal ( t , "2000010203040000024842227a2f87041ff82025199c0187410a9297bf" , CreateTimeLimitCode ( "test-hmac" , 2 , time2000 , nil ) )
assert . Equal ( t , "2000010203040000024842227a2f87041ff82025199c0187410a9297bf" , CreateTimeLimitCode ( "test-hmac" , 2 , "200001020304" , nil ) )
} )
t . Run ( "TestInvalidCode" , func ( t * testing . T ) {
assert . False ( t , VerifyTimeLimitCode ( now , "data" , 2 , "" ) )
assert . False ( t , VerifyTimeLimitCode ( now , "data" , 2 , "invalid code" ) )
} )
2021-01-28 19:08:11 +01:00
2024-05-20 23:12:50 +08:00
t . Run ( "TestCreateAndVerify" , func ( t * testing . T ) {
code := CreateTimeLimitCode ( "data" , 2 , now , nil )
assert . False ( t , VerifyTimeLimitCode ( now . Add ( - time . Minute ) , "data" , 2 , code ) ) // not started yet
assert . True ( t , VerifyTimeLimitCode ( now , "data" , 2 , code ) )
assert . True ( t , VerifyTimeLimitCode ( now . Add ( time . Minute ) , "data" , 2 , code ) )
assert . False ( t , VerifyTimeLimitCode ( now . Add ( time . Minute ) , "DATA" , 2 , code ) ) // invalid data
assert . False ( t , VerifyTimeLimitCode ( now . Add ( 2 * time . Minute ) , "data" , 2 , code ) ) // expired
} )
2021-01-28 19:08:11 +01:00
2024-05-20 23:12:50 +08:00
t . Run ( "TestDifferentSecret" , func ( t * testing . T ) {
// use another secret to ensure the code is invalid for different secret
verifyDataCode := func ( c string ) bool {
return VerifyTimeLimitCode ( now , "data" , 2 , c )
}
2025-02-03 02:16:56 +08:00
code := CreateTimeLimitCode ( "data" , 2 , now , nil )
assert . True ( t , verifyDataCode ( code ) )
2024-05-20 23:12:50 +08:00
initGeneralSecret ( "000_QLUd4fYVyxetjxC4eZkrBgWM2SndOOWDNtgUUko" )
2025-02-03 02:16:56 +08:00
assert . False ( t , verifyDataCode ( code ) )
2024-05-20 23:12:50 +08:00
} )
2021-01-28 19:08:11 +01:00
}
2016-11-06 01:53:11 +01:00
2016-11-07 00:32:32 +01:00
func TestFileSize ( t * testing . T ) {
2019-06-12 21:41:28 +02:00
var size int64 = 512
2020-02-03 21:50:37 +02:00
assert . Equal ( t , "512 B" , FileSize ( size ) )
2019-06-12 21:41:28 +02:00
size *= 1024
2020-02-03 21:50:37 +02:00
assert . Equal ( t , "512 KiB" , FileSize ( size ) )
2019-06-12 21:41:28 +02:00
size *= 1024
2020-02-03 21:50:37 +02:00
assert . Equal ( t , "512 MiB" , FileSize ( size ) )
2019-06-12 21:41:28 +02:00
size *= 1024
2020-02-03 21:50:37 +02:00
assert . Equal ( t , "512 GiB" , FileSize ( size ) )
2019-06-12 21:41:28 +02:00
size *= 1024
2020-02-03 21:50:37 +02:00
assert . Equal ( t , "512 TiB" , FileSize ( size ) )
2019-06-12 21:41:28 +02:00
size *= 1024
2020-02-03 21:50:37 +02:00
assert . Equal ( t , "512 PiB" , FileSize ( size ) )
2019-06-12 21:41:28 +02:00
size *= 4
2020-02-03 21:50:37 +02:00
assert . Equal ( t , "2.0 EiB" , FileSize ( size ) )
2016-11-07 00:32:32 +01:00
}
2016-11-07 21:49:50 +01:00
func TestStringsToInt64s ( t * testing . T ) {
2016-12-22 03:58:04 -05:00
testSuccess := func ( input [ ] string , expected [ ] int64 ) {
result , err := StringsToInt64s ( input )
assert . NoError ( t , err )
assert . Equal ( t , expected , result )
}
2024-03-21 23:07:35 +08:00
testSuccess ( nil , nil )
2016-12-22 03:58:04 -05:00
testSuccess ( [ ] string { } , [ ] int64 { } )
2024-11-11 04:07:54 +08:00
testSuccess ( [ ] string { "" } , [ ] int64 { } )
2016-12-22 03:58:04 -05:00
testSuccess ( [ ] string { "-1234" } , [ ] int64 { - 1234 } )
2024-03-21 23:07:35 +08:00
testSuccess ( [ ] string { "1" , "4" , "16" , "64" , "256" } , [ ] int64 { 1 , 4 , 16 , 64 , 256 } )
2016-11-07 21:49:50 +01:00
2024-03-21 23:07:35 +08:00
ints , err := StringsToInt64s ( [ ] string { "-1" , "a" } )
2024-12-15 11:41:29 +01:00
assert . Empty ( t , ints )
2016-12-22 03:58:04 -05:00
assert . Error ( t , err )
2016-11-07 21:49:50 +01: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 } ) ,
)
}