aliyun-oss-ruby-sdk 0.4.1

data/lib/aliyun_sdk/sts.rb

@@ -0,0 +1,9 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require_relative 'sts/util'
+require_relative 'sts/exception'
+require_relative 'sts/struct'
+require_relative 'sts/config'
+require_relative 'sts/protocol'
+require_relative 'sts/client'

data/lib/aliyun_sdk/sts/client.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+module AliyunSDK
+  module STS
+
+    # STS服务的客户端，用于向STS申请临时token。
+    # @example 创建Client
+    #   client = Client.new(
+    #     :access_key_id => 'access_key_id',
+    #     :access_key_secret => 'access_key_secret')
+    #   token = client.assume_role('role:arn', 'app')
+    #
+    #   policy = Policy.new
+    #   policy.allow(['oss:Get*'], ['acs:oss:*:*:my-bucket/*'])
+    #   token = client.assume_role('role:arn', 'app', policy, 60)
+    #   puts token.to_s
+    class Client
+
+      def initialize(opts)
+        @config = Config.new(opts)
+        @protocol = Protocol.new(@config)
+      end
+
+      # Assume a role
+      # @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
+      #  requested token
+      # @return [STS::Token] the sts token
+      def assume_role(role, session, policy = nil, duration = 3600)
+        @protocol.assume_role(role, session, policy, duration)
+      end
+
+    end # Client
+
+  end # STS
+end # Aliyun

data/lib/aliyun_sdk/sts/config.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+module AliyunSDK
+  module STS
+
+    # A place to store various configurations: credentials, api
+    # timeout, retry mechanism, etc
+    class Config < Common::Struct::Base
+
+      attrs :access_key_id, :access_key_secret, :endpoint
+
+      def initialize(opts = {})
+        super(opts)
+
+        @access_key_id = @access_key_id.strip if @access_key_id
+        @access_key_secret = @access_key_secret.strip if @access_key_secret
+        @endpoint = @endpoint.strip if @endpoint
+      end
+    end # Config
+
+  end # STS
+end # Aliyun

data/lib/aliyun_sdk/sts/exception.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+require 'nokogiri'
+
+module AliyunSDK
+  module STS
+
+    # ServerError represents exceptions from the STS
+    # service. i.e. Client receives a HTTP response whose status is
+    # NOT OK. #message provides the error message and #to_s gives
+    # detailed information probably including the STS request id.
+    class ServerError < Common::Exception
+
+      attr_reader :http_code, :error_code, :message, :request_id
+
+      def initialize(response)
+        @http_code = response.code
+        @attrs = {}
+
+        doc = Nokogiri::XML(response.body) do |config|
+          config.options |= Nokogiri::XML::ParseOptions::NOBLANKS
+        end rescue nil
+
+        if doc and doc.root
+          doc.root.children.each do |n|
+            @attrs[n.name] = n.text
+          end
+        end
+
+        @error_code = @attrs['Code']
+        @message = @attrs['Message']
+        @request_id = @attrs['RequestId']
+      end
+
+      def message
+        msg = @attrs['Message'] || "UnknownError[#{http_code}]."
+        "#{msg} RequestId: #{request_id}"
+      end
+
+      def to_s
+        @attrs.merge({'HTTPCode' => @http_code}).map do |k, v|
+          [k, v].join(": ")
+        end.join(", ")
+      end
+    end # ServerError
+
+    # ClientError represents client exceptions caused mostly by
+    # invalid parameters.
+    class ClientError < Common::Exception
+    end # ClientError
+
+  end # STS
+end # Aliyun

data/lib/aliyun_sdk/sts/protocol.rb

