aliyun-sdk 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aea256f156d30bf7e84ed0f6a2cd0670b63c02fe1fc6a6f9641e479dc2dfcbf5
-  data.tar.gz: 1344db0e4aa351fc9065779ef80297857a57e48fdf5d41527dd5ce3cb62c17cb
+  metadata.gz: 5bc5cc4acd9d6e01955fd76f3b15e38d73a352f457c181bb9de469af4f30c4f3
+  data.tar.gz: 2ec82c787847ed16ac7172cec823756f8752700a8366048127487d3257a2af32
 SHA512:
-  metadata.gz: 53387168b68b6b209f8a2c83e7704c0b0fa5bc02cb7dcd384c19bfe357eece672a5e9b2e566e2da261d1133d5a99280455e74eb71ef3aa09158659948b3fb2bf
-  data.tar.gz: 93615f26a714a0daf08cfe18addd2fc25bc5e1d028ec53ab8302f6aeabd4e4b05dc59f254cc823faeba2d846f0b0b8e5a74736fc9348ee1ee6d88366b100cc84
+  metadata.gz: e4af5842f0231aa8d5fd3c301e70418f895a5b9e5a36e254a184a4715b70389119a78c931e823ca0df039fde1020b32e82d598becf867b6416b39ecdf904635b
+  data.tar.gz: 94edfce3d26df7ee399e62b56e48f22c055df2ab967affd22d40f4145e48f27bdc8ada7a16916464330287569a58eb0cbd17d8c5dbca73ce2fd31b081d96644c

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## Change Log
 
+### 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

@@ -34,8 +34,13 @@ module Aliyun
 
       def self.logger
         unless @logger
+          @log_file = nil
+          # Environment parameter ALIYUN_OSS_SDK_LOG_PATH used to control whether output log to a file
+          if ENV['ALIYUN_OSS_SDK_LOG_PATH']
+            @log_file ||= DEFAULT_LOG_FILE
+          end
           @logger = Logger.new(
-            @log_file ||= DEFAULT_LOG_FILE, MAX_NUM_LOG, ROTATE_SIZE)
+              @log_file, MAX_NUM_LOG, ROTATE_SIZE)
           @logger.level = Logger::INFO
         end
         @logger

data/lib/aliyun/version.rb

@@ -2,6 +2,6 @@
 
 module Aliyun
 
-    VERSION = "0.7.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
           }
@@ -392,6 +392,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 +433,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 +460,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 +484,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 +522,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 +607,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 +662,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,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/')

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aliyun-sdk
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Tianlong Wu
 autorequire: 
 bindir: lib/aliyun
 cert_chain: []
-date: 2019-11-16 00:00:00.000000000 Z
+date: 2020-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri