aliyun-sdk 0.1.1

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

@@ -0,0 +1,338 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'yaml'
+require 'nokogiri'
+
+module Aliyun
+  module OSS
+
+    describe Bucket do
+
+      before :all do
+        @endpoint = 'oss-cn-hangzhou.aliyuncs.com'
+        @bucket_name = 'rubysdk-bucket'
+        @bucket = Client.new(
+          :endpoint => @endpoint,
+          :access_key_id => 'xxx',
+          :access_key_secret => 'yyy').get_bucket(@bucket_name)
+      end
+
+      def bucket_url
+        "#{@bucket_name}.#{@endpoint}"
+      end
+
+      def object_url(object)
+        "#{@bucket_name}.#{@endpoint}/#{object}"
+      end
+
+      def resource_path(object)
+        "/#{@bucket_name}/#{object}"
+      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] != nil
+            end
+
+            objects.each do |o|
+              xml.Contents {
+                xml.Key o.key
+                xml.Size o.size
+                xml.ETag o.etag
+              }
+            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
+
+      context "bucket operations" do
+        it "should get acl" do
+          query = {'acl' => ''}
+          return_acl = ACL::PUBLIC_READ
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(:body => mock_acl(return_acl))
+
+          acl = @bucket.acl
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+          expect(acl).to eq(return_acl)
+        end
+
+        it "should set acl" do
+          query = {'acl' => ''}
+
+          stub_request(:put, bucket_url).with(:query => query)
+
+          @bucket.acl = ACL::PUBLIC_READ
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => nil)
+        end
+
+        it "should delete logging setting" do
+          query = {'logging' => ''}
+
+          stub_request(:delete, bucket_url).with(:query => query)
+
+          @bucket.logging = BucketLogging.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')
+        end
+
+        it "should get access key id" do
+          expect(@bucket.access_key_id).to eq('xxx')
+        end
+      end # bucket operations
+
+      context "object operations" do
+        it "should list objects" do
+          query_1 = {
+            :prefix => 'list-',
+            :delimiter => '-'
+          }
+          return_obj_1 = (1..5).map{ |i| Object.new(
+            :key => "obj-#{i}",
+            :size => 1024 * i,
+            :etag => "etag-#{i}")}
+          return_more_1 = {
+            :next_marker => 'foo',
+            :truncated => true,
+            :common_prefixes => ['hello', 'world']
+          }
+
+          query_2 = {
+            :prefix => 'list-',
+            :delimiter => '-',
+            :marker => 'foo'
+          }
+          return_obj_2 = (6..8).map{ |i| Object.new(
+            :key => "obj-#{i}",
+            :size => 1024 * i,
+            :etag => "etag-#{i}")}
+          return_more_2 = {
+            :next_marker => 'bar',
+            :truncated => false,
+            :common_prefixes => ['rock', 'suck']
+          }
+
+          stub_request(:get, bucket_url)
+            .with(:query => query_1)
+            .to_return(:body => mock_objects(return_obj_1, return_more_1))
+
+          stub_request(:get, bucket_url)
+            .with(:query => query_2)
+            .to_return(:body => mock_objects(return_obj_2, return_more_2))
+
+          list = @bucket.list_objects :prefix => 'list-', :delimiter => '-'
+          all = list.to_a
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+                         .with(:query => query_1).times(1)
+          expect(WebMock).to have_requested(:get, bucket_url)
+                         .with(:query => query_2).times(1)
+
+          objs = all.select{ |x| x.is_a?(Object) }
+          common_prefixes = all.select{ |x| x.is_a?(String) }
+          all_objs = (1..8).map{ |i| Object.new(
+            :key => "obj-#{i}",
+            :size => 1024 * i,
+            :etag => "etag-#{i}")}
+          expect(objs.map{ |o| o.to_s }).to match_array(all_objs.map{ |o| o.to_s })
+          all_prefixes = ['hello', 'world', 'rock', 'suck']
+          expect(common_prefixes).to match_array(all_prefixes)
+        end
+
+        it "should put object from file" do
+          key = 'ruby'
+          stub_request(:put, object_url(key))
+
+          content = (1..10).map{ |i| i.to_s.rjust(9, '0') }.join("\n")
+          File.open('/tmp/x', 'w'){ |f| f.write(content) }
+
+          @bucket.put_object(key, :file => '/tmp/x')
+
+          expect(WebMock).to have_requested(:put, object_url(key))
+            .with(:body => content, :query => {})
+        end
+
+        it "should get object to file" do
+          key = 'ruby'
+          # 100 KB
+          content = (1..1024).map{ |i| i.to_s.rjust(99, '0') }.join(",")
+
+          stub_request(:get, object_url(key)).to_return(:body => content)
+
+          @bucket.get_object(key, :file => '/tmp/x')
+
+          expect(WebMock).to have_requested(:get, object_url(key))
+                         .with(:body => nil, :query => {})
+          expect(File.read('/tmp/x')).to eq(content)
+        end
+
+        it "should only get meta when get object without :file or block" do
+          key = 'ruby'
+
+          last_modified = Time.now.rfc822
+          return_headers = {
+            'x-oss-object-type' => 'Normal',
+            'ETag' => 'xxxyyyzzz',
+            'Content-Length' => 1024,
+            'Last-Modified' => last_modified,
+            'x-oss-meta-year' => '2015',
+            'x-oss-meta-people' => 'mary'
+          }
+          stub_request(:head, object_url(key))
+            .to_return(:headers => return_headers)
+
+          obj = @bucket.get_object(key)
+
+          expect(WebMock).to have_requested(:head, object_url(key))
+            .with(:body => nil, :query => {})
+
+          expect(obj.key).to eq(key)
+          expect(obj.type).to eq('Normal')
+          expect(obj.etag).to eq('xxxyyyzzz')
+          expect(obj.size).to eq(1024)
+          expect(obj.last_modified.rfc822).to eq(last_modified)
+          expect(obj.metas).to eq({'year' => '2015', 'people' => 'mary'})
+        end
+
+        it "should append object from file" do
+          key = 'ruby'
+          query = {'append' => '', 'position' => 11}
+          stub_request(:post, object_url(key)).with(:query => query)
+
+          content = (1..10).map{ |i| i.to_s.rjust(9, '0') }.join("\n")
+          content = "<html>" + content + "</html>"
+          File.open('/tmp/x.html', 'w'){ |f| f.write(content) }
+
+          @bucket.append_object(key, 11, :file => '/tmp/x.html')
+
+          expect(WebMock).to have_requested(:post, object_url(key))
+                         .with(:query => query, :body => content,
+                               :headers => {'Content-Type' => 'text/html'})
+        end
+
+        it "should answer object exists?" do
+          key = 'ruby'
+
+          stub_request(:head, object_url(key))
+            .to_return(:status => 404).times(3)
+
+          expect {
+            @bucket.get_object(key)
+          }.to raise_error(Exception, "UnknownError, HTTP Code: 404")
+
+          expect(@bucket.object_exists?(key)).to be false
+          expect(@bucket.object_exist?(key)).to be false
+
+          last_modified = Time.now.rfc822
+          return_headers = {
+            'x-oss-object-type' => 'Normal',
+            'ETag' => 'xxxyyyzzz',
+            'Content-Length' => 1024,
+            'Last-Modified' => last_modified,
+            'x-oss-meta-year' => '2015',
+            'x-oss-meta-people' => 'mary'
+          }
+
+          stub_request(:head, object_url(key))
+            .to_return(:headers => return_headers).times(2)
+
+          expect(@bucket.object_exists?(key)).to be true
+          expect(@bucket.object_exist?(key)).to be true
+
+          stub_request(:head, object_url(key))
+            .to_return(:status => 500)
+
+          expect {
+            @bucket.object_exists?(key)
+          }.to raise_error(Exception, "UnknownError, HTTP Code: 500")
+        end
+
+        it "should update object metas" do
+          key = 'ruby'
+
+          stub_request(:put, object_url(key))
+
+          @bucket.update_object_metas(
+            key, {'people' => 'mary', 'year' => '2016'})
+
+          expect(WebMock).to have_requested(:put, object_url(key))
+                         .with(:body => nil,
+                               :headers => {
+                                 'x-oss-copy-source' => resource_path(key),
+                                 'x-oss-metadata-directive' => 'REPLACE',
+                                 'x-oss-meta-year' => '2016',
+                                 'x-oss-meta-people' => 'mary'})
+        end
+
+        it "should get object url" do
+          url = @bucket.object_url('yeah', false)
+          object_url = 'http://rubysdk-bucket.oss-cn-hangzhou.aliyuncs.com/yeah'
+          expect(url).to eq(object_url)
+
+          url = @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['OSSAccessKeyId']).to eq('xxx')
+          expires = query['Expires']
+          signature = CGI.unescape(query['Signature'])
+
+          string_to_sign =
+            "GET\n" + "\n\n" + "#{expires}\n" + "/rubysdk-bucket/yeah"
+          sig = Util.sign('yyy', string_to_sign)
+          expect(signature).to eq(sig)
+        end
+      end # object operations
+
+    end # Bucket
+  end # OSS
+end # Aliyun

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

