tommy/cos-go-sdk-v5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

update bucket inventory/logging/replication/versioning/tagging and test

Browse Source
This commit is contained in:
jojoliang
2019-10-07 14:04:39 +08:00
parent 4e467b3cf6
commit d37fd23cdf
9 changed files with 614 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
bucket_inventory.go
View File

@@ -22,7 +22,6 @@ type BucketInventoryFilter struct {
// BucketInventoryOptionalFields ...
type BucketInventoryOptionalFields struct {
XMLName xml.Name `xml:"OptionalFields,omitempty"`
BucketInventoryFields []string `xml:"Field,omitempty"`
}
@@ -33,12 +32,11 @@ type BucketInventorySchedule struct {
// BucketInventoryEncryption ...
type BucketInventoryEncryption struct {
XMLName xml.Name `xml:"Encryption"`
SSECOS string `xml:"SSE-COS,omitempty"`
SSECOS string `xml:"SSE-COS"`
}
// BucketInventoryDestinationContent ...
type BucketInventoryDestinationContent struct {
// BucketInventoryDestination ...
type BucketInventoryDestination struct {
Bucket string `xml:"Bucket"`
AccountId string `xml:"AccountId,omitempty"`
Prefix string `xml:"Prefix,omitempty"`
@@ -46,12 +44,6 @@ type BucketInventoryDestinationContent struct {
Encryption *BucketInventoryEncryption `xml:"Encryption,omitempty"`
}
// BucketInventoryDestination ...
type BucketInventoryDestination struct {
XMLName xml.Name `xml:"Destination"`
BucketDestination *BucketInventoryDestinationContent `xml:"COSBucketDestination"`
}
// BucketPutInventoryOptions ...
type BucketPutInventoryOptions struct {
XMLName xml.Name `xml:"InventoryConfiguration"`
@@ -61,7 +53,7 @@ type BucketPutInventoryOptions struct {
Filter *BucketInventoryFilter `xml:"Filter,omitempty"`
OptionalFields *BucketInventoryOptionalFields `xml:"OptionalFields,omitempty"`
Schedule *BucketInventorySchedule `xml:"Schedule"`
Destination *BucketInventoryDestination `xml:"Destination"`
Destination *BucketInventoryDestination `xml:"Destination>COSBucketDestination"`
}
// ListBucketInventoryConfigResult result of ListBucketInventoryConfiguration
@@ -74,7 +66,7 @@ type ListBucketInventoryConfigResult struct {
}
// PutBucketInventory https://cloud.tencent.com/document/product/436/33707
func (s *BucketService) PutBucketInventoryTest(ctx context.Context, id string, opt *BucketPutInventoryOptions) (*Response, error) {
func (s *BucketService) PutInventory(ctx context.Context, id string, opt *BucketPutInventoryOptions) (*Response, error) {
u := fmt.Sprintf("/?inventory&id=%s", id)
sendOpt := sendOptions{
baseURL: s.client.BaseURL.BucketURL,
@@ -88,7 +80,7 @@ func (s *BucketService) PutBucketInventoryTest(ctx context.Context, id string, o
}
// GetBucketInventory https://cloud.tencent.com/document/product/436/33705
func (s *BucketService) GetBucketInventoryTest(ctx context.Context, id string) (*BucketGetInventoryResult, *Response, error) {
func (s *BucketService) GetInventory(ctx context.Context, id string) (*BucketGetInventoryResult, *Response, error) {
u := fmt.Sprintf("/?inventory&id=%s", id)
var res BucketGetInventoryResult
sendOpt := sendOptions{
@@ -102,7 +94,7 @@ func (s *BucketService) GetBucketInventoryTest(ctx context.Context, id string) (
}
// DeleteBucketInventory https://cloud.tencent.com/document/product/436/33704
func (s *BucketService) DeleteBucketInventoryTest(ctx context.Context, id string) (*Response, error) {
func (s *BucketService) DeleteInventory(ctx context.Context, id string) (*Response, error) {
u := fmt.Sprintf("/?inventory&id=%s", id)
sendOpt := sendOptions{
baseURL: s.client.BaseURL.BucketURL,
@@ -114,7 +106,7 @@ func (s *BucketService) DeleteBucketInventoryTest(ctx context.Context, id string
}
// ListBucketInventoryConfigurations https://cloud.tencent.com/document/product/436/33706
func (s *BucketService) ListBucketInventoryConfigurationsTest(ctx context.Context, token string) (*ListBucketInventoryConfigResult, *Response, error) {
func (s *BucketService) ListInventoryConfigurations(ctx context.Context, token string) (*ListBucketInventoryConfigResult, *Response, error) {
var res ListBucketInventoryConfigResult
var u string
if token == "" {

292
bucket_inventory_test.go Normal file
View File

@@ -0,0 +1,292 @@
package cos
import (
"context"
"encoding/xml"
"fmt"
"net/http"
"reflect"
"testing"
)
func TestBucketService_PutInventory(t *testing.T) {
setup()
defer teardown()
opt := &BucketPutInventoryOptions{
XMLName: xml.Name{Local: "InventoryConfiguration"},
ID: "list1",
IsEnabled: "True",
IncludedObjectVersions: "All",
Filter: &BucketInventoryFilter{"myPrefix"},
Schedule: &BucketInventorySchedule{"Daily"},
Destination: &BucketInventoryDestination{
Bucket: "qcs::cos:ap-guangzhou::examplebucket-1250000000",
AccountId: "100000000001",
Prefix: "list1",
Format: "CSV",
Encryption: &BucketInventoryEncryption{},
},
OptionalFields: &BucketInventoryOptionalFields{
BucketInventoryFields: []string{
"Size",
"LastModifiedDate",
"ETag",
"StorageClass",
"IsMultipartUploaded",
"ReplicationStatus",
},
},
}
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut)
vs := values{
"inventory": "",
"id": "list1",
}
testFormValues(t, r, vs)
body := &BucketPutInventoryOptions{}
xml.NewDecoder(r.Body).Decode(body)
want := opt
if !reflect.DeepEqual(want, body) {
t.Fatalf("Bucket.PutInventory request\n body: %+v\n, want %+v\n", body, want)
}
})
_, err := client.Bucket.PutInventory(context.Background(), "list1", opt)
if err != nil {
t.Fatalf("Bucket.PutInventory failed, error: %v", err)
}
}
func TestBucketService_GetInventory(t *testing.T) {
setup()
defer teardown()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodGet)
vs := values{
"inventory": "",
"id": "list1",
}
testFormValues(t, r, vs)
fmt.Fprint(w, `<InventoryConfiguration>
<Id>list1</Id>
<IsEnabled>True</IsEnabled>
<Destination>
<COSBucketDestination>
<Format>CSV</Format>
<Bucket>qcs::cos:ap-guangzhou::examplebucket-1250000000</Bucket>
<Prefix>list1</Prefix>
<AccountId>100000000001</AccountId>
</COSBucketDestination>
</Destination>
<Schedule>
<Frequency>Daily</Frequency>
</Schedule>
<Filter>
<Prefix>myPrefix</Prefix>
</Filter>
<IncludedObjectVersions>All</IncludedObjectVersions>
<OptionalFields>
<Field>Size</Field>
<Field>LastModifiedDate</Field>
<Field>ETag</Field>
<Field>StorageClass</Field>
<Field>IsMultipartUploaded</Field>
<Field>ReplicationStatus</Field>
</OptionalFields>
</InventoryConfiguration>`)
})
res, _, err := client.Bucket.GetInventory(context.Background(), "list1")
if err != nil {
t.Fatalf("Bucket.GetInventory failed, error: %v", err)
}
want := &BucketGetInventoryResult{
XMLName: xml.Name{Local: "InventoryConfiguration"},
ID: "list1",
IsEnabled: "True",
IncludedObjectVersions: "All",
Filter: &BucketInventoryFilter{"myPrefix"},
Schedule: &BucketInventorySchedule{"Daily"},
Destination: &BucketInventoryDestination{
Bucket: "qcs::cos:ap-guangzhou::examplebucket-1250000000",
AccountId: "100000000001",
Prefix: "list1",
Format: "CSV",
},
OptionalFields: &BucketInventoryOptionalFields{
BucketInventoryFields: []string{
"Size",
"LastModifiedDate",
"ETag",
"StorageClass",
"IsMultipartUploaded",
"ReplicationStatus",
},
},
}
if !reflect.DeepEqual(res, want) {
t.Errorf("Bucket.GetInventory returned\n%+v, want\n%+v", res, want)
}
}
func TestBucketService_ListInventory(t *testing.T) {
setup()
defer teardown()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodGet)
vs := values{
"inventory": "",
}
testFormValues(t, r, vs)
fmt.Fprint(w, `<ListInventoryConfigurationResult>
<InventoryConfiguration>
<Id>list1</Id>
<IsEnabled>True</IsEnabled>
<Destination>
<COSBucketDestination>
<Format>CSV</Format>
<AccountId>1250000000</AccountId>
<Bucket>qcs::cos:ap-beijing::examplebucket-1250000000</Bucket>
<Prefix>list1</Prefix>
<Encryption>
<SSE-COS/>
</Encryption>
</COSBucketDestination>
</Destination>
<Schedule>
<Frequency>Daily</Frequency>
</Schedule>
<Filter>
<Prefix>myPrefix</Prefix>
</Filter>
<IncludedObjectVersions>All</IncludedObjectVersions>
<OptionalFields>
<Field>Size</Field>
<Field>LastModifiedDate</Field>
<Field>ETag</Field>
<Field>StorageClass</Field>
<Field>IsMultipartUpload</Field>
<Field>ReplicationStatus</Field>
</OptionalFields>
</InventoryConfiguration>
<InventoryConfiguration>
<Id>list2</Id>
<IsEnabled>True</IsEnabled>
<Destination>
<COSBucketDestination>
<Format>CSV</Format>
<AccountId>1250000000</AccountId>
<Bucket>qcs::cos:ap-beijing::examplebucket-1250000000</Bucket>
<Prefix>list2</Prefix>
</COSBucketDestination>
</Destination>
<Schedule>
<Frequency>Weekly</Frequency>
</Schedule>
<Filter>
<Prefix>myPrefix2</Prefix>
</Filter>
<IncludedObjectVersions>All</IncludedObjectVersions>
<OptionalFields>
<Field>Size</Field>
<Field>LastModifiedDate</Field>
<Field>ETag</Field>
<Field>StorageClass</Field>
</OptionalFields>
</InventoryConfiguration>
<IsTruncated>false</IsTruncated>
<ContinuationToken>...</ContinuationToken>
<IsTruncated>true</IsTruncated>
<NextContinuationToken>1ueSDFASDF1Tr/XDAFdadEADadf2J/wm36Hy4vbOwM=</NextContinuationToken>
</ListInventoryConfigurationResult>`)
})
res, _, err := client.Bucket.ListInventoryConfigurations(context.Background(), "")
if err != nil {
t.Fatalf("Bucket.ListInventory failed, error: %v", err)
}
want := &ListBucketInventoryConfigResult{
XMLName: xml.Name{Local: "ListInventoryConfigurationResult"},
IsTruncated: true,
ContinuationToken: "...",
NextContinuationToken: "1ueSDFASDF1Tr/XDAFdadEADadf2J/wm36Hy4vbOwM=",
InventoryConfigurations: []BucketListInventoryConfiguartion{
BucketListInventoryConfiguartion{
XMLName: xml.Name{Local: "InventoryConfiguration"},
ID: "list1",
IsEnabled: "True",
IncludedObjectVersions: "All",
Filter: &BucketInventoryFilter{"myPrefix"},
Schedule: &BucketInventorySchedule{"Daily"},
Destination: &BucketInventoryDestination{
Bucket: "qcs::cos:ap-beijing::examplebucket-1250000000",
AccountId: "1250000000",
Prefix: "list1",
Format: "CSV",
Encryption: &BucketInventoryEncryption{},
},
OptionalFields: &BucketInventoryOptionalFields{
BucketInventoryFields: []string{
"Size",
"LastModifiedDate",
"ETag",
"StorageClass",
"IsMultipartUpload",
"ReplicationStatus",
},
},
},
BucketListInventoryConfiguartion{
XMLName: xml.Name{Local: "InventoryConfiguration"},
ID: "list2",
IsEnabled: "True",
IncludedObjectVersions: "All",
Filter: &BucketInventoryFilter{"myPrefix2"},
Schedule: &BucketInventorySchedule{"Weekly"},
Destination: &BucketInventoryDestination{
Bucket: "qcs::cos:ap-beijing::examplebucket-1250000000",
AccountId: "1250000000",
Prefix: "list2",
Format: "CSV",
},
OptionalFields: &BucketInventoryOptionalFields{
BucketInventoryFields: []string{
"Size",
"LastModifiedDate",
"ETag",
"StorageClass",
},
},
},
},
}
if !reflect.DeepEqual(res, want) {
t.Fatalf("Bucket.ListInventory failed, \nwant: %+v\nres: %+v", want, res)
}
}
func TestBucketService_DeleteInventory(t *testing.T) {
setup()
defer teardown()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodDelete)
vs := values{
"inventory": "",
"id": "list1",
}
testFormValues(t, r, vs)
w.WriteHeader(http.StatusNoContent)
})
_, err := client.Bucket.DeleteInventory(context.Background(), "list1")
if err != nil {
t.Fatalf("Bucket.DeleteInventory returned error: %v", err)
}
}

11
bucket_logging.go
View File

@@ -17,17 +17,14 @@ type BucketLoggingEnabled struct {
// BucketPutLoggingOptions is the options of PutBucketLogging
type BucketPutLoggingOptions struct {
XMLName xml.Name `xml:"BucketLoggingStatus"`
LoggingEnabled *BucketLoggingEnabled `xml:"LoggingEnabled"`
LoggingEnabled *BucketLoggingEnabled `xml:"LoggingEnabled,omitempty"`
}
// BucketGetLoggingResult is the result of GetBucketLogging
type BucketGetLoggingResult struct {
XMLName xml.Name `xml:"BucketLoggingStatus"`
LoggingEnabled *BucketLoggingEnabled `xml:"LoggingEnabled"`
}
type BucketGetLoggingResult BucketPutLoggingOptions
// PutBucketLogging https://cloud.tencent.com/document/product/436/17054
func (s *BucketService) PutBucketLoggingTest(ctx context.Context, opt *BucketPutLoggingOptions) (*Response, error) {
func (s *BucketService) PutLogging(ctx context.Context, opt *BucketPutLoggingOptions) (*Response, error) {
sendOpt := sendOptions{
baseURL: s.client.BaseURL.BucketURL,
uri: "/?logging",
@@ -39,7 +36,7 @@ func (s *BucketService) PutBucketLoggingTest(ctx context.Context, opt *BucketPut
}
// GetBucketLogging https://cloud.tencent.com/document/product/436/17053
func (s *BucketService) GetBucketLoggingTest(ctx context.Context) (*BucketGetLoggingResult, *Response, error) {
func (s *BucketService) GetLogging(ctx context.Context) (*BucketGetLoggingResult, *Response, error) {
var res BucketGetLoggingResult
sendOpt := sendOptions{
baseURL: s.client.BaseURL.BucketURL,

75
bucket_logging_test.go Normal file
View File

@@ -0,0 +1,75 @@
package cos
import (
"context"
"encoding/xml"
"fmt"
"net/http"
"reflect"
"testing"
)
func TestBucketService_PutLogging(t *testing.T) {
setup()
defer teardown()
opt := &BucketPutLoggingOptions{
LoggingEnabled: &BucketLoggingEnabled{
TargetBucket: "logs",
},
}
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut)
vs := values{
"logging": "",
}
testFormValues(t, r, vs)
body := &BucketPutLoggingOptions{}
xml.NewDecoder(r.Body).Decode(body)
want := opt
want.XMLName = xml.Name{Local: "BucketLoggingStatus"}
if !reflect.DeepEqual(want, body) {
t.Fatalf("Bucket.PutLogging request\n body: %+v\n, want %+v\n", body, want)
}
})
_, err := client.Bucket.PutLogging(context.Background(), opt)
if err != nil {
t.Fatalf("Bucket.PutLogging failed, error: %v", err)
}
}
func TestBucketService_GetLogging(t *testing.T) {
setup()
defer teardown()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodGet)
vs := values{
"logging": "",
}
testFormValues(t, r, vs)
fmt.Fprint(w, `<BucketLoggingStatus>
<LoggingEnabled>
<TargetBucket>logs</TargetBucket>
<TargetPrefix>mylogs</TargetPrefix>
</LoggingEnabled>
</BucketLoggingStatus>`)
})
res, _, err := client.Bucket.GetLogging(context.Background())
if err != nil {
t.Fatalf("Bucket.GetLogging failed, error: %v", err)
}
want := &BucketGetLoggingResult{
XMLName: xml.Name{Local: "BucketLoggingStatus"},
LoggingEnabled: &BucketLoggingEnabled{
TargetBucket: "logs",
TargetPrefix: "mylogs",
},
}
if !reflect.DeepEqual(res, want) {
t.Errorf("Bucket.GetLogging returned\n%+v, want\n%+v", res, want)
}
}

6
bucket_replication.go
View File

@@ -28,11 +28,7 @@ type PutBucketReplicationOptions struct {
}
// GetBucketReplicationResult is the result of GetBucketReplication
type GetBucketReplicationResult struct {
XMLName xml.Name `xml:"ReplicationConfiguration"`
Role string `xml:"Role"`
Rule []BucketReplicationRule `xml:"Rule"`
}
type GetBucketReplicationResult PutBucketReplicationOptions
// PutBucketReplication https://cloud.tencent.com/document/product/436/19223
func (s *BucketService) PutBucketReplication(ctx context.Context, opt *PutBucketReplicationOptions) (*Response, error) {

115
bucket_replication_test.go Normal file
View File

@@ -0,0 +1,115 @@
package cos
import (
"context"
"encoding/xml"
"fmt"
"net/http"
"reflect"
"testing"
)
func TestBucketService_PutReplication(t *testing.T) {
setup()
defer teardown()
opt := &PutBucketReplicationOptions{
Role: "qcs::cam::uin/100000000001:uin/100000000001",
Rule: []BucketReplicationRule{
{
Status: "Disabled",
Prefix: "prefix",
Destination: &ReplicationDestination{
Bucket: "qcs::cos:ap-beijing-1::examplebucket-1250000000",
},
},
},
}
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut)
vs := values{
"replication": "",
}
testFormValues(t, r, vs)
body := &PutBucketReplicationOptions{}
xml.NewDecoder(r.Body).Decode(body)
want := opt
want.XMLName = xml.Name{Local: "ReplicationConfiguration"}
if !reflect.DeepEqual(want, body) {
t.Fatalf("Bucket.PutReplication request\n body: %+v\n, want %+v\n", body, want)
}
})
_, err := client.Bucket.PutBucketReplication(context.Background(), opt)
if err != nil {
t.Fatalf("Bucket.PutLogging failed, error: %v", err)
}
}
func TestBucketService_GetReplication(t *testing.T) {
setup()
defer teardown()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodGet)
vs := values{
"replication": "",
}
testFormValues(t, r, vs)
fmt.Fprint(w, `<ReplicationConfiguration>
<Role>qcs::cam::uin/100000000001:uin/100000000001</Role>
<Rule>
<Status>Disabled</Status>
<ID></ID>
<Prefix>prefix</Prefix>
<Destination>
<Bucket>qcs::cos:ap-beijing-1::examplebucket-1250000000</Bucket>
</Destination>
</Rule>
</ReplicationConfiguration>`)
})
res, _, err := client.Bucket.GetBucketReplication(context.Background())
if err != nil {
t.Fatalf("Bucket.GetReplication failed, error: %v", err)
}
want := &GetBucketReplicationResult{
XMLName: xml.Name{Local: "ReplicationConfiguration"},
Role: "qcs::cam::uin/100000000001:uin/100000000001",
Rule: []BucketReplicationRule{
{
Status: "Disabled",
Prefix: "prefix",
Destination: &ReplicationDestination{
Bucket: "qcs::cos:ap-beijing-1::examplebucket-1250000000",
},
},
},
}
if !reflect.DeepEqual(res, want) {
t.Errorf("Bucket.GetBucketReplication\nres %+v\nwant %+v", res.Rule[0].Destination, want.Rule[0].Destination)
t.Errorf("Bucket.GetBucketReplication\nres %+v\nwant %+v", res, want)
}
}
func TestBucketService_DeleteReplication(t *testing.T) {
setup()
defer teardown()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodDelete)
vs := values{
"replication": "",
}
testFormValues(t, r, vs)
w.WriteHeader(http.StatusNoContent)
})
_, err := client.Bucket.DeleteBucketReplication(context.Background())
if err != nil {
t.Fatalf("Bucket.DeleteBucketReplication returned error: %v", err)
}
}

