aliyun-sdk 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aea256f156d30bf7e84ed0f6a2cd0670b63c02fe1fc6a6f9641e479dc2dfcbf5
-  data.tar.gz: 1344db0e4aa351fc9065779ef80297857a57e48fdf5d41527dd5ce3cb62c17cb
+  metadata.gz: 9ed62a6f5a59df2499c7fd4028b4aecfad8506018ef7a3425b1c7627e0f8ddc8
+  data.tar.gz: eb47336dccf3d526466e6cbf5fbf3a845c4f9b8be5d34a5b7f7a55cd6b87f693
 SHA512:
-  metadata.gz: 53387168b68b6b209f8a2c83e7704c0b0fa5bc02cb7dcd384c19bfe357eece672a5e9b2e566e2da261d1133d5a99280455e74eb71ef3aa09158659948b3fb2bf
-  data.tar.gz: 93615f26a714a0daf08cfe18addd2fc25bc5e1d028ec53ab8302f6aeabd4e4b05dc59f254cc823faeba2d846f0b0b8e5a74736fc9348ee1ee6d88366b100cc84
+  metadata.gz: 4ee2ee99edbc2d8adbaa2d5dcf1cc2b661ee5430af90b8f5f95f6e4c7508fc878b4d83bc93c03d52efa8ea90796448e04992475ec8decc1756b886139d72c01a
+  data.tar.gz: 20d032b6e0c0537d2b6fbcc8d94aaba85e666c643a495bf2093418d731c5655c665a46523b17d11c9361edf683db418a9000e435e98afdaf53f4588a8c7bc794

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## Change Log
 
+### v0.8.0 / 2020-08-17
+
+- add bucket encryption
+- add bucket versioning
+- add env parameter to set default log level
+
+### v0.7.3 / 2020-06-28
+
+- add variable control log output path
+
+
+### v0.7.2 / 2020-06-05
+
+- add env parameter to descide whether output log file
+
 ### v0.7.1 / 2019-11-16
 
 - add the validity check of bucket name

data/lib/aliyun/common/logging.rb

@@ -11,7 +11,6 @@ module Aliyun
     #   logger.info(xxx)
     module Logging
 
-      DEFAULT_LOG_FILE = "./aliyun_sdk.log"
       MAX_NUM_LOG = 100
       ROTATE_SIZE = 10 * 1024 * 1024
 
@@ -34,13 +33,31 @@ module Aliyun
 
       def self.logger
         unless @logger
+          # Environment parameter ALIYUN_OSS_SDK_LOG_PATH used to set output log to a file,do not output log if not set
+          @log_file ||= ENV["ALIYUN_OSS_SDK_LOG_PATH"]
           @logger = Logger.new(
-            @log_file ||= DEFAULT_LOG_FILE, MAX_NUM_LOG, ROTATE_SIZE)
-          @logger.level = Logger::INFO
+              @log_file, MAX_NUM_LOG, ROTATE_SIZE)
+          @logger.level = get_env_log_level || Logger::INFO
         end
         @logger
       end
 
+      def self.get_env_log_level
+        return unless ENV["ALIYUN_OSS_SDK_LOG_LEVEL"]
+        case ENV["ALIYUN_OSS_SDK_LOG_LEVEL"].upcase
+        when "DEBUG"
+          Logger::DEBUG
+        when "WARN"
+          Logger::WARN
+        when "ERROR"
+          Logger::ERROR
+        when "FATAL"
+          Logger::FATAL
+        when "UNKNOWN"
+          Logger::UNKNOWN
+        end
+      end
+
     end # logging
   end # Common
 end # Aliyun

data/lib/aliyun/oss/bucket.rb

@@ -47,6 +47,34 @@ module Aliyun
         end
       end
 