@@ -0,0 +1,228 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'yaml'
+require 'nokogiri'
+
+module Aliyun
+  module OSS
+
+    describe Client do
+
+      context "construct" do
+        it "should setup endpoint and a/k", :focus => true do
+          endpoint = 'oss-cn-hangzhou.aliyuncs.com'
+          client = Client.new(
+            :endpoint => endpoint,
+            :access_key_id => 'xxx', :access_key_secret => 'yyy')
+
+          config = client.instance_variable_get('@config')
+          expect(config.endpoint.to_s).to eq("http://#{endpoint}")
+          expect(config.access_key_id).to eq('xxx')
+          expect(config.access_key_secret).to eq('yyy')
+        end
+
+        it "should not set Authorization with anonymous client" do
+          endpoint = 'oss-cn-hangzhou.aliyuncs.com'
+          bucket = 'rubysdk-bucket'
+          object = 'rubysdk-object'
+          client = Client.new(:endpoint => endpoint)
+
+          stub_request(:get, "#{bucket}.#{endpoint}/#{object}")
+
+          client.get_bucket(bucket).get_object(object) {}
+
+          expect(WebMock)
+            .to have_requested(:get, "#{bucket}.#{endpoint}/#{object}")
+            .with{ |req| not req.headers.has_key?('Authorization') }
+        end
+
+        it "should construct different client" do
+          bucket = 'rubysdk-bucket'
+          object = 'rubysdk-object'
+          ep1 = 'oss-cn-hangzhou.aliyuncs.com'
+          c1 = Client.new(
+            :endpoint => ep1,
+            :access_key_id => 'xxx', :access_key_secret => 'yyy')
+          ep2 = 'oss-cn-beijing.aliyuncs.com'
+          c2 = Client.new(
+            :endpoint => ep2,
+            :access_key_id => 'aaa', :access_key_secret => 'bbb')
+
+          stub_request(:get, "#{bucket}.#{ep1}/#{object}")
+          stub_request(:put, "#{bucket}.#{ep2}/#{object}")
+
+          c1.get_bucket(bucket).get_object(object) {}
+          c2.get_bucket(bucket).put_object(object)
+
+          expect(WebMock).to have_requested(:get, "#{bucket}.#{ep1}/#{object}")
+          expect(WebMock).to have_requested(:put, "#{bucket}.#{ep2}/#{object}")
+        end
+      end # construct
+
+      def mock_buckets(buckets, more = {})
+        Nokogiri::XML::Builder.new do |xml|
+          xml.ListAllMyBucketsResult {
+            xml.Owner {
+              xml.ID 'owner_id'
+              xml.DisplayName 'owner_name'
+            }
+            xml.Buckets {
+              buckets.each do |b|
+                xml.Bucket {
+                  xml.Location b.location
+                  xml.Name b.name
+                  xml.CreationDate b.creation_time.to_s
+                }
+              end
+            }
+
+            unless more.empty?
+              xml.Prefix more[:prefix]
+              xml.Marker more[:marker]
+              xml.MaxKeys more[:limit].to_s
+              xml.NextMarker more[:next_marker]
+              xml.IsTruncated more[:truncated]
+            end
+          }
+        end.to_xml
+      end
+
+      def mock_location(location)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.CreateBucketConfiguration {
+            xml.LocationConstraint location
+          }
+        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
+
+      context "bucket operations" do
+        before :all do
+          @endpoint = 'oss.aliyuncs.com'
+          @client = Client.new(
+            :endpoint => @endpoint,
+            :access_key_id => 'xxx',
+            :access_key_secret => 'yyy')
+          @bucket = 'rubysdk-bucket'
+        end
+
+        def bucket_url
+          @bucket + "." + @endpoint
+        end
+
+        it "should create bucket" do
+          location = 'oss-cn-hangzhou'
+
+          stub_request(:put, bucket_url).with(:body => mock_location(location))
+
+          @client.create_bucket(@bucket, :location => 'oss-cn-hangzhou')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:body => mock_location(location), :query => {})
+        end
+
+        it "should delete bucket" do
+          stub_request(:delete, bucket_url)
+
+          @client.delete_bucket(@bucket)
+
+          expect(WebMock).to have_requested(:delete, bucket_url)
+            .with(:body => nil, :query => {})
+        end
+
+        it "should paging list buckets" do
+          return_buckets_1 = (1..5).map do |i|
+            name = "rubysdk-bucket-#{i.to_s.rjust(3, '0')}"
+            Bucket.new(
+              :name => name,
+              :location => 'oss-cn-hangzhou',
+              :creation_time => Time.now)
+          end
+
+          more_1 = {:next_marker => return_buckets_1.last.name, :truncated => true}
+
+          return_buckets_2 = (6..10).map do |i|
+            name = "rubysdk-bucket-#{i.to_s.rjust(3, '0')}"
+            Bucket.new(
+              :name => name,
+              :location => 'oss-cn-hangzhou',
+              :creation_time => Time.now)
+          end
+
+          more_2 = {:truncated => false}
+
+          stub_request(:get, /#{@endpoint}.*/)
+            .to_return(:body => mock_buckets(return_buckets_1, more_1)).then
+            .to_return(:body => mock_buckets(return_buckets_2, more_2))
+
+          buckets = @client.list_buckets
+
+          expect(buckets.map {|b| b.to_s}.join(";"))
+            .to eq((return_buckets_1 + return_buckets_2).map {|b| b.to_s}.join(";"))
+          expect(WebMock).to have_requested(:get, /#{@endpoint}.*/).times(2)
+        end
+
+        it "should test bucket existence" do
+          query = {'acl' => ''}
+          return_acl = ACL::PUBLIC_READ
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(:body => mock_acl(return_acl)).then
+            .to_return(:status => 404)
+
+          exist = @client.bucket_exists?(@bucket)
+          expect(exist).to be true
+
+          exist = @client.bucket_exists?(@bucket)
+          expect(exist).to be false
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil).times(2)
+        end
+
+        it "should not list buckets when endpoint is cname" do
+          cname_client = Client.new(
+            :endpoint => @endpoint,
+            :access_key_id => 'xxx',
+            :access_key_secret => 'yyy',
+            :cname => true)
+
+          expect {
+            cname_client.list_buckets
+          }.to raise_error(ClientError)
+        end
+
+        it "should use HTTPS" do
+          stub_request(:put, "https://#{bucket_url}")
+
+          https_client = Client.new(
+            :endpoint => "https://#{@endpoint}",
+            :access_key_id => 'xxx',
+            :access_key_secret => 'yyy',
+            :cname => false)
+
+          https_client.create_bucket(@bucket)
+
+          expect(WebMock).to have_requested(:put, "https://#{bucket_url}")
+        end
+      end # bucket operations
+
+    end # Client
+
+  end # OSS
+end # Aliyun