5
bucket_version.go
View File

@@ -13,10 +13,7 @@ type BucketPutVersionOptions struct {
}
// BucketGetVersionResult is the result of GetBucketVersioning
type BucketGetVersionResult struct {
XMLName xml.Name `xml:"VersioningConfiguration"`
Status string `xml:"Status"`
}
type BucketGetVersionResult BucketPutVersionOptions
// PutVersion https://cloud.tencent.com/document/product/436/19889
// Status has Suspended\Enabled

67
bucket_version_test.go Normal file
View File

@@ -0,0 +1,67 @@
package cos
import (
"context"
"encoding/xml"
"fmt"
"net/http"
"reflect"
"testing"
)
func TestBucketService_PutVersioning(t *testing.T) {
setup()
defer teardown()
opt := &BucketPutVersionOptions{
Status: "Suspended",
}
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut)
vs := values{
"versioning": "",
}
testFormValues(t, r, vs)
body := &BucketPutVersionOptions{}
xml.NewDecoder(r.Body).Decode(body)
want := opt
want.XMLName = xml.Name{Local: "VersioningConfiguration"}
if !reflect.DeepEqual(want, body) {
t.Fatalf("Bucket.PutVersioning request\nbody: %+v\nwant %+v\n", body, want)
}
})
_, err := client.Bucket.PutVersioning(context.Background(), opt)
if err != nil {
t.Fatalf("Bucket.PutVersioning failed, error: %v", err)
}
}
func TestBucketService_GetVersioning(t *testing.T) {
setup()
defer teardown()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodGet)
vs := values{
"versioning": "",
}
testFormValues(t, r, vs)
fmt.Fprint(w, `<VersioningConfiguration>
<Status>Suspended</Status>
</VersioningConfiguration>`)
})
res, _, err := client.Bucket.GetVersioning(context.Background())
if err != nil {
t.Fatalf("Bucket.GetVersioning failed, error: %v", err)
}
want := &BucketGetVersionResult{
XMLName: xml.Name{Local: "VersioningConfiguration"},
Status: "Suspended",
}
if !reflect.DeepEqual(res, want) {
t.Errorf("Bucket.GetVersioning returned\n%+v, want\n%+v", res, want)
}
}