+      # 获取Bucket的versioning配置
+      # @return [BucketVersioning] Bucket的versioning配置
+      def versioning
+        @protocol.get_bucket_versioning(name)
+      end
+
+      # 设置Bucket的versioning配置
+      # @param versioning [BucketVersioning] versioning配置
+      def versioning=(versioning)
+          @protocol.put_bucket_versioning(name, versioning)
+      end
+
+      # 获取Bucket的encryption配置
+      # @return [BucketEncryption] Bucket的encryption配置
+      def encryption
+        @protocol.get_bucket_encryption(name)
+      end
+
+      # 设置Bucket的encryption配置
+      # @param encryption [BucketEncryption] encryption配置
+      def encryption=(encryption)
+        if encryption.enabled?
+          @protocol.put_bucket_encryption(name, encryption)
+        else
+          @protocol.delete_bucket_encryption(name)
+        end
+      end
+
       # 获取Bucket的website配置
       # @return [BucketWebsite] Bucket的website配置
       def website

data/lib/aliyun/oss/protocol.rb

@@ -212,6 +212,105 @@ module Aliyun
         logger.info("Done delete bucket logging")
       end
 
+      # Put bucket versioning settings
+      # @param name [String] the bucket name
+      # @param versioning [BucketVersioning] versioning options
+      def put_bucket_versioning(name, versioning)
+        logger.info("Begin put bucket versioning, "\
+                    "name: #{name}, versioning: #{versioning}")
+
+        sub_res = {'versioning' => nil}
+        body = Nokogiri::XML::Builder.new do |xml|
+          xml.VersioningConfiguration {
+            xml.Status versioning.status
+          }
+        end.to_xml
+
+        @http.put(
+          {:bucket => name, :sub_res => sub_res},
+          {:body => body})
+
+        logger.info("Done put bucket versioning")
+      end
+
+      # Get bucket versioning settings
+      # @param name [String] the bucket name
+      # @return [BucketVersioning] versioning options of this bucket
+      def get_bucket_versioning(name)
+        logger.info("Begin get bucket versioning, name: #{name}")
+
+        sub_res = {'versioning' => nil}
+        r = @http.get({:bucket => name, :sub_res => sub_res})
+
+        doc = parse_xml(r.body)
+
+        versioning_node = doc.at_css("VersioningConfiguration")
+        opts = {
+          :status => get_node_text(versioning_node, 'Status')
+        }
+
+        logger.info("Done get bucket versioning")
+
+        BucketVersioning.new(opts)
+      end
+
+      # Put bucket encryption settings
+      # @param name [String] the bucket name
+      # @param encryption [BucketEncryption] encryption options
+      def put_bucket_encryption(name, encryption)
+        logger.info("Begin put bucket encryption, "\
+                    "name: #{name}, encryption: #{encryption}")
+
+        sub_res = {'encryption' => nil}
+        body = Nokogiri::XML::Builder.new do |xml|
+          xml.ServerSideEncryptionRule {
+            xml.ApplyServerSideEncryptionByDefault {
+              xml.SSEAlgorithm encryption.sse_algorithm
+              xml.KMSMasterKeyID encryption.kms_master_key_id if encryption.kms_master_key_id
+            }
+          }
+        end.to_xml
+
+        @http.put(
+          {:bucket => name, :sub_res => sub_res},
+          {:body => body})
+
+        logger.info("Done put bucket encryption")
+      end
+
+      # Get bucket encryption settings
+      # @param name [String] the bucket name
+      # @return [BucketEncryption] encryption options of this bucket
+      def get_bucket_encryption(name)
+        logger.info("Begin get bucket encryption, name: #{name}")
+
+        sub_res = {'encryption' => nil}
+        r = @http.get({:bucket => name, :sub_res => sub_res})
+
+        doc = parse_xml(r.body)
+
+        encryption_node = doc.at_css("ApplyServerSideEncryptionByDefault")
+        opts = {
+          :sse_algorithm => get_node_text(encryption_node, 'SSEAlgorithm'),
+          :kms_master_key_id => get_node_text(encryption_node, 'KMSMasterKeyID')
+        }
+
+        logger.info("Done get bucket encryption")
+
+        BucketEncryption.new(opts)
+      end
+
+      # Delete bucket encryption settings, a.k.a. disable bucket encryption
+      # @param name [String] the bucket name
+      def delete_bucket_encryption(name)
+        logger.info("Begin delete bucket encryption, name: #{name}")
+
+        sub_res = {'encryption' => nil}
+        @http.delete({:bucket => name, :sub_res => sub_res})
+
+        logger.info("Done delete bucket encryption")
+      end
+
       # Put bucket website settings
       # @param name [String] the bucket name
       # @param website [BucketWebsite] the bucket website options