@@ -0,0 +1,130 @@
+# -*- encoding: utf-8 -*-
+
+require 'rest-client'
+require 'nokogiri'
+require 'time'
+
+module AliyunSDK
+  module STS
+
+    # Protocol implements the STS Open API which is low-level. User
+    # should refer to {STS::Client} for normal use.
+    class Protocol
+
+      ENDPOINT = 'https://sts.aliyuncs.com'
+      FORMAT = 'XML'
+      API_VERSION = '2015-04-01'
+      SIGNATURE_METHOD = 'HMAC-SHA1'
+      SIGNATURE_VERSION = '1.0'
+
+      include Common::Logging
+
+      def initialize(config)
+        @config = config
+      end
+
+      # Assume a role
+      # @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
+      #  requested token
+      # @return [STS::Token] the sts token
+      def assume_role(role, session, policy = nil, duration = 3600)
+        logger.info("Begin assume role, role: #{role}, session: #{session}, "\
+                    "policy: #{policy}, duration: #{duration}")
+
+        params = {
+          'Action' => 'AssumeRole',
+          'RoleArn' => role,
+          'RoleSessionName' => session,
+          'DurationSeconds' => duration.to_s
+        }
+        params.merge!({'Policy' => policy.serialize}) if policy
+
+        body = do_request(params)
+        doc = parse_xml(body)
+
+        creds_node = doc.at_css("Credentials")
+        creds = {
+          session_name: session,
+          access_key_id: get_node_text(creds_node, 'AccessKeyId'),
+          access_key_secret: get_node_text(creds_node, 'AccessKeySecret'),
+          security_token: get_node_text(creds_node, 'SecurityToken'),
+          expiration: get_node_text(
+            creds_node, 'Expiration') { |x| Time.parse(x) },
+        }
+
+        logger.info("Done assume role, creds: #{creds}")
+
+        Token.new(creds)
+      end
+
+      private
+      # Generate a random signature nonce
+      # @return [String] a random string
+      def signature_nonce
+        (rand * 1_000_000_000).to_s
+      end
+
+      # Do HTTP POST request with specified params
+      # @param params [Hash] the parameters to STS
+      # @return [String] the response body
+      # @raise [ServerError] raise errors if the server responds with errors
+      def do_request(params)
+        query = params.merge(
+          {'Format' => FORMAT,
+           'Version' => API_VERSION,
+           'AccessKeyId' => @config.access_key_id,
+           'SignatureMethod' => SIGNATURE_METHOD,
+           'SignatureVersion' => SIGNATURE_VERSION,
+           'SignatureNonce' => signature_nonce,
+           'Timestamp' => Time.now.utc.iso8601})
+
+        signature = Util.get_signature('POST', query, @config.access_key_secret)
+        query.merge!({'Signature' => signature})
+
+        r = RestClient::Request.execute(
+          :method => 'POST',
+          :url => @config.endpoint || ENDPOINT,
+          :payload => query
+        ) do |response, request, result, &blk|
+
+          if response.code >= 300
+            e = ServerError.new(response)
+            logger.error(e.to_s)
+            raise e
+          else
+            response.return!(request, result, &blk)
+          end
+        end
+
+        logger.debug("Received HTTP response, code: #{r.code}, headers: "\
+                     "#{r.headers}, body: #{r.body}")
+        r.body
+      end
+
+      # Parse body content to xml document
+      # @param content [String] the xml content
+      # @return [Nokogiri::XML::Document] the parsed document
+      def parse_xml(content)
+        doc = Nokogiri::XML(content) do |config|
+          config.options |= Nokogiri::XML::ParseOptions::NOBLANKS
+        end
+
+        doc
+      end
+
+      # Get the text of a xml node
+      # @param node [Nokogiri::XML::Node] the xml node
+      # @param tag [String] the node tag
+      # @yield [String] the node text is given to the block
+      def get_node_text(node, tag, &block)
+        n = node.at_css(tag) if node
+        value = n.text if n
+        block && value ? yield(value) : value
+      end
+
+    end # Protocol
+  end # STS
+end # Aliyun

data/lib/aliyun_sdk/sts/struct.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+require 'json'
+require 'cgi'
+
+module AliyunSDK
+  module STS
+
+    # STS Policy. Referer to
+    # https://help.aliyun.com/document_detail/ram/ram-user-guide/policy_reference/struct_def.html for details.
+    class Policy < Common::Struct::Base
+      VERSION = '1'
+
+      attrs :rules
+
+      # Add an 'Allow' rule
+      # @param actions [Array<String>] actions of the rule. e.g.:
+      #  oss:GetObject, oss:Get*, oss:*
+      # @param resources [Array<String>] resources of the rule. e.g.:
+      #  acs:oss:*:*:my-bucket, acs:oss:*:*:my-bucket/*, acs:oss:*:*:*
+      def allow(actions, resources)
+        add_rule(true, actions, resources)
+      end
+
+      # Add an 'Deny' rule
+      # @param actions [Array<String>] actions of the rule. e.g.:
+      #  oss:GetObject, oss:Get*, oss:*
+      # @param resources [Array<String>] resources of the rule. e.g.:
+      #  acs:oss:*:*:my-bucket, acs:oss:*:*:my-bucket/*, acs:oss:*:*:*
+      def deny(actions, resources)
+        add_rule(false, actions, resources)
+      end
+
+      # Serialize to rule to string
+      def serialize
+        {'Version' => VERSION, 'Statement' => @rules}.to_json
+      end
+
+      private
+      def add_rule(allow, actions, resources)
+        @rules ||= []
+        @rules << {
+          'Effect' => allow ? 'Allow' : 'Deny',
+          'Action' => actions,
+          'Resource' => resources
+        }
+      end
+    end
+
+    # STS token. User may use the credentials included to access
+    # Alicloud resources(OSS, OTS, etc).
+    # Attributes:
+    # * access_key_id [String] the AccessKeyId
+    # * access_key_secret [String] the AccessKeySecret
+    # * security_token [String] the SecurityToken
+    # * expiration [Time] the time when the token will be expired
+    # * session_name [String] the session name for this token
+    class Token < Common::Struct::Base
+      attrs :access_key_id, :access_key_secret,
+            :security_token, :expiration, :session_name
+    end
+
+  end # STS
+end # Aliyun

