vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/utils_test.go

   1 package oss
   2
   3 import (
   4         "strings"
   5
   6         . "gopkg.in/check.v1"
   7 )
   8
   9 type OssUtilsSuite struct{}
  10
  11 var _ = Suite(&OssUtilsSuite{})
  12
  13 func (s *OssUtilsSuite) TestUtilsTime(c *C) {
  14         c.Assert(GetNowSec() > 1448597674, Equals, true)
  15         c.Assert(GetNowNanoSec() > 1448597674000000000, Equals, true)
  16         c.Assert(len(GetNowGMT()), Equals, len("Fri, 27 Nov 2015 04:14:34 GMT"))
  17 }
  18
  19 func (s *OssUtilsSuite) TestUtilsSplitFile(c *C) {
  20         localFile := "../sample/BingWallpaper-2015-11-07.jpg"
  21
  22         // Num
  23         parts, err := SplitFileByPartNum(localFile, 4)
  24         c.Assert(err, IsNil)
  25         c.Assert(len(parts), Equals, 4)
  26         testLogger.Println("parts 4:", parts)
  27         for i, part := range parts {
  28                 c.Assert(part.Number, Equals, i+1)
  29                 c.Assert(part.Offset, Equals, int64(i*120512))
  30                 c.Assert(part.Size, Equals, int64(120512))
  31         }
  32
  33         parts, err = SplitFileByPartNum(localFile, 5)
  34         c.Assert(err, IsNil)
  35         c.Assert(len(parts), Equals, 5)
  36         testLogger.Println("parts 5:", parts)
  37         for i, part := range parts {
  38                 c.Assert(part.Number, Equals, i+1)
  39                 c.Assert(part.Offset, Equals, int64(i*96409))
  40         }
  41
  42         _, err = SplitFileByPartNum(localFile, 10001)
  43         c.Assert(err, NotNil)
  44
  45         _, err = SplitFileByPartNum(localFile, 0)
  46         c.Assert(err, NotNil)
  47
  48         _, err = SplitFileByPartNum(localFile, -1)
  49         c.Assert(err, NotNil)
  50
  51         _, err = SplitFileByPartNum("notexist", 1024)
  52         c.Assert(err, NotNil)
  53
  54         // Size
  55         parts, err = SplitFileByPartSize(localFile, 120512)
  56         c.Assert(err, IsNil)
  57         c.Assert(len(parts), Equals, 4)
  58         testLogger.Println("parts 4:", parts)
  59         for i, part := range parts {
  60                 c.Assert(part.Number, Equals, i+1)
  61                 c.Assert(part.Offset, Equals, int64(i*120512))
  62                 c.Assert(part.Size, Equals, int64(120512))
  63         }
  64
  65         parts, err = SplitFileByPartSize(localFile, 96409)
  66         c.Assert(err, IsNil)
  67         c.Assert(len(parts), Equals, 6)
  68         testLogger.Println("parts 6:", parts)
  69         for i, part := range parts {
  70                 c.Assert(part.Number, Equals, i+1)
  71                 c.Assert(part.Offset, Equals, int64(i*96409))
  72         }
  73
  74         _, err = SplitFileByPartSize(localFile, 0)
  75         c.Assert(err, NotNil)
  76
  77         _, err = SplitFileByPartSize(localFile, -1)
  78         c.Assert(err, NotNil)
  79
  80         _, err = SplitFileByPartSize(localFile, 10)
  81         c.Assert(err, NotNil)
  82
  83         _, err = SplitFileByPartSize("noexist", 120512)
  84         c.Assert(err, NotNil)
  85 }
  86
  87 func (s *OssUtilsSuite) TestUtilsFileExt(c *C) {
  88         c.Assert(strings.Contains(TypeByExtension("test.txt"), "text/plain"), Equals, true)
  89         c.Assert(TypeByExtension("test.jpg"), Equals, "image/jpeg")
  90         c.Assert(TypeByExtension("test.pdf"), Equals, "application/pdf")
  91         c.Assert(TypeByExtension("test"), Equals, "")
  92         c.Assert(strings.Contains(TypeByExtension("/root/dir/test.txt"), "text/plain"), Equals, true)
  93         c.Assert(strings.Contains(TypeByExtension("root/dir/test.txt"), "text/plain"), Equals, true)
  94         c.Assert(strings.Contains(TypeByExtension("root\\dir\\test.txt"), "text/plain"), Equals, true)
  95         c.Assert(strings.Contains(TypeByExtension("D:\\work\\dir\\test.txt"), "text/plain"), Equals, true)
  96 }
  97
  98 func (s *OssUtilsSuite) TestGetPartEnd(c *C) {
  99         end := GetPartEnd(3, 10, 3)
 100         c.Assert(end, Equals, int64(5))
 101
 102         end = GetPartEnd(9, 10, 3)
 103         c.Assert(end, Equals, int64(9))
 104
 105         end = GetPartEnd(7, 10, 3)
 106         c.Assert(end, Equals, int64(9))
 107 }
 108
 109 func (s *OssUtilsSuite) TestParseRange(c *C) {
 110         // InvalidRange bytes==M-N
 111         _, err := ParseRange("bytes==M-N")
 112         c.Assert(err, NotNil)
 113         c.Assert(err.Error(), Equals, "InvalidRange bytes==M-N")
 114
 115         // InvalidRange ranges=M-N
 116         _, err = ParseRange("ranges=M-N")
 117         c.Assert(err, NotNil)
 118         c.Assert(err.Error(), Equals, "InvalidRange ranges=M-N")
 119
 120         // InvalidRange ranges=M-N
 121         _, err = ParseRange("bytes=M-N")
 122         c.Assert(err, NotNil)
 123         c.Assert(err.Error(), Equals, "InvalidRange bytes=M-N")
 124
 125         // InvalidRange ranges=M-
 126         _, err = ParseRange("bytes=M-")
 127         c.Assert(err, NotNil)
 128         c.Assert(err.Error(), Equals, "InvalidRange bytes=M-")
 129
 130         // InvalidRange ranges=-N
 131         _, err = ParseRange("bytes=-N")
 132         c.Assert(err, NotNil)
 133         c.Assert(err.Error(), Equals, "InvalidRange bytes=-N")
 134
 135         // InvalidRange ranges=-0
 136         _, err = ParseRange("bytes=-0")
 137         c.Assert(err, NotNil)
 138         c.Assert(err.Error(), Equals, "InvalidRange bytes=-0")
 139
 140         // InvalidRange bytes=1-2-3
 141         _, err = ParseRange("bytes=1-2-3")
 142         c.Assert(err, NotNil)
 143         c.Assert(err.Error(), Equals, "InvalidRange bytes=1-2-3")
 144
 145         // InvalidRange bytes=1-N
 146         _, err = ParseRange("bytes=1-N")
 147         c.Assert(err, NotNil)
 148         c.Assert(err.Error(), Equals, "InvalidRange bytes=1-N")
 149
 150         // Ranges=M-N
 151         ur, err := ParseRange("bytes=1024-4096")
 152         c.Assert(err, IsNil)
 153         c.Assert(ur.Start, Equals, (int64)(1024))
 154         c.Assert(ur.End, Equals, (int64)(4096))
 155         c.Assert(ur.HasStart, Equals, true)
 156         c.Assert(ur.HasEnd, Equals, true)
 157
 158         // Ranges=M-N,X-Y
 159         ur, err = ParseRange("bytes=1024-4096,2048-4096")
 160         c.Assert(err, IsNil)
 161         c.Assert(ur.Start, Equals, (int64)(1024))
 162         c.Assert(ur.End, Equals, (int64)(4096))
 163         c.Assert(ur.HasStart, Equals, true)
 164         c.Assert(ur.HasEnd, Equals, true)
 165
 166         // Ranges=M-
 167         ur, err = ParseRange("bytes=1024-")
 168         c.Assert(err, IsNil)
 169         c.Assert(ur.Start, Equals, (int64)(1024))
 170         c.Assert(ur.End, Equals, (int64)(0))
 171         c.Assert(ur.HasStart, Equals, true)
 172         c.Assert(ur.HasEnd, Equals, false)
 173
 174         // Ranges=-N
 175         ur, err = ParseRange("bytes=-4096")
 176         c.Assert(err, IsNil)
 177         c.Assert(ur.Start, Equals, (int64)(0))
 178         c.Assert(ur.End, Equals, (int64)(4096))
 179         c.Assert(ur.HasStart, Equals, false)
 180         c.Assert(ur.HasEnd, Equals, true)
 181 }
 182
 183 func (s *OssUtilsSuite) TestAdjustRange(c *C) {
 184         // Nil
 185         start, end := AdjustRange(nil, 8192)
 186         c.Assert(start, Equals, (int64)(0))
 187         c.Assert(end, Equals, (int64)(8192))
 188
 189         // 1024-4096
 190         ur := &UnpackedRange{true, true, 1024, 4095}
 191         start, end = AdjustRange(ur, 8192)
 192         c.Assert(start, Equals, (int64)(1024))
 193         c.Assert(end, Equals, (int64)(4096))
 194
 195         // 1024-
 196         ur = &UnpackedRange{true, false, 1024, 4096}
 197         start, end = AdjustRange(ur, 8192)
 198         c.Assert(start, Equals, (int64)(1024))
 199         c.Assert(end, Equals, (int64)(8192))
 200
 201         // -4096
 202         ur = &UnpackedRange{false, true, 1024, 4096}
 203         start, end = AdjustRange(ur, 8192)
 204         c.Assert(start, Equals, (int64)(4096))
 205         c.Assert(end, Equals, (int64)(8192))
 206
 207         // Invalid range 4096-1024
 208         ur = &UnpackedRange{true, true, 4096, 1024}
 209         start, end = AdjustRange(ur, 8192)
 210         c.Assert(start, Equals, (int64)(0))
 211         c.Assert(end, Equals, (int64)(8192))
 212
 213         // Invalid range -1-
 214         ur = &UnpackedRange{true, false, -1, 0}
 215         start, end = AdjustRange(ur, 8192)
 216         c.Assert(start, Equals, (int64)(0))
 217         c.Assert(end, Equals, (int64)(8192))
 218
 219         // Invalid range -9999
 220         ur = &UnpackedRange{false, true, 0, 9999}
 221         start, end = AdjustRange(ur, 8192)
 222         c.Assert(start, Equals, (int64)(0))
 223         c.Assert(end, Equals, (int64)(8192))
 224 }
 225
 226 func (s *OssUtilsSuite) TestUtilCheckBucketName(c *C) {
 227         err := CheckBucketName("a")
 228         c.Assert(err, NotNil)
 229
 230         err = CheckBucketName("a11111111111111111111111111111nbbbbbbbbbbbbbbbbbbbbbbbbbbbqqqqqqqqqqqqqqqqqqqq")
 231         c.Assert(err, NotNil)
 232
 233         err = CheckBucketName("-abcd")
 234         c.Assert(err, NotNil)
 235
 236         err = CheckBucketName("abcd-")
 237         c.Assert(err, NotNil)
 238
 239         err = CheckBucketName("abcD")
 240         c.Assert(err, NotNil)
 241
 242         err = CheckBucketName("abc 1")
 243         c.Assert(err, NotNil)
 244
 245         err = CheckBucketName("abc&1")
 246         c.Assert(err, NotNil)
 247
 248         err = CheckBucketName("abc-1")
 249         c.Assert(err, IsNil)
 250
 251         err = CheckBucketName("1bc-1")
 252         c.Assert(err, IsNil)
 253
 254         err = CheckBucketName("111-1")
 255         c.Assert(err, IsNil)
 256
 257         err = CheckBucketName("abc123-def1")
 258         c.Assert(err, IsNil)
 259 }