aliyun-sdk 0.4.1 → 0.7.2

data/lib/aliyun/sts/client.rb

@@ -25,7 +25,7 @@ module Aliyun
       # @param role [String] the role arn
       # @param session [String] the session name
       # @param policy [STS::Policy] the policy
-      # @param duration [Fixnum] the duration seconds for the
+      # @param duration [Integer] the duration seconds for the
       #  requested token
       # @return [STS::Token] the sts token
       def assume_role(role, session, policy = nil, duration = 3600)

data/lib/aliyun/sts/protocol.rb

@@ -27,7 +27,7 @@ module Aliyun
       # @param role [String] the role arn
       # @param session [String] the session name
       # @param policy [STS::Policy] the policy
-      # @param duration [Fixnum] the duration seconds for the
+      # @param duration [Integer] the duration seconds for the
       #  requested token
       # @return [STS::Token] the sts token
       def assume_role(role, session, policy = nil, duration = 3600)
@@ -88,14 +88,14 @@ module Aliyun
           :method => 'POST',
           :url => @config.endpoint || ENDPOINT,
           :payload => query
-        ) do |response, request, result, &blk|
+        ) do |response, &blk|
 
           if response.code >= 300
             e = ServerError.new(response)
             logger.error(e.to_s)
             raise e
           else
-            response.return!(request, result, &blk)
+            response.return!(&blk)
           end
         end
 

data/lib/aliyun/version.rb

@@ -2,6 +2,6 @@
 
 module Aliyun
 
-    VERSION = "0.4.1"
+    VERSION = "0.7.2"
 
 end # Aliyun

data/spec/aliyun/oss/bucket_spec.rb

@@ -89,7 +89,7 @@ module Aliyun
             if opts.enabled?
               xml.LoggingEnabled {
                 xml.TargetBucket opts.target_bucket
-                xml.TargetPrefix opts.target_prefix
+                xml.TargetPrefix opts.target_prefix if opts.target_prefix
               }
             end
           }
@@ -356,7 +356,7 @@ module Aliyun
 
       context "acl, logging, website, referer, lifecycle" do
         it "should update acl" do
-          query = {'acl' => ''}
+          query = {'acl' => nil}
           stub_request(:put, request_path).with(:query => query)
 
           @protocol.put_bucket_acl(@bucket, ACL::PUBLIC_READ)
@@ -366,7 +366,7 @@ module Aliyun
         end
 
         it "should get acl" do
-          query = {'acl' => ''}
+          query = {'acl' => nil}
           return_acl = ACL::PUBLIC_READ
           stub_request(:get, request_path)
             .with(:query => query)
@@ -380,7 +380,7 @@ module Aliyun
         end
 
         it "should enable logging" do