data/lib/aliyun/oss/struct.rb

@@ -74,6 +74,31 @@ module Aliyun
       end
     end
 
+    ##
+    # Bucket Versioning setting. See: {http://help.aliyun.com/document_detail/oss/product-documentation/function/versioning.html OSS Bucket versioning}
+    # Attributes:
+    # * status [String] the bucket versioning status, can be 'Enabled' and 'Suspended'
+    # @example Enable bucket versioning
+    #  bucket.versioning = BucketVersioning.new(:status => 'Enabled')
+    # @example Suspend bucket versioning
+    #  bucket.versioning = BucketVersioning.new(:status => 'Suspended')
+    class BucketVersioning < Common::Struct::Base
+      attrs :status
+    end
+    
+    ##
+    # Bucket Encryption setting. See: {http://help.aliyun.com/document_detail/oss/product-documentation/function/encryption.html OSS Bucket encryption}
+    # Attributes:
+    # * sse_algorithm [string] Indicates the default server-side encryption method
+    # * kms_master_key_id [string] Indicates the ID of CMK that is currently used.
+    class BucketEncryption < Common::Struct::Base
+      attrs :enable, :sse_algorithm, :kms_master_key_id
+
+      def enabled?
+        enable == true
+      end
+    end
+
     ##
     # Bucket website setting. See: {http://help.aliyun.com/document_detail/oss/product-documentation/function/host-static-website.html OSS Website hosting}
     # Attributes:

data/lib/aliyun/version.rb

@@ -2,6 +2,6 @@
 
 module Aliyun
 
-    VERSION = "0.7.1"
+    VERSION = "0.8.0"
 
 end # Aliyun

data/spec/aliyun/oss/bucket_spec.rb

@@ -89,13 +89,32 @@ 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
           }
         end.to_xml
       end
 
+      def mock_versioning(opts)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.VersioningConfiguration {
+            xml.Status opts.status
+          }
+        end.to_xml
+      end
+
+      def mock_encryption(opts)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.ServerSideEncryptionRule {
+            xml.ApplyServerSideEncryptionByDefault {
+              xml.SSEAlgorithm opts.sse_algorithm
+              xml.KMSMasterKeyID opts.kms_master_key_id if opts.kms_master_key_id
+            }
+          }
+        end.to_xml
+      end
+
       def mock_website(opts)
         Nokogiri::XML::Builder.new do |xml|
           xml.WebsiteConfiguration {
@@ -354,7 +373,7 @@ module Aliyun
         end
       end # delete bucket
 
-      context "acl, logging, website, referer, lifecycle" do
+      context "acl, logging, versioning, encryption, website, referer, lifecycle" do
         it "should update acl" do
           query = {'acl' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -392,6 +411,19 @@ 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' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -420,6 +452,23 @@ 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' => nil}
           stub_request(:delete, request_path).with(:query => query)
@@ -430,6 +479,18 @@ 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' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -442,6 +503,18 @@ 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' => nil}
           website_opts = BucketWebsite.new(
@@ -468,6 +541,18 @@ 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' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -541,6 +626,44 @@ 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' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -558,6 +681,24 @@ 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' => nil}
           return_rules = (1..5).map do |i|

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

@@ -156,6 +156,350 @@ 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 set versioning" do
+          query = {'versioning' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.VersioningConfiguration {
+              xml.Status 'Enabled'
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.versioning = BucketVersioning.new(:status => 'Enabled')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+		it "should get versioning" do
+          query = {'versioning' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.VersioningConfiguration {
+              xml.Status 'Enabled'
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          ret = @bucket.versioning
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+
+          expect(ret.status).to eq('Enabled')
+        end
+
+		it "should set encryption with aes256" do
+          query = {'encryption' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.ServerSideEncryptionRule {
+              xml.ApplyServerSideEncryptionByDefault {
+                xml.SSEAlgorithm 'AES256'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.encryption = BucketEncryption.new(:enable => true, :sse_algorithm => 'AES256')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+		it "should set encryption with KMS" do
+          query = {'encryption' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.ServerSideEncryptionRule {
+              xml.ApplyServerSideEncryptionByDefault {
+                xml.SSEAlgorithm 'KMS'
+                xml.KMSMasterKeyID 'kms-id'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.encryption = BucketEncryption.new(
+			:enable => true, 
+			:sse_algorithm => 'KMS', 
+			:kms_master_key_id => 'kms-id')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+		it "should get encryption" do
+          query = {'encryption' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.ServerSideEncryptionRule {
+              xml.ApplyServerSideEncryptionByDefault {
+                xml.SSEAlgorithm 'KMS'
+                xml.KMSMasterKeyID 'kms-id'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          ret = @bucket.encryption
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+
+          expect(ret.sse_algorithm).to eq('KMS')
+          expect(ret.kms_master_key_id).to eq('kms-id')
+        end
+
+		it "should delete encryption" do
+          query = {'encryption' => nil}
+
+          stub_request(:delete, bucket_url)
+            .with(:query => query)
+            .to_return(status: 204, :body => nil)
+
+          @bucket.encryption = BucketEncryption.new(:enable => false)
+
+          expect(WebMock).to have_requested(:delete, 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/')

data/spec/aliyun/oss/object_spec.rb

@@ -611,6 +611,15 @@ module Aliyun
                   })
         end
 
+        it "should raise Exception on error when setting invalid range" do
+          object_name = 'ruby'
+          url = get_request_path(object_name)
+          stub_request(:get, url)
+          expect {
+            @protocol.get_object(@bucket, object_name, {:range => [0, 10, 5]}) {}
+          }.to raise_error(ClientError)
+        end
+
         it "should match modify time and etag" do
           object_name = 'ruby'
           url = get_request_path(object_name)
@@ -662,6 +671,22 @@ module Aliyun
             .with(:body => nil, :query => query)
         end
 
+        it "should get object with headers" do
+          object_name = 'ruby'
+          url = get_request_path(object_name)
+          headers = {
+            'Range' => 'bytes=0-9'
+          }
+          stub_request(:get, url)
+
+          @protocol.get_object(@bucket, object_name, {:headers => headers}) {}
+
+          expect(WebMock).to have_requested(:get, url)
+            .with(:body => nil, :query => {},
+                  :headers => {
+                    'Range' => 'bytes=0-9'
+                  })
+        end
 
         it "should raise crc exception on error" do
           object_name = 'ruby'
@@ -821,7 +846,7 @@ module Aliyun
 
         it "should batch delete objects" do
           url = get_request_path
-          query = {'delete' => nil, 'encoding-type' => KeyEncoding::URL}
+          query = {'delete' => nil}
 
           object_names = (1..5).map do |i|
             "object-#{i}"
@@ -831,7 +856,7 @@ module Aliyun
             .with(:query => query)
             .to_return(:body => mock_delete_result(object_names))
 
-          opts = {:quiet => false, :encoding => KeyEncoding::URL}
+          opts = {:quiet => false}
           deleted = @protocol.batch_delete_objects(@bucket, object_names, opts)
 
           expect(WebMock).to have_requested(:post, url)
@@ -861,6 +886,57 @@ module Aliyun
             .with(:query => query, :body => mock_delete(object_names, opts))
           expect(deleted).to match_array(object_names)
         end
+
+        it "should batch delete objects in quiet mode" do
+          url = get_request_path
+          query = {'delete' => nil}
+
+          object_names = (1..5).map do |i|
+            "object-#{i}"
+          end
+
+          stub_request(:post, url)
+            .with(:query => query)
+            .to_return(:body => "")
+
+          opts = {:quiet => true}
+          deleted = @protocol.batch_delete_objects(@bucket, object_names, opts)
+
+          expect(WebMock).to have_requested(:post, url)
+            .with(:query => query, :body => mock_delete(object_names, opts))
+          expect(deleted).to match_array([])
+        end
+
+        it "should rasie Exception wiht invalid responsed body" do
+          url = get_request_path
+          query = {'delete' => nil}
+          body = '<DeleteResult>
+                    <EncodingType>invaid<EncodingType>
+                    <Deleted>
+                      <Key>multipart.data</Key>
+                    </Deleted>
+                    <Deleted>
+                      <Key>test.jpg</Key>
+                    </Deleted>
+                    <Deleted>
+                      <Key>demo.jpg</Key>
+                    </Deleted>
+                  </DeleteResult>'
+
+          object_names = (1..5).map do |i|
+            "object-#{i}"
+          end
+
+          stub_request(:post, url)
+            .with(:query => query)
+            .to_return(:body => body)
+
+          opts = {:quiet => false}
+          expect {
+            deleted = @protocol.batch_delete_objects(@bucket, object_names, opts)
+          }.to raise_error(ClientError)
+
+        end
       end # delete object
 
       context "acl" do

data/tests/test_bucket.rb

@@ -0,0 +1,73 @@
+require 'minitest/autorun'
+require 'yaml'
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+require 'aliyun/oss'
+require 'time'
+require_relative 'config'
+
+class TestBucket < Minitest::Test
+  def setup
+    Aliyun::Common::Logging.set_log_level(Logger::DEBUG)
+    @client = Aliyun::OSS::Client.new(TestConf.creds)
+    @bucket_name = TestConf.bucket + Time.now.to_i.to_s
+    @client.create_bucket(@bucket_name)
+    @bucket = @client.get_bucket(@bucket_name)
+  end
+
+  def teardown
+    @client.delete_bucket(@bucket_name)
+  end
+
+  def test_bucket_versioning
+    ret = @bucket.versioning
+    assert_nil ret.status
+
+    @bucket.versioning =  Aliyun::OSS::BucketVersioning.new(:status => 'Enabled')
+    ret = @bucket.versioning
+    assert_equal 'Enabled', ret.status
+
+    @bucket.versioning =  Aliyun::OSS::BucketVersioning.new(:status => 'Suspended')
+    ret = @bucket.versioning
+    assert_equal 'Suspended', ret.status
+
+  end
+
+  def test_bucket_encryption
+
+    begin
+      ret = @bucket.encryption
+      assert_raises "should not here"
+    rescue => exception
+    end  
+
+    @bucket.encryption =  Aliyun::OSS::BucketEncryption.new(
+      :enable => true,
+      :sse_algorithm => 'KMS')
+    ret = @bucket.encryption
+    assert_equal 'KMS', ret.sse_algorithm
+    assert_nil ret.kms_master_key_id
+
+    @bucket.encryption =  Aliyun::OSS::BucketEncryption.new(
+      :enable => true,
+      :sse_algorithm => 'KMS',
+      :kms_master_key_id => 'kms-id')
+    ret = @bucket.encryption
+    assert_equal 'KMS', ret.sse_algorithm
+    assert_equal 'kms-id', ret.kms_master_key_id
+
+    @bucket.encryption =  Aliyun::OSS::BucketEncryption.new(
+      :enable => true,
+      :sse_algorithm => 'AES256')
+    ret = @bucket.encryption
+    assert_equal 'AES256', ret.sse_algorithm
+    assert_nil ret.kms_master_key_id
+
+    @bucket.encryption =  Aliyun::OSS::BucketEncryption.new(
+      :enable => false)
+    begin
+      ret = @bucket.encryption
+      assert_raises "should not here"
+    rescue => exception
+    end  
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aliyun-sdk
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Tianlong Wu
 autorequire: 
 bindir: lib/aliyun
 cert_chain: []
-date: 2019-11-16 00:00:00.000000000 Z
+date: 2020-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -200,6 +200,7 @@ files:
 - spec/aliyun/sts/util_spec.rb
 - tests/config.rb
 - tests/helper.rb
+- tests/test_bucket.rb
 - tests/test_content_encoding.rb
 - tests/test_content_type.rb
 - tests/test_crc_check.rb
@@ -249,6 +250,7 @@ test_files:
 - spec/aliyun/sts/util_spec.rb
 - tests/config.rb
 - tests/helper.rb
+- tests/test_bucket.rb
 - tests/test_content_encoding.rb
 - tests/test_content_type.rb
 - tests/test_crc_check.rb