data/lib/aliyun_sdk/sts/util.rb

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+require 'time'
+require 'cgi'
+require 'base64'
+require 'openssl'
+require 'digest/md5'
+
+module AliyunSDK
+  module STS
+    ##
+    # Util functions to help generate formatted Date, signatures,
+    # etc.
+    #
+    module Util
+
+      class << self
+
+        include Common::Logging
+
+        # Calculate request signatures
+        def get_signature(verb, params, key)
+          logger.debug("Sign, verb: #{verb}, params: #{params}")
+
+          cano_query = params.sort.map {
+            |k, v| [CGI.escape(k), CGI.escape(v)].join('=') }.join('&')
+
+          string_to_sign =
+            verb + '&' + CGI.escape('/') + '&' + CGI.escape(cano_query)
+
+          logger.debug("String to sign: #{string_to_sign}")
+
+          Util.sign(key + '&', string_to_sign)
+        end
+
+        # Sign a string using HMAC and BASE64
+        # @param [String] key the secret key
+        # @param [String] string_to_sign the string to sign
+        # @return [String] the signature
+        def sign(key, string_to_sign)
+          Base64.strict_encode64(
+            OpenSSL::HMAC.digest('sha1', key, string_to_sign))
+        end
+
+      end # self
+    end # Util
+  end # STS
+end # Aliyun

data/lib/aliyun_sdk/version.rb

@@ -0,0 +1,7 @@
+# -*- encoding: utf-8 -*-
+
+module AliyunSDK
+
+    VERSION = "0.4.1"
+
+end # Aliyun

data/spec/aliyun/oss/bucket_spec.rb