-          query = {'logging' => ''}
+          query = {'logging' => nil}
           stub_request(:put, request_path).with(:query => query)
 
           logging_opts = BucketLogging.new(
@@ -392,8 +392,21 @@ module Aliyun
             .with(:query => query, :body => mock_logging(logging_opts))
         end
 
+        it "should enable logging without target prefix" do
+          query = {'logging' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          logging_opts = BucketLogging.new(
+            :enable => true,
+            :target_bucket => 'target-bucket')
+          @protocol.put_bucket_logging(@bucket, logging_opts)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:query => query, :body => mock_logging(logging_opts))
+        end
+
         it "should disable logging" do
-          query = {'logging' => ''}
+          query = {'logging' => nil}
           stub_request(:put, request_path).with(:query => query)
 
           logging_opts = BucketLogging.new(:enable => false)
@@ -404,7 +417,7 @@ module Aliyun
         end
 
         it "should get logging" do
-          query = {'logging' => ''}
+          query = {'logging' => nil}
           logging_opts = BucketLogging.new(
             :enable => true,
             :target_bucket => 'target-bucket', :target_prefix => 'foo')
@@ -420,8 +433,25 @@ module Aliyun
           expect(logging.to_s).to eq(logging_opts.to_s)
         end
 
+        it "should get logging without target-bucket" do
+          query = {'logging' => nil}
+          logging_opts = BucketLogging.new(
+            :enable => false,
+            :target_bucket => nil, :target_prefix => nil)
+
+          stub_request(:get, request_path)
+            .with(:query => query)
+            .to_return(:body => mock_logging(logging_opts))
+
+          logging = @protocol.get_bucket_logging(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:query => query, :body => nil)
+          expect(logging.to_s).to eq(logging_opts.to_s)
+        end
+
         it "should delete logging" do
-          query = {'logging' => ''}
+          query = {'logging' => nil}
           stub_request(:delete, request_path).with(:query => query)
 
           @protocol.delete_bucket_logging(@bucket)
@@ -430,8 +460,20 @@ module Aliyun
             .with(:query => query, :body => nil)
         end
 
+        it "should raise Exception when enable logging" do
+          query = {'logging' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          logging_opts = BucketLogging.new(
+            :enable => true,
+            :target_bucket => nil, :target_prefix => nil)
+          expect {
+            @protocol.put_bucket_logging(@bucket, logging_opts)
+          }.to raise_error(ClientError)
+        end
+
         it "should update website" do
-          query = {'website' => ''}
+          query = {'website' => nil}
           stub_request(:put, request_path).with(:query => query)
 
           website_opts = BucketWebsite.new(
@@ -442,8 +484,20 @@ module Aliyun
             .with(:query => query, :body => mock_website(website_opts))
         end
 
+        it "should update website with index only" do
+          query = {'website' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          website_opts = BucketWebsite.new(
+            :enable => true, :index => 'index.html', :error => nil)
+          @protocol.put_bucket_website(@bucket, website_opts)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:query => query, :body => mock_website(website_opts))
+        end
+
         it "should get website" do
-          query = {'website' => ''}
+          query = {'website' => nil}
           website_opts = BucketWebsite.new(
             :enable => true, :index => 'index.html', :error => 'error.html')
 
@@ -459,7 +513,7 @@ module Aliyun
         end
 
         it "should delete website" do
-          query = {'website' => ''}
+          query = {'website' => nil}
           stub_request(:delete, request_path).with(:query => query)
 
           @protocol.delete_bucket_website(@bucket)
@@ -468,8 +522,20 @@ module Aliyun
             .with(:query => query, :body => nil)
         end
 
+        it "should raise Exception when update website" do
+          query = {'website' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          website_opts = BucketWebsite.new(
+            :enable => true, :index => nil)
+
+          expect {
+            @protocol.put_bucket_website(@bucket, website_opts)
+          }.to raise_error(ClientError)
+        end
+
         it "should update referer" do
-          query = {'referer' => ''}
+          query = {'referer' => nil}
           stub_request(:put, request_path).with(:query => query)
 
           referer_opts = BucketReferer.new(
@@ -481,7 +547,7 @@ module Aliyun
         end
 
         it "should get referer" do
-          query = {'referer' => ''}
+          query = {'referer' => nil}
           referer_opts = BucketReferer.new(
             :allow_empty => true, :whitelist => ['xxx', 'yyy'])
 
@@ -497,7 +563,7 @@ module Aliyun
         end
 
         it "should update lifecycle" do
-          query = {'lifecycle' => ''}
+          query = {'lifecycle' => nil}
           stub_request(:put, request_path).with(:query => query)
 
           rules = (1..5).map do |i|
@@ -513,7 +579,7 @@ module Aliyun
         end
 
         it "should get lifecycle" do
-          query = {'lifecycle' => ''}
+          query = {'lifecycle' => nil}
           return_rules = (1..5).map do |i|
             LifeCycleRule.new(
               :id => i, :enable => i % 2 == 0, :prefix => "foo#{i}",
@@ -532,7 +598,7 @@ module Aliyun
         end
 
         it "should delete lifecycle" do
-          query = {'lifecycle' => ''}
+          query = {'lifecycle' => nil}
           stub_request(:delete, request_path).with(:query => query)
 
           @protocol.delete_bucket_lifecycle(@bucket)
@@ -541,8 +607,46 @@ module Aliyun
             .with(:query => query, :body => nil)
         end
 
+        it "should raise Exception when update lifecycle " do
+          query = {'lifecycle' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          rules = (1..5).map do |i|
+            LifeCycleRule.new(
+              :id => i, :enable => i % 2 == 0, :prefix => "foo#{i}",
+              :expiry => 'invalid')
+          end
+ 
+          expect {
+            @protocol.put_bucket_lifecycle(@bucket, rules)
+          }.to raise_error(ClientError)
+        end        
+
+        it "should raise Exception when get lifecycle " do
+          query = {'lifecycle' => nil}
+          body = '<LifecycleConfiguration>
+                    <Rule>
+                      <ID>delete after one day</ID>
+                      <Prefix>logs/</Prefix>
+                      <Status>Enabled</Status>
+                      <Expiration>
+                        <Days>1</Days>
+                        <Date>2017-01-01T00:00:00.000Z</Date>
+                      </Expiration>
+                  </Rule>
+                </LifecycleConfiguration>'
+
+          stub_request(:get, request_path)
+            .with(:query => query)
+            .to_return(:body => body)
+ 
+          expect {
+            rules = @protocol.get_bucket_lifecycle(@bucket)
+          }.to raise_error(ClientError)
+        end        
+
         it "should set cors" do
-          query = {'cors' => ''}
+          query = {'cors' => nil}
           stub_request(:put, request_path).with(:query => query)
 
           rules = (1..5).map do |i|
@@ -558,8 +662,26 @@ module Aliyun
             .with(:query => query, :body => mock_cors(rules))
         end
 
+        it "should set cors with MaxAgeSeconds " do
+          query = {'cors' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          rules = (1..5).map do |i|
+            CORSRule.new(
+              :allowed_origins => (1..3).map {|x| "origin-#{x}"},
+              :allowed_methods => ['PUT', 'GET'],
+              :allowed_headers => (1..3).map {|x| "header-#{x}"},
+              :expose_headers => (1..3).map {|x| "header-#{x}"},
+              :max_age_seconds => 5)
+          end
+          @protocol.set_bucket_cors(@bucket, rules)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:query => query, :body => mock_cors(rules))
+        end
+
         it "should get cors" do
-          query = {'cors' => ''}
+          query = {'cors' => nil}
           return_rules = (1..5).map do |i|
             CORSRule.new(
               :allowed_origins => (1..3).map {|x| "origin-#{x}"},
@@ -580,7 +702,7 @@ module Aliyun
         end
 
         it "should delete cors" do
-          query = {'cors' => ''}
+          query = {'cors' => nil}
 
           stub_request(:delete, request_path).with(:query => query)
 
@@ -591,6 +713,60 @@ module Aliyun
 
       end # acl, logging, cors, etc
 
+      context "crc" do
+        it "should download crc enable equal config setting" do
+          protocol = Protocol.new(
+                      Config.new(:endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :download_crc_enable => 'true'))
+          expect(protocol.download_crc_enable).to eq(true)
+
+          protocol = Protocol.new(
+                      Config.new(:endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :download_crc_enable => true))
+          expect(protocol.download_crc_enable).to eq(true)
+
+          protocol = Protocol.new(
+                      Config.new(:endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :download_crc_enable => 'false'))
+          expect(protocol.download_crc_enable).to eq(false)
+
+          protocol = Protocol.new(
+                      Config.new(:endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :download_crc_enable => false))
+          expect(protocol.download_crc_enable).to eq(false)
+        end
+
+        it "should upload crc enable equal config setting" do
+          protocol = Protocol.new(
+                      Config.new(:endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :upload_crc_enable => 'true'))
+          expect(protocol.upload_crc_enable).to eq(true)
+
+          protocol = Protocol.new(
+                      Config.new(:endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :upload_crc_enable => true))
+          expect(protocol.upload_crc_enable).to eq(true)
+
+          protocol = Protocol.new(
+                      Config.new(:endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :upload_crc_enable => 'false'))
+          expect(protocol.upload_crc_enable).to eq(false)
+
+          protocol = Protocol.new(
+                      Config.new(:endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :upload_crc_enable => false))
+          expect(protocol.upload_crc_enable).to eq(false)
+        end
+      end # crc
+
     end # Bucket
 
   end # OSS

data/spec/aliyun/oss/client/bucket_spec.rb

@@ -120,7 +120,7 @@ module Aliyun
 
       context "bucket operations" do
         it "should get acl" do
-          query = {'acl' => ''}
+          query = {'acl' => nil}
           return_acl = ACL::PUBLIC_READ
 
           stub_request(:get, bucket_url)
@@ -135,7 +135,7 @@ module Aliyun
         end
 
         it "should set acl" do
-          query = {'acl' => ''}
+          query = {'acl' => nil}
 
           stub_request(:put, bucket_url).with(:query => query)
 
@@ -146,7 +146,7 @@ module Aliyun
         end
 
         it "should delete logging setting" do
-          query = {'logging' => ''}
+          query = {'logging' => nil}
 
           stub_request(:delete, bucket_url).with(:query => query)
 
@@ -156,6 +156,226 @@ module Aliyun
             .with(:query => query, :body => nil)
         end
 
+        it "should set logging setting" do
+          query = {'logging' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.BucketLoggingStatus {
+              xml.LoggingEnabled {
+                xml.TargetBucket 'target-bucket'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url).with(:query => query)
+
+          @bucket.logging = BucketLogging.new(:enable => true, :target_bucket => 'target-bucket')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+        it "should get logging setting" do
+          query = {'logging' => nil}
+
+          retbody = Nokogiri::XML::Builder.new do |xml|
+            xml.BucketLoggingStatus {
+              xml.LoggingEnabled {
+                xml.TargetBucket 'target-bucket'
+                xml.TargetPrefix 'target-prefix'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => retbody)
+
+          logging = @bucket.logging
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+          expect(logging.enable).to eq(true)
+          expect(logging.target_bucket).to eq('target-bucket')
+
+        end
+
+        it "should set webseit" do
+          query = {'website' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.WebsiteConfiguration {
+              xml.IndexDocument {
+                xml.Suffix 'index.html'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.website = BucketWebsite.new(:enable => true, :index => 'index.html')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+        it "should delete webseit" do
+          query = {'website' => nil}
+
+          stub_request(:delete, bucket_url)
+            .with(:query => query)
+            .to_return(status: 204, :body => nil)
+
+          @bucket.website = BucketWebsite.new(:enable => false)
+
+          expect(WebMock).to have_requested(:delete, bucket_url)
+            .with(:query => query, :body => nil)
+        end
+
+        it "should get webseit" do
+          query = {'website' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.WebsiteConfiguration {
+              xml.IndexDocument {
+                xml.Suffix 'index.html'
+              }
+              xml.ErrorDocument {
+                xml.Key 'error.html'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          website = @bucket.website
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+
+          expect(website.enable).to eq(true)
+          expect(website.index).to eq('index.html')
+          expect(website.error).to eq('error.html')
+        end
+
+        it "should set referer" do
+          query = {'referer' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.RefererConfiguration {
+              xml.AllowEmptyReferer 'true'
+              xml.RefererList {
+                xml.Referer 'http://www.aliyun.com'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.referer = BucketReferer.new(:allow_empty => true, :whitelist => ['http://www.aliyun.com'])
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+        it "should get referer" do
+          query = {'referer' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.RefererConfiguration {
+              xml.AllowEmptyReferer 'true'
+              xml.RefererList {
+                xml.Referer 'http://www.aliyun.com'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          referer = @bucket.referer
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+
+          expect(referer.allow_empty).to eq(true)
+          expect(referer.whitelist).to eq(['http://www.aliyun.com'])
+        end
+
+        it "should set cors" do
+          query = {'cors' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.CORSConfiguration {
+              xml.CORSRule {
+                xml.AllowedOrigin '*'
+                xml.AllowedMethod 'PUT'
+                xml.AllowedHeader 'Authorization'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          rules = [
+            CORSRule.new(
+              :allowed_origins => ['*'],
+              :allowed_methods => ['PUT'],
+              :allowed_headers => ['Authorization'],
+              :expose_headers =>[])
+          ]
+
+          @bucket.cors = rules
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+        it "should delete cors" do
+          query = {'cors' => nil}
+
+          stub_request(:delete, bucket_url)
+            .with(:query => query)
+            .to_return(status: 204, :body => nil)
+
+          @bucket.cors = []
+
+          expect(WebMock).to have_requested(:delete, bucket_url)
+            .with(:query => query, :body => nil)
+        end
+
+        it "should get cors" do
+          query = {'cors' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.CORSConfiguration {
+              xml.CORSRule {
+                xml.AllowedOrigin '*'
+                xml.AllowedMethod 'PUT'
+                xml.AllowedHeader 'Authorization'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          cors = @bucket.cors
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+        end
+
         it "should get bucket url" do
           expect(@bucket.bucket_url)
             .to eq('http://rubysdk-bucket.oss-cn-hangzhou.aliyuncs.com/')
@@ -303,7 +523,7 @@ module Aliyun
 
         it "should set custom headers when append object" do
           key = 'ruby'
-          query = {'append' => '', 'position' => 11}
+          query = {'append' => nil, 'position' => 11}
           stub_request(:post, object_url(key)).with(:query => query)
 
           @bucket.append_object(
@@ -362,7 +582,7 @@ module Aliyun
 
         it "should append object from file" do
           key = 'ruby'
-          query = {'append' => '', 'position' => 11}
+          query = {'append' => nil, 'position' => 11}
           stub_request(:post, object_url(key)).with(:query => query)
 
           content = (1..10).map{ |i| i.to_s.rjust(9, '0') }.join("\n")
@@ -378,7 +598,7 @@ module Aliyun
 
         it "should append object with acl" do
           key = 'ruby'
-          query = {'append' => '', 'position' => 11}
+          query = {'append' => nil, 'position' => 11}
           stub_request(:post, object_url(key)).with(:query => query)
 
           @bucket.append_object(key, 11, :acl => ACL::PUBLIC_READ_WRITE)
@@ -467,29 +687,55 @@ module Aliyun
           expect(signature).to eq(sig)
         end
 
-        it "should get object url with STS" do
-          sts_bucket = Client.new(
-            :endpoint => @endpoint,
-            :access_key_id => 'xxx',
-            :access_key_secret => 'yyy',
-            :sts_token => 'zzz').get_bucket(@bucket_name)
-
-          object_url = 'http://rubysdk-bucket.oss-cn-hangzhou.aliyuncs.com/yeah'
-
-          url = sts_bucket.object_url('yeah')
-          path = url[0, url.index('?')]
-          expect(path).to eq(object_url)
-
-          query = {}
-          url[url.index('?') + 1, url.size].split('&')
-            .each { |s| k, v = s.split('='); query[k] = v }
-
-          expect(query.key?('Expires')).to be true
-          expect(query.key?('Signature')).to be true
-          expect(query['OSSAccessKeyId']).to eq('xxx')
-          expect(query['security-token']).to eq('zzz')
+        context 'should use STS' do
+          it "get object url" do
+            sts_bucket = Client.new(
+              :endpoint => @endpoint,
+              :access_key_id => 'xxx',
+              :access_key_secret => 'yyy',
+              :sts_token => 'zzz').get_bucket(@bucket_name)
+
+            object_url = 'http://rubysdk-bucket.oss-cn-hangzhou.aliyuncs.com/yeah'
+
+            url = sts_bucket.object_url('yeah')
+            path = url[0, url.index('?')]
+            expect(path).to eq(object_url)
+
+            query = {}
+            url[url.index('?') + 1, url.size].split('&')
+              .each { |s| k, v = s.split('='); query[k] = v }
+
+            expect(query.key?('Expires')).to be true
+            expect(query.key?('Signature')).to be true
+            expect(query['OSSAccessKeyId']).to eq('xxx')
+            expect(query['security-token']).to eq('zzz')
+          end
+
+          it "get object url with query string" do
+            sts_bucket = Client.new(
+              :endpoint => @endpoint,
+              :access_key_id => 'xxx',
+              :access_key_secret => 'yyy',
+              :sts_token => 'zzz').get_bucket(@bucket_name)
+
+            param = {
+              'x-oss-process' => 'image/resize,m_fill,h_100,w_100',
+            }  
+            url = sts_bucket.object_url('ico.png', true, 60, param)
+            path = url[0, url.index('?')]
+            expect(path).to eq('http://rubysdk-bucket.oss-cn-hangzhou.aliyuncs.com/ico.png')
+
+            query = {}
+            url[url.index('?') + 1, url.size].split('&')
+              .each { |s| k, v = s.split('='); query[k] = v }
+
+            expect(query.key?('Expires')).to be true
+            expect(query.key?('Signature')).to be true
+            expect(query['OSSAccessKeyId']).to eq('xxx')
+            expect(query['security-token']).to eq('zzz')
+            expect(query['x-oss-process']).to eq('image%2Fresize%2Cm_fill%2Ch_100%2Cw_100')
+          end
         end
-
       end # object operations
 
       context "multipart operations" do
@@ -497,7 +743,7 @@ module Aliyun
           query_1 = {
             :prefix => 'list-',
             'encoding-type' => 'url',
-            'uploads' => ''
+            'uploads' => nil
           }
           return_up_1 = (1..5).map{ |i| Multipart::Transaction.new(
             :id => "txn-#{i}",
@@ -513,7 +759,7 @@ module Aliyun
             :prefix => 'list-',
             'upload-id-marker' => 'txn-5',
             'encoding-type' => 'url',
-            'uploads' => ''
+            'uploads' => nil
           }
           return_up_2 = (6..8).map{ |i| Multipart::Transaction.new(
             :id => "txn-#{i}",
@@ -549,6 +795,72 @@ module Aliyun
         end
       end # multipart operations
 
+      context "crc" do
+        it "should download crc enable equal config setting" do
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :download_crc_enable => 'true').get_bucket(@bucket_name)
+          expect(bucket.download_crc_enable).to eq(true)
+
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :download_crc_enable => true).get_bucket(@bucket_name)
+          expect(bucket.download_crc_enable).to eq(true)
+
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :download_crc_enable => 'false').get_bucket(@bucket_name)
+          expect(bucket.download_crc_enable).to eq(false)
+
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :download_crc_enable => false).get_bucket(@bucket_name)
+          expect(bucket.download_crc_enable).to eq(false)
+
+          # check default value
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy').get_bucket(@bucket_name)
+          expect(bucket.download_crc_enable).to eq(false)
+        end
+
+        it "should upload crc enable equal config setting" do
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :upload_crc_enable => 'true').get_bucket(@bucket_name)
+          expect(bucket.upload_crc_enable).to eq(true)
+
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :upload_crc_enable => true).get_bucket(@bucket_name)
+          expect(bucket.upload_crc_enable).to eq(true)
+
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :upload_crc_enable => 'false').get_bucket(@bucket_name)
+          expect(bucket.upload_crc_enable).to eq(false)
+
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy',
+                      :upload_crc_enable => false).get_bucket(@bucket_name)
+          expect(bucket.upload_crc_enable).to eq(false)
+
+          # check default value
+          bucket = Client.new(
+                      :endpoint => @endpoint,
+                      :access_key_id => 'xxx', :access_key_secret => 'yyy').get_bucket(@bucket_name)
+          expect(bucket.upload_crc_enable).to eq(true)
+        end
+      end # crc
+
     end # Bucket
   end # OSS
 end # Aliyun