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

   1 package oss
   2
   3 import (
   4         "net/url"
   5         "sort"
   6
   7         . "gopkg.in/check.v1"
   8 )
   9
  10 type OssTypeSuite struct{}
  11
  12 var _ = Suite(&OssTypeSuite{})
  13
  14 var (
  15         goStr     = "go go + go <> go"
  16         chnStr    = "试问闲情几许"
  17         goURLStr  = url.QueryEscape(goStr)
  18         chnURLStr = url.QueryEscape(chnStr)
  19 )
  20
  21 func (s *OssTypeSuite) TestDecodeDeleteObjectsResult(c *C) {
  22         var res DeleteObjectVersionsResult
  23         err := decodeDeleteObjectsResult(&res)
  24         c.Assert(err, IsNil)
  25
  26         res.DeletedObjectsDetail = []DeletedKeyInfo{DeletedKeyInfo{Key: ""}}
  27         err = decodeDeleteObjectsResult(&res)
  28         c.Assert(err, IsNil)
  29         c.Assert(res.DeletedObjectsDetail[0].Key, Equals, "")
  30
  31         res.DeletedObjectsDetail = []DeletedKeyInfo{DeletedKeyInfo{Key: goURLStr}, DeletedKeyInfo{Key: chnURLStr}}
  32         err = decodeDeleteObjectsResult(&res)
  33         c.Assert(err, IsNil)
  34         c.Assert(res.DeletedObjectsDetail[0].Key, Equals, goStr)
  35         c.Assert(res.DeletedObjectsDetail[1].Key, Equals, chnStr)
  36 }
  37
  38 func (s *OssTypeSuite) TestDecodeListObjectsResult(c *C) {
  39         var res ListObjectsResult
  40         err := decodeListObjectsResult(&res)
  41         c.Assert(err, IsNil)
  42
  43         res = ListObjectsResult{}
  44         err = decodeListObjectsResult(&res)
  45         c.Assert(err, IsNil)
  46
  47         res = ListObjectsResult{Prefix: goURLStr, Marker: goURLStr,
  48                 Delimiter: goURLStr, NextMarker: goURLStr,
  49                 Objects:        []ObjectProperties{{Key: chnURLStr}},
  50                 CommonPrefixes: []string{chnURLStr}}
  51
  52         err = decodeListObjectsResult(&res)
  53         c.Assert(err, IsNil)
  54
  55         c.Assert(res.Prefix, Equals, goStr)
  56         c.Assert(res.Marker, Equals, goStr)
  57         c.Assert(res.Delimiter, Equals, goStr)
  58         c.Assert(res.NextMarker, Equals, goStr)
  59         c.Assert(res.Objects[0].Key, Equals, chnStr)
  60         c.Assert(res.CommonPrefixes[0], Equals, chnStr)
  61 }
  62
  63 func (s *OssTypeSuite) TestDecodeListMultipartUploadResult(c *C) {
  64         res := ListMultipartUploadResult{}
  65         err := decodeListMultipartUploadResult(&res)
  66         c.Assert(err, IsNil)
  67
  68         res = ListMultipartUploadResult{Prefix: goURLStr, KeyMarker: goURLStr,
  69                 Delimiter: goURLStr, NextKeyMarker: goURLStr,
  70                 Uploads: []UncompletedUpload{{Key: chnURLStr}}}
  71
  72         err = decodeListMultipartUploadResult(&res)
  73         c.Assert(err, IsNil)
  74
  75         c.Assert(res.Prefix, Equals, goStr)
  76         c.Assert(res.KeyMarker, Equals, goStr)
  77         c.Assert(res.Delimiter, Equals, goStr)
  78         c.Assert(res.NextKeyMarker, Equals, goStr)
  79         c.Assert(res.Uploads[0].Key, Equals, chnStr)
  80 }
  81
  82 func (s *OssTypeSuite) TestSortUploadPart(c *C) {
  83         parts := []UploadPart{}
  84
  85         sort.Sort(UploadParts(parts))
  86         c.Assert(len(parts), Equals, 0)
  87
  88         parts = []UploadPart{
  89                 {PartNumber: 5, ETag: "E5"},
  90                 {PartNumber: 1, ETag: "E1"},
  91                 {PartNumber: 4, ETag: "E4"},
  92                 {PartNumber: 2, ETag: "E2"},
  93                 {PartNumber: 3, ETag: "E3"},
  94         }
  95
  96         sort.Sort(UploadParts(parts))
  97
  98         c.Assert(parts[0].PartNumber, Equals, 1)
  99         c.Assert(parts[0].ETag, Equals, "E1")
 100         c.Assert(parts[1].PartNumber, Equals, 2)
 101         c.Assert(parts[1].ETag, Equals, "E2")
 102         c.Assert(parts[2].PartNumber, Equals, 3)
 103         c.Assert(parts[2].ETag, Equals, "E3")
 104         c.Assert(parts[3].PartNumber, Equals, 4)
 105         c.Assert(parts[3].ETag, Equals, "E4")
 106         c.Assert(parts[4].PartNumber, Equals, 5)
 107         c.Assert(parts[4].ETag, Equals, "E5")
 108 }
 109
 110 func (s *OssTypeSuite) TestValidateLifecleRules(c *C) {
 111         expiration := LifecycleExpiration{
 112                 Days:              30,
 113                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 114         }
 115         rule := LifecycleRule{
 116                 ID:         "ruleID",
 117                 Prefix:     "prefix",
 118                 Status:     "Enabled",
 119                 Expiration: &expiration,
 120         }
 121         rules := []LifecycleRule{rule}
 122         err := verifyLifecycleRules(rules)
 123         c.Assert(err, IsNil)
 124
 125         expiration = LifecycleExpiration{
 126                 Date:              "2015-11-11T00:00:00.000Z",
 127                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 128         }
 129         rule = LifecycleRule{
 130                 ID:         "ruleID",
 131                 Prefix:     "prefix",
 132                 Status:     "Enabled",
 133                 Expiration: &expiration,
 134         }
 135         rules = []LifecycleRule{rule}
 136         err = verifyLifecycleRules(rules)
 137         c.Assert(err, IsNil)
 138
 139         expiration = LifecycleExpiration{
 140                 Days:              0,
 141                 CreatedBeforeDate: "",
 142                 Date:              "",
 143         }
 144         rule = LifecycleRule{
 145                 ID:         "ruleID",
 146                 Prefix:     "prefix",
 147                 Status:     "Enabled",
 148                 Expiration: &expiration,
 149         }
 150         rules = []LifecycleRule{rule}
 151         err = verifyLifecycleRules(rules)
 152         c.Assert(err, IsNil)
 153
 154         abortMPU := LifecycleAbortMultipartUpload{
 155                 Days:              30,
 156                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 157         }
 158         rule = LifecycleRule{
 159                 ID:                   "ruleID",
 160                 Prefix:               "prefix",
 161                 Status:               "Enabled",
 162                 AbortMultipartUpload: &abortMPU,
 163         }
 164         rules = []LifecycleRule{rule}
 165         err = verifyLifecycleRules(rules)
 166         c.Assert(err, NotNil)
 167
 168         abortMPU = LifecycleAbortMultipartUpload{
 169                 Days:              0,
 170                 CreatedBeforeDate: "",
 171         }
 172         rule = LifecycleRule{
 173                 ID:                   "ruleID",
 174                 Prefix:               "prefix",
 175                 Status:               "Enabled",
 176                 AbortMultipartUpload: &abortMPU,
 177         }
 178         rules = []LifecycleRule{rule}
 179         err = verifyLifecycleRules(rules)
 180         c.Assert(err, NotNil)
 181
 182         transition := LifecycleTransition{
 183                 Days:              30,
 184                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 185                 StorageClass:      StorageIA,
 186         }
 187         rule = LifecycleRule{
 188                 ID:          "ruleID",
 189                 Prefix:      "prefix",
 190                 Status:      "Enabled",
 191                 Transitions: []LifecycleTransition{transition},
 192         }
 193         rules = []LifecycleRule{rule}
 194         err = verifyLifecycleRules(rules)
 195         c.Assert(err, NotNil)
 196
 197         transition = LifecycleTransition{
 198                 Days:              0,
 199                 CreatedBeforeDate: "",
 200                 StorageClass:      StorageIA,
 201         }
 202         rule = LifecycleRule{
 203                 ID:          "ruleID",
 204                 Prefix:      "prefix",
 205                 Status:      "Enabled",
 206                 Transitions: []LifecycleTransition{transition},
 207         }
 208         rules = []LifecycleRule{rule}
 209         err = verifyLifecycleRules(rules)
 210         c.Assert(err, NotNil)
 211
 212         transition = LifecycleTransition{
 213                 Days:         30,
 214                 StorageClass: StorageStandard,
 215         }
 216         rule = LifecycleRule{
 217                 ID:          "ruleID",
 218                 Prefix:      "prefix",
 219                 Status:      "Enabled",
 220                 Transitions: []LifecycleTransition{transition},
 221         }
 222         rules = []LifecycleRule{rule}
 223         err = verifyLifecycleRules(rules)
 224         c.Assert(err, IsNil)
 225
 226         transition = LifecycleTransition{
 227                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 228                 StorageClass:      StorageStandard,
 229         }
 230         rule = LifecycleRule{
 231                 ID:          "ruleID",
 232                 Prefix:      "prefix",
 233                 Status:      "Enabled",
 234                 Transitions: []LifecycleTransition{transition},
 235         }
 236         rules = []LifecycleRule{rule}
 237         err = verifyLifecycleRules(rules)
 238         c.Assert(err, IsNil)
 239
 240         transition1 := LifecycleTransition{
 241                 Days:         30,
 242                 StorageClass: StorageIA,
 243         }
 244         transition2 := LifecycleTransition{
 245                 Days:         60,
 246                 StorageClass: StorageArchive,
 247         }
 248         transition3 := LifecycleTransition{
 249                 Days:         100,
 250                 StorageClass: StorageArchive,
 251         }
 252         rule = LifecycleRule{
 253                 ID:          "ruleID",
 254                 Prefix:      "prefix",
 255                 Status:      "Enabled",
 256                 Transitions: []LifecycleTransition{transition1, transition2, transition3},
 257         }
 258         rules = []LifecycleRule{rule}
 259         err = verifyLifecycleRules(rules)
 260         c.Assert(err, IsNil)
 261
 262         rule = LifecycleRule{
 263                 ID:     "ruleID",
 264                 Prefix: "prefix",
 265                 Status: "Enabled",
 266         }
 267         rules = []LifecycleRule{rule}
 268         err = verifyLifecycleRules(rules)
 269         c.Assert(err, IsNil)
 270
 271         rules = []LifecycleRule{}
 272         err1 := verifyLifecycleRules(rules)
 273         c.Assert(err1, NotNil)
 274
 275         expiration = LifecycleExpiration{
 276                 Days: 30,
 277         }
 278         rule = LifecycleRule{
 279                 ID:         "ruleID",
 280                 Prefix:     "prefix",
 281                 Status:     "Enabled",
 282                 Expiration: &expiration,
 283         }
 284         rules = []LifecycleRule{rule}
 285         err = verifyLifecycleRules(rules)
 286         c.Assert(err, IsNil)
 287
 288         expiration = LifecycleExpiration{
 289                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 290         }
 291         rule = LifecycleRule{
 292                 ID:         "ruleID",
 293                 Prefix:     "prefix",
 294                 Status:     "Enabled",
 295                 Expiration: &expiration,
 296         }
 297         rules = []LifecycleRule{rule}
 298         err = verifyLifecycleRules(rules)
 299         c.Assert(err, IsNil)
 300
 301         abortMPU = LifecycleAbortMultipartUpload{
 302                 Days: 30,
 303         }
 304         rule = LifecycleRule{
 305                 ID:                   "ruleID",
 306                 Prefix:               "prefix",
 307                 Status:               "Enabled",
 308                 AbortMultipartUpload: &abortMPU,
 309         }
 310         rules = []LifecycleRule{rule}
 311         err = verifyLifecycleRules(rules)
 312         c.Assert(err, IsNil)
 313
 314         abortMPU = LifecycleAbortMultipartUpload{
 315                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 316         }
 317         rule = LifecycleRule{
 318                 ID:                   "ruleID",
 319                 Prefix:               "prefix",
 320                 Status:               "Enabled",
 321                 AbortMultipartUpload: &abortMPU,
 322         }
 323         rules = []LifecycleRule{rule}
 324         err = verifyLifecycleRules(rules)
 325         c.Assert(err, IsNil)
 326
 327         expiration = LifecycleExpiration{
 328                 Days: 30,
 329         }
 330         abortMPU = LifecycleAbortMultipartUpload{
 331                 Days: 30,
 332         }
 333         rule = LifecycleRule{
 334                 ID:                   "ruleID",
 335                 Prefix:               "prefix",
 336                 Status:               "Enabled",
 337                 Expiration:           &expiration,
 338                 AbortMultipartUpload: &abortMPU,
 339         }
 340         rules = []LifecycleRule{rule}
 341         err = verifyLifecycleRules(rules)
 342         c.Assert(err, IsNil)
 343
 344         expiration = LifecycleExpiration{
 345                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 346         }
 347         abortMPU = LifecycleAbortMultipartUpload{
 348                 Days: 30,
 349         }
 350         transition = LifecycleTransition{
 351                 Days:         30,
 352                 StorageClass: StorageIA,
 353         }
 354         rule = LifecycleRule{
 355                 ID:                   "ruleID",
 356                 Prefix:               "prefix",
 357                 Status:               "Enabled",
 358                 Expiration:           &expiration,
 359                 AbortMultipartUpload: &abortMPU,
 360                 Transitions:          []LifecycleTransition{transition},
 361         }
 362         rules = []LifecycleRule{rule}
 363         err = verifyLifecycleRules(rules)
 364         c.Assert(err, IsNil)
 365
 366         expiration = LifecycleExpiration{
 367                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 368         }
 369         abortMPU = LifecycleAbortMultipartUpload{
 370                 Days: 30,
 371         }
 372         transition1 = LifecycleTransition{
 373                 Days:         30,
 374                 StorageClass: StorageIA,
 375         }
 376         transition2 = LifecycleTransition{
 377                 Days:         60,
 378                 StorageClass: StorageArchive,
 379         }
 380         rule = LifecycleRule{
 381                 ID:                   "ruleID",
 382                 Prefix:               "prefix",
 383                 Status:               "Enabled",
 384                 Expiration:           &expiration,
 385                 AbortMultipartUpload: &abortMPU,
 386                 Transitions:          []LifecycleTransition{transition1, transition2},
 387         }
 388         rules = []LifecycleRule{rule}
 389         err = verifyLifecycleRules(rules)
 390         c.Assert(err, IsNil)
 391 }