72
costesting/ci_test.go
View File

@@ -44,6 +44,16 @@ type CosTestSuite struct {
SepFileName string
}
// replace
const (
//uin
kUin = "100010805041"
//Replication Target Region,
kRepRegion = "ap-chengdu"
//Replication Target Bucket, Version management needs to be turned on beforehand
kRepBucket = "cosgosdkreptest"
)
func (s *CosTestSuite) SetupSuite() {
fmt.Println("Set up test")
// init
@@ -52,7 +62,7 @@ func (s *CosTestSuite) SetupSuite() {
// CI client for test interface
// URL like this http://test-1253846586.cos.ap-guangzhou.myqcloud.com
u := "http://cosgosdktest-1251668577.cos.ap-guangzhou.myqcloud.com"
u := "https://cosgosdktest-1259654469.cos.ap-guangzhou.myqcloud.com"
// Get the region
iu, _ := url.Parse(u)
@@ -199,7 +209,7 @@ func (s *CosTestSuite) TestVersionAndReplication() {
repOpt := &cos.PutBucketReplicationOptions{
// qcs::cam::uin/[UIN]:uin/[Subaccount]
Role: "qcs::cam::uin/2779643970:uin/2779643970",
Role: "qcs::cam::uin/" + kUin + ":uin/" + kUin,
Rule: []cos.BucketReplicationRule{
{
ID: "1",
@@ -207,7 +217,7 @@ func (s *CosTestSuite) TestVersionAndReplication() {
Status: "Enabled",
Destination: &cos.ReplicationDestination{
// qcs::cos:[Region]::[Bucketname-Appid]
Bucket: "qcs::cos:ap-beijing::alanbj-1251668577",
Bucket: "qcs::cos:" + kRepRegion + "::" + kRepBucket + "-" + s.Appid,
},
},
},
@@ -219,7 +229,7 @@ func (s *CosTestSuite) TestVersionAndReplication() {
assert.Nil(s.T(), err, "GetBucketReplication Failed")
for _, r := range vr.Rule {
assert.Equal(s.T(), "Enabled", r.Status, "Get Wrong Version status")
assert.Equal(s.T(), "qcs::cos:ap-beijing::alanbj-1251668577", r.Destination.Bucket, "Get Wrong Version status")
assert.Equal(s.T(), "qcs::cos:"+kRepRegion+"::"+kRepBucket+"-"+s.Appid, r.Destination.Bucket, "Get Wrong Version status")
}
_, err = s.Client.Bucket.DeleteBucketReplication(context.Background())
@@ -228,6 +238,7 @@ func (s *CosTestSuite) TestVersionAndReplication() {
func (s *CosTestSuite) TestBucketInventory() {
id := "test1"
dBucket := "qcs::cos:" + s.Region + "::" + s.Bucket + "-" + s.Appid
opt := &cos.BucketPutInventoryOptions{
ID: id,
// True or False
@@ -246,38 +257,57 @@ func (s *CosTestSuite) TestBucketInventory() {
Frequency: "Daily",
},
Destination: &cos.BucketInventoryDestination{
BucketDestination: &cos.BucketInventoryDestinationContent{
Bucket: "qcs::cos:ap-guangzhou::alangz-1251668577",
Format: "CSV",
},
Bucket: dBucket,
Format: "CSV",
},
}
_, err := s.Client.Bucket.PutBucketInventoryTest(context.Background(), id, opt)
_, err := s.Client.Bucket.PutInventory(context.Background(), id, opt)
assert.Nil(s.T(), err, "PutBucketInventory Failed")
v, _, err := s.Client.Bucket.GetBucketInventoryTest(context.Background(), id)
v, _, err := s.Client.Bucket.GetInventory(context.Background(), id)
assert.Nil(s.T(), err, "GetBucketInventory Failed")
assert.Equal(s.T(), "test1", v.ID, "Get Wrong inventory id")
assert.Equal(s.T(), "true", v.IsEnabled, "Get Wrong inventory isenabled")
assert.Equal(s.T(), "qcs::cos:ap-guangzhou::alangz-1251668577", v.Destination.BucketDestination.Bucket, "Get Wrong inventory isenabled")
assert.Equal(s.T(), dBucket, v.Destination.Bucket, "Get Wrong inventory isenabled")
_, err = s.Client.Bucket.DeleteBucketInventoryTest(context.Background(), id)
_, err = s.Client.Bucket.DeleteInventory(context.Background(), id)
assert.Nil(s.T(), err, "DeleteBucketInventory Failed")
}
func (s *CosTestSuite) TestBucketLogging() {
tBucket := s.Bucket + "-" + s.Appid
opt := &cos.BucketPutLoggingOptions{
LoggingEnabled: &cos.BucketLoggingEnabled{
// The bucket must same region.
TargetBucket: "alangz-1251668577",
TargetBucket: tBucket,
},
}
_, err := s.Client.Bucket.PutBucketLoggingTest(context.Background(), opt)
assert.Nil(s.T(), err, "PutBucketLogging Failed")
v, _, err := s.Client.Bucket.GetBucketLoggingTest(context.Background())
assert.Nil(s.T(), err, "GetBucketLogging Failed")
assert.Equal(s.T(), "alangz-1251668577", v.LoggingEnabled.TargetBucket, "Get Wrong Version status")
_, err := s.Client.Bucket.PutLogging(context.Background(), opt)
assert.Nil(s.T(), err, "PutLogging Failed")
v, _, err := s.Client.Bucket.GetLogging(context.Background())
assert.Nil(s.T(), err, "GetLogging Failed")
assert.Equal(s.T(), tBucket, v.LoggingEnabled.TargetBucket, "Get Wrong Version status")
}
func (s *CosTestSuite) TestBucketTagging() {
opt := &cos.BucketPutTaggingOptions{
TagSet: []cos.BucketTaggingTag{
{
Key: "testk1",
Value: "testv1",
},
{
Key: "testk2",
Value: "testv2",
},
},
}
_, err := s.Client.Bucket.PutTagging(context.Background(), opt)
assert.Nil(s.T(), err, "Put Tagging Failed")
v, _, err := s.Client.Bucket.GetTagging(context.Background())
assert.Nil(s.T(), err, "Get Tagging Failed")
assert.Equal(s.T(), v.TagSet[0].Key, opt.TagSet[0].Key, "Get Wrong Tag key")
assert.Equal(s.T(), v.TagSet[0].Value, opt.TagSet[0].Value, "Get Wrong Tag value")
assert.Equal(s.T(), v.TagSet[1].Key, opt.TagSet[1].Key, "Get Wrong Tag key")
assert.Equal(s.T(), v.TagSet[1].Value, opt.TagSet[1].Value, "Get Wrong Tag value")
}
func (s *CosTestSuite) TestPutGetDeleteLifeCycle() {
@@ -491,7 +521,7 @@ func (s *CosTestSuite) TestPutObjectRestore() {
}
func (s *CosTestSuite) TestCopyObject() {
u := "http://gosdkcopytest-" + s.Appid + ".cos.ap-beijing-1.myqcloud.com"
u := "http://" + kRepBucket + "-" + s.Appid + ".cos." + kRepRegion + ".myqcloud.com"
iu, _ := url.Parse(u)
ib := &cos.BaseURL{BucketURL: iu}
c := cos.NewClient(ib, &http.Client{