@@ -0,0 +1,597 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'yaml'
+require 'nokogiri'
+
+module AliyunSDK
+  module OSS
+
+    describe "Bucket" do
+
+      before :all do
+        @endpoint = 'oss.aliyuncs.com'
+        @protocol = Protocol.new(
+          Config.new(:endpoint => @endpoint,
+                     :access_key_id => 'xxx', :access_key_secret => 'yyy'))
+        @bucket = 'rubysdk-bucket'
+      end
+
+      def request_path
+        @bucket + "." + @endpoint
+      end
+
+      def mock_location(location)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.CreateBucketConfiguration {
+            xml.LocationConstraint location
+          }
+        end.to_xml
+      end
+
+      def mock_objects(objects, more = {})
+        Nokogiri::XML::Builder.new do |xml|
+          xml.ListBucketResult {
+            {
+              :prefix => 'Prefix',
+              :delimiter => 'Delimiter',
+              :limit => 'MaxKeys',
+              :marker => 'Marker',
+              :next_marker => 'NextMarker',
+              :truncated => 'IsTruncated',
+              :encoding => 'EncodingType'
+            }.map do |k, v|
+              xml.send(v, more[k]) if more[k]
+            end
+
+            objects.each do |o|
+              xml.Contents {
+                xml.Key o
+                xml.LastModified Time.now.to_s
+                xml.Type 'Normal'
+                xml.Size 1024
+                xml.StorageClass 'Standard'
+                xml.Etag 'etag'
+                xml.Owner {
+                  xml.ID '10086'
+                  xml.DisplayName 'CMCC'
+                }
+              }
+            end
+
+            (more[:common_prefixes] || []).each do |p|
+              xml.CommonPrefixes {
+                xml.Prefix p
+              }
+            end
+          }
+        end.to_xml
+      end
+
+      def mock_acl(acl)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.AccessControlPolicy {
+            xml.Owner {
+              xml.ID 'owner_id'
+              xml.DisplayName 'owner_name'
+            }
+
+            xml.AccessControlList {
+              xml.Grant acl
+            }
+          }
+        end.to_xml
+      end
+
+      def mock_logging(opts)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.BucketLoggingStatus {
+            if opts.enabled?
+              xml.LoggingEnabled {
+                xml.TargetBucket opts.target_bucket
+                xml.TargetPrefix opts.target_prefix
+              }
+            end
+          }
+        end.to_xml
+      end
+
+      def mock_website(opts)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.WebsiteConfiguration {
+            xml.IndexDocument {
+              xml.Suffix opts.index
+            }
+            if opts.error
+              xml.ErrorDocument {
+                xml.Key opts.error
+              }
+            end
+          }
+        end.to_xml
+      end
+
+      def mock_referer(opts)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.RefererConfiguration {
+            xml.AllowEmptyReferer opts.allow_empty?
+            xml.RefererList {
+              opts.whitelist.each do |r|
+                xml.Referer r
+              end
+            }
+          }
+        end.to_xml
+      end
+
+      def mock_lifecycle(rules)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.LifecycleConfiguration {
+            rules.each do |r|
+              xml.Rule {
+                xml.ID r.id if r.id
+                xml.Status r.enabled? ? 'Enabled' : 'Disabled'
+                xml.Prefix r.prefix
+                xml.Expiration {
+                  if r.expiry.is_a?(Date)
+                    xml.Date Time.utc(r.expiry.year, r.expiry.month, r.expiry.day)
+                              .iso8601.sub('Z', '.000Z')
+                  else
+                    xml.Days r.expiry.to_i
+                  end
+                }
+              }
+            end
+          }
+        end.to_xml
+      end
+
+      def mock_cors(rules)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.CORSConfiguration {
+            rules.each do |r|
+              xml.CORSRule {
+                r.allowed_origins.each do |x|
+                  xml.AllowedOrigin x
+                end
+                r.allowed_methods.each do |x|
+                  xml.AllowedMethod x
+                end
+                r.allowed_headers.each do |x|
+                  xml.AllowedHeader x
+                end
+                r.expose_headers.each do |x|
+                  xml.ExposeHeader x
+                end
+                xml.MaxAgeSeconds r.max_age_seconds if r.max_age_seconds
+              }
+            end
+          }
+        end.to_xml
+      end
+
+      def mock_error(code, message)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.Error {
+            xml.Code code
+            xml.Message message
+            xml.RequestId '0000'
+          }
+        end.to_xml
+      end
+
+      def err(msg, reqid = '0000')
+        "#{msg} RequestId: #{reqid}"
+      end
+
+      context "Create bucket" do
+
+        it "should PUT to create bucket" do
+          stub_request(:put, request_path)
+
+          @protocol.create_bucket(@bucket)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:body => nil, :query => {})
+        end
+
+        it "should set location when create bucket" do
+          location = 'oss-cn-hangzhou'
+
+          stub_request(:put, request_path).with(:body => mock_location(location))
+
+          @protocol.create_bucket(@bucket, :location => 'oss-cn-hangzhou')
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:body => mock_location(location), :query => {})
+        end
+      end # create bucket
+
+      context "List objects" do
+
+        it "should list all objects" do
+          stub_request(:get, request_path)
+
+          @protocol.list_objects(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:body => nil, :query => {})
+        end
+
+        it "should parse object response" do
+          return_objects = ['hello', 'world', 'foo/bar']
+          stub_request(:get, request_path)
+            .to_return(:body => mock_objects(return_objects))
+
+          objects, more = @protocol.list_objects(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:body => nil, :query => {})
+
+          expect(objects.map {|o| o.key}).to match_array(return_objects)
+          expect(more).to be_empty
+        end
+
+        it "should list objects with prefix & delimiter" do
+          # Webmock cannot capture the request_path encoded query parameters,
+          # so we use 'foo-bar' instead of 'foo/bar' to work around
+          # the problem
+          opts = {
+            :marker => 'foo-bar',
+            :prefix => 'foo-',
+            :delimiter => '-',
+            :limit => 10,
+            :encoding => KeyEncoding::URL}
+
+          query = opts.clone
+          query['max-keys'] = query.delete(:limit)
+          query['encoding-type'] = query.delete(:encoding)
+
+          stub_request(:get, request_path).with(:query => query)
+
+          @protocol.list_objects(@bucket, opts)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:body => "", :query => query)
+        end
+
+        it "should parse object and common prefixes response" do
+          return_objects = ['hello', 'world', 'foo-bar']
+          return_more = {
+            :marker => 'foo-bar',
+            :prefix => 'foo-',
+            :delimiter => '-',
+            :limit => 10,
+            :encoding => KeyEncoding::URL,
+            :next_marker => 'foo-xxx',
+            :truncated => true,
+            :common_prefixes => ['foo/bar/', 'foo/xxx/']
+          }
+
+          opts = {
+            :marker => 'foo-bar',
+            :prefix => 'foo-',
+            :delimiter => '-',
+            :limit => 10,
+            :encoding => KeyEncoding::URL
+          }
+
+          query = opts.clone
+          query['max-keys'] = query.delete(:limit)
+          query['encoding-type'] = query.delete(:encoding)
+
+          stub_request(:get, request_path).with(:query => query).
+            to_return(:body => mock_objects(return_objects, return_more))
+
+          objects, more = @protocol.list_objects(@bucket, opts)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:body => nil, :query => query)
+
+          expect(objects.map {|o| o.key}).to match_array(return_objects)
+          expect(more).to eq(return_more)
+        end
+
+        it "should decode object key" do
+          return_objects = ['中国のruby', 'world', 'foo/bar']
+          return_more = {
+            :marker => '杭州のruby',
+            :prefix => 'foo-',
+            :delimiter => '分隔のruby',
+            :limit => 10,
+            :encoding => KeyEncoding::URL,
+            :next_marker => '西湖のruby',
+            :truncated => true,
+            :common_prefixes => ['玉泉のruby', '苏堤のruby']
+          }
+
+          es_objects = [CGI.escape('中国のruby'), 'world', 'foo/bar']
+          es_more = {
+            :marker => CGI.escape('杭州のruby'),
+            :prefix => 'foo-',
+            :delimiter => CGI.escape('分隔のruby'),
+            :limit => 10,
+            :encoding => KeyEncoding::URL,
+            :next_marker => CGI.escape('西湖のruby'),
+            :truncated => true,
+            :common_prefixes => [CGI.escape('玉泉のruby'), CGI.escape('苏堤のruby')]
+          }
+
+          stub_request(:get, request_path)
+            .to_return(:body => mock_objects(es_objects, es_more))
+
+          objects, more = @protocol.list_objects(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:body => nil, :query => {})
+
+          expect(objects.map {|o| o.key}).to match_array(return_objects)
+          expect(more).to eq(return_more)
+        end
+      end # list objects
+
+      context "Delete bucket" do
+
+        it "should send DELETE reqeust" do
+          stub_request(:delete, request_path)
+
+          @protocol.delete_bucket(@bucket)
+
+          expect(WebMock).to have_requested(:delete, request_path)
+            .with(:body => nil, :query => {})
+        end
+
+        it "should raise Exception on error" do
+          code = "NoSuchBucket"
+          message = "The bucket to delete does not exist."
+
+          stub_request(:delete, request_path).to_return(
+            :status => 404, :body => mock_error(code, message))
+
+          expect {
+            @protocol.delete_bucket(@bucket)
+          }.to raise_error(ServerError, err(message))
+        end
+      end # delete bucket
+
+      context "acl, logging, website, referer, lifecycle" do
+        it "should update acl" do
+          query = {'acl' => ''}
+          stub_request(:put, request_path).with(:query => query)
+
+          @protocol.put_bucket_acl(@bucket, ACL::PUBLIC_READ)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:query => query, :body => nil)
+        end
+
+        it "should get acl" do
+          query = {'acl' => ''}
+          return_acl = ACL::PUBLIC_READ
+          stub_request(:get, request_path)
+            .with(:query => query)
+            .to_return(:body => mock_acl(return_acl))
+
+          acl = @protocol.get_bucket_acl(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:query => query, :body => nil)
+          expect(acl).to eq(return_acl)
+        end
+
+        it "should enable logging" do
+          query = {'logging' => ''}
+          stub_request(:put, request_path).with(:query => query)
+
+          logging_opts = BucketLogging.new(
+            :enable => true,
+            :target_bucket => 'target-bucket', :target_prefix => 'foo')
+          @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' => ''}
+          stub_request(:put, request_path).with(:query => query)
+
+          logging_opts = BucketLogging.new(:enable => false)
+          @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 get logging" do
+          query = {'logging' => ''}
+          logging_opts = BucketLogging.new(
+            :enable => true,
+            :target_bucket => 'target-bucket', :target_prefix => 'foo')
+
+          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' => ''}
+          stub_request(:delete, request_path).with(:query => query)
+
+          @protocol.delete_bucket_logging(@bucket)
+
+          expect(WebMock).to have_requested(:delete, request_path)
+            .with(:query => query, :body => nil)
+        end
+
+        it "should update website" do
+          query = {'website' => ''}
+          stub_request(:put, request_path).with(:query => query)
+
+          website_opts = BucketWebsite.new(
+            :enable => true, :index => 'index.html', :error => 'error.html')
+          @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' => ''}
+          website_opts = BucketWebsite.new(
+            :enable => true, :index => 'index.html', :error => 'error.html')
+
+          stub_request(:get, request_path)
+            .with(:query => query)
+            .to_return(:body => mock_website(website_opts))
+
+          opts = @protocol.get_bucket_website(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:query => query, :body => nil)
+          expect(opts.to_s).to eq(website_opts.to_s)
+        end
+
+        it "should delete website" do
+          query = {'website' => ''}
+          stub_request(:delete, request_path).with(:query => query)
+
+          @protocol.delete_bucket_website(@bucket)
+
+          expect(WebMock).to have_requested(:delete, request_path)
+            .with(:query => query, :body => nil)
+        end
+
+        it "should update referer" do
+          query = {'referer' => ''}
+          stub_request(:put, request_path).with(:query => query)
+
+          referer_opts = BucketReferer.new(
+            :allow_empty => true, :whitelist => ['xxx', 'yyy'])
+          @protocol.put_bucket_referer(@bucket, referer_opts)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:query => query, :body => mock_referer(referer_opts))
+        end
+
+        it "should get referer" do
+          query = {'referer' => ''}
+          referer_opts = BucketReferer.new(
+            :allow_empty => true, :whitelist => ['xxx', 'yyy'])
+
+          stub_request(:get, request_path)
+            .with(:query => query)
+            .to_return(:body => mock_referer(referer_opts))
+
+          opts = @protocol.get_bucket_referer(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:query => query, :body => nil)
+          expect(opts.to_s).to eq(referer_opts.to_s)
+        end
+
+        it "should update lifecycle" do
+          query = {'lifecycle' => ''}
+          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 => (i % 2 == 1 ? Date.today : 10 + i))
+          end
+
+          @protocol.put_bucket_lifecycle(@bucket, rules)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:query => query, :body => mock_lifecycle(rules))
+        end
+
+        it "should get lifecycle" do
+          query = {'lifecycle' => ''}
+          return_rules = (1..5).map do |i|
+            LifeCycleRule.new(
+              :id => i, :enable => i % 2 == 0, :prefix => "foo#{i}",
+              :expiry => (i % 2 == 1 ? Date.today : 10 + i))
+          end
+
+          stub_request(:get, request_path)
+            .with(:query => query)
+            .to_return(:body => mock_lifecycle(return_rules))
+
+          rules = @protocol.get_bucket_lifecycle(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:query => query, :body => nil)
+          expect(rules.map(&:to_s)).to match_array(return_rules.map(&:to_s))
+        end
+
+        it "should delete lifecycle" do
+          query = {'lifecycle' => ''}
+          stub_request(:delete, request_path).with(:query => query)
+
+          @protocol.delete_bucket_lifecycle(@bucket)
+
+          expect(WebMock).to have_requested(:delete, request_path)
+            .with(:query => query, :body => nil)
+        end
+
+        it "should set cors" do
+          query = {'cors' => ''}
+          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}"})
+          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' => ''}
+          return_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}"})
+          end
+
+          stub_request(:get, request_path)
+            .with(:query => query)
+            .to_return(:body => mock_cors(return_rules))
+
+          rules = @protocol.get_bucket_cors(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:query => query, :body => nil)
+          expect(rules.map(&:to_s)).to match_array(return_rules.map(&:to_s))
+        end
+
+        it "should delete cors" do
+          query = {'cors' => ''}
+
+          stub_request(:delete, request_path).with(:query => query)
+
+          @protocol.delete_bucket_cors(@bucket)
+          expect(WebMock).to have_requested(:delete, request_path)
+            .with(:query => query, :body => nil)
+        end
+
+      end # acl, logging, cors, etc
+
+    end # Bucket
+
+  end # OSS
+end # Aliyun