qiniu_jxb_fix 6.4.2

data/spec/qiniu/qiniu_spec.rb

@@ -0,0 +1,321 @@
+# -*- encoding: utf-8 -*-
+
+require 'digest/sha1'
+require 'spec_helper'
+require 'qiniu'
+require 'qiniu/exceptions'
+
+module Qiniu
+  describe Qiniu do
+
+    before :all do
+      @bucket = 'rubysdk'
+
+      @test_image_bucket = @bucket
+
+      @key = Digest::SHA1.hexdigest Time.now.to_s
+      @key = make_unique_key_in_bucket(@key)
+
+      @key2 = @key + rand(100).to_s
+      #@domain = @bucket + '.dn.qbox.me'
+
+      @test_image_key = 'image_logo_for_test.png'
+      local_file = File.expand_path('./' + @test_image_key, File.dirname(__FILE__))
+      puts local_file.inspect
+      upopts = {:scope => @test_image_bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
+      uptoken = Qiniu.generate_upload_token(upopts)
+      data = Qiniu.upload_file :uptoken => uptoken, :file => local_file, :bucket => @test_image_bucket, :key => @test_image_key
+      puts data.inspect
+    end
+
+    after :all do
+    end
+
+    context "get_url" do
+      it 'should works' do
+        key = 'Fg8ne_KBJpTrCqlvaZ9cPl68DK4N'
+        primitive_url = Qiniu.get(@bucket, key)['url'] rescue nil
+        return nil if primitive_url.nil?
+        #puts Qiniu::Auth.authorize_download_url(primitive_url) 
+        puts Qiniu::Auth.authorize_download_url_2('testqiniu.jiaoxuebang.cn', key)
+      end
+    end
+
+    context ".buckets" do
+      it "should works" do
+        result = Qiniu.buckets
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".set_protected" do
+      it "should works" do
+        result = Qiniu.set_protected(@bucket, 1)
+        expect(result).to eq(true)
+        puts result.inspect
+      end
+    end
+
+    context ".set_separator" do
+      it "should works" do
+        result = Qiniu.set_separator(@bucket, "-")
+        expect(result).to eq(true)
+        puts result.inspect
+      end
+    end
+
+    context ".set_style" do
+      it "should works" do
+        result = Qiniu.set_style(@bucket, "small.jpg", "imageMogr/auto-orient/thumbnail/!120x120r/gravity/center/crop/!120x120/quality/80")
+        expect(result).to eq(true)
+        puts result.inspect
+      end
+    end
+
+    context ".unset_style" do
+      it "should works" do
+        result = Qiniu.unset_style(@bucket, "small.jpg")
+        expect(result).to eq(true)
+        puts result.inspect
+      end
+    end
+
+    context ".upload_file" do
+      it "should works" do
+        uptoken_opts = {:scope => @bucket, :escape => 0}
+        upload_opts = {
+          :uptoken => Qiniu.generate_upload_token(uptoken_opts),
+          :file => __FILE__,
+          :bucket => @bucket,
+          :key => @key,
+          :enable_crc32_check => true
+        }
+        result = Qiniu.upload_file(upload_opts)
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+
+      it "should raise MissingArgsError" do
+        uptoken_opts = {:scope => @bucket, :escape => 0}
+        upload_opts = {
+          :uptoken => Qiniu.generate_upload_token(uptoken_opts),
+          :file => __FILE__,
+          :key => @key,
+          :enable_crc32_check => true
+        }
+        lambda { Qiniu.upload_file(upload_opts) }.should raise_error(MissingArgsError)
+      end
+
+      it "should raise NoSuchFileError" do
+        uptoken_opts = {:scope => @bucket, :escape => 0}
+        upload_opts = {
+          :uptoken => Qiniu.generate_upload_token(uptoken_opts),
+          :file => 'no_this_file',
+          :bucket => @bucket,
+          :key => @key,
+          :enable_crc32_check => true
+        }
+        lambda { Qiniu.upload_file(upload_opts) }.should raise_error(NoSuchFileError)
+      end
+    end
+
+    context ".resumable_upload_file" do
+      it "should works" do
+        # generate bigfile for testing
+        localfile = "test_bigfile"
+        File.open(localfile, "w"){|f| 5242888.times{f.write(rand(9).to_s)}}
+        key = Digest::SHA1.hexdigest(localfile+Time.now.to_s)
+        # generate the upload token
+        uptoken_opts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com", :escape => 0}
+        uptoken = Qiniu.generate_upload_token(uptoken_opts)
+        # uploading
+        upload_opts = {
+            :uptoken => uptoken,
+            :file => localfile,
+            :bucket => @bucket,
+            :key => key
+        }
+        #uploading
+        result1 = Qiniu.upload_file(upload_opts)
+        #drop the bigfile
+        File.unlink(localfile) if File.exists?(localfile)
+        #expect
+        puts result1.inspect
+        expect(result1).to_not be_empty
+        #stat
+        result2 = Qiniu.stat(@bucket, key)
+        puts result2.inspect
+        expect(result2).to_not be_empty
+        #delete
+        result3 = Qiniu.delete(@bucket, key)
+        puts result3.inspect
+        expect(result3).to eq(true)
+      end
+    end
+
+    context ".stat" do
+      it "should works" do
+        result = Qiniu.stat(@bucket, @key)
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".get" do
+      it "should works" do
+        result = Qiniu.get(@bucket, @key, "qiniu_spec.rb", 10)
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".download" do
+      it "should works" do
+        result = Qiniu.download(@bucket, @key, "rs_spec.rb", 10)
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".batch" do
+      it "should works" do
+        result = Qiniu.batch("stat", @bucket, [@key])
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".batch_stat" do
+      it "should works" do
+        result = Qiniu.batch_stat(@bucket, [@key])
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".batch_get" do
+      it "should works" do
+        result = Qiniu.batch_get(@bucket, [@key])
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".batch_download" do
+      it "should works" do
+        result = Qiniu.batch_download(@bucket, [@key])
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+    end
+
+=begin
+    context ".batch_copy" do
+      it "should works" do
+        result = Qiniu.batch_copy [@bucket, @key, @bucket, @key2]
+        result.should_not be_false
+
+        #result2 = Qiniu.stat(@bucket, @key2)
+        #result2.should_not be_false
+      end
+    end
+
+    context ".batch_move" do
+      it "should works" do
+        result = Qiniu.batch_move [@bucket, @key, @bucket, @key2]
+        result.should_not be_false
+
+        #result2 = Qiniu.stat(@bucket, @key2)
+        #result2.should_not be_false
+
+        result3 = Qiniu.batch_move [@bucket, @key2, @bucket, @key]
+        result3.should_not be_false
+      end
+    end
+=end
+
+    context ".move" do
+      it "should works" do
+        result = Qiniu.move(@bucket, @key, @bucket, @key2)
+        expect(result).to eq(true)
+
+        result2 = Qiniu.stat(@bucket, @key2)
+        expect(result2).to_not be_empty
+
+        result3 = Qiniu.move(@bucket, @key2, @bucket, @key)
+        expect(result3).to eq(true)
+      end
+    end
+
+    context ".copy" do
+      it "should works" do
+        result = Qiniu.copy(@bucket, @key, @bucket, @key2)
+        expect(result).to eq(true)
+
+        result3 = Qiniu.delete(@bucket, @key2)
+        expect(result3).to eq(true)
+      end
+    end
+
+    context ".delete" do
+      it "should works" do
+        result = Qiniu.delete(@bucket, @key)
+        expect(result).to eq(true)
+      end
+    end
+
+    context ".image_info" do
+      it "should works" do
+        data = Qiniu.get(@test_image_bucket, @test_image_key)
+        expect(data).to_not be_empty
+        puts data.inspect
+        result = Qiniu.image_info(data["url"])
+        expect(result).to_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".image_mogrify_save_as" do
+      it "should works" do
+        data = Qiniu.get(@test_image_bucket, @test_image_key)
+        expect(data).to_not be_empty
+        puts data.inspect
+
+        dest_key = "cropped-" + @test_image_key
+        src_img_url = data["url"]
+        mogrify_options = {
+          :thumbnail => "!120x120>",
+          :gravity => "center",
+          :crop => "!120x120a0a0",
+          :quality => 85,
+          :rotate => 45,
+          :format => "jpg",
+          :auto_orient => true
+        }
+        result2 = Qiniu.image_mogrify_save_as(@test_image_bucket, dest_key, src_img_url, mogrify_options)
+        expect(result2).to_not be_empty
+        puts result2.inspect
+      end
+    end
+
+    context ".generate_upload_token" do
+      it "should works" do
+        data = Qiniu.generate_upload_token({:scope => @bucket, :expires_in => 3600, :escape => 0})
+        data.should_not be_empty
+        puts data.inspect
+        data.split(":").length.should == 3
+      end
+    end
+
+    context ".generate_download_token" do
+      it "should works" do
+        data = Qiniu.generate_download_token({:expires_in => 1, :pattern => 'http://*.dn.qbox.me/*'})
+        data.should_not be_empty
+        puts data.inspect
+        data.split(":").length.should == 3
+      end
+    end
+
+  end
+end # module Qiniu

data/spec/qiniu/tokens/qbox_token_spec.rb

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/tokens/qbox_token'
+
+module Qiniu
+  module RS
+    describe QboxToken do
+      before :all do
+        @qbox_token = QboxToken.new(:url => 'www.qiniu.com?key1=value1',
+                                    :params => { :key2 => 'value2' })
+        @qbox_token.access_key = 'access_key'
+        @qbox_token.secret_key = 'secret_key'
+      end
+
+      context "#generate_token" do
+        it "should generate token" do
+          @qbox_token.generate_token.should_not be_empty
+        end
+      end
+
+      context "#generate_signature" do
+        it "should generate signature" do
+          @qbox_token.generate_signature.should == "www.qiniu.com?key1=value1\nkey2=value2"
+        end
+      end
+    end
+  end
+end

data/spec/qiniu/upload_spec.rb

@@ -0,0 +1,301 @@
+# -*- encoding: utf-8 -*-
+# vim: sw=2 ts=2
+
+require 'spec_helper'
+require 'qiniu/auth'
+require 'qiniu/storage'
+require 'digest/sha1'
+
+module Qiniu
+  module Storage
+    describe Storage do
+
+      before :all do
+        @bucket = 'rubysdk'
+
+        @key = Digest::SHA1.hexdigest((Time.now.to_i+rand(100)).to_s)
+        @key = make_unique_key_in_bucket(@key)
+        puts "key=#{@key}"
+
+        @localfile_5m = "5M.txt"
+        File.open(@localfile_5m, "w"){|f| 5242888.times{ f.write(rand(9).to_s) }}
+        @key_5m = Digest::SHA1.hexdigest(@localfile_5m+Time.now.to_s)
+        @key_5m = make_unique_key_in_bucket(@key_5m)
+        puts "key_5m=#{@key_5m}"
+
+        @localfile_4m = "4M.txt"
+        File.open(@localfile_4m, "w"){|f| (1 << 22).times{ f.write(rand(9).to_s) }}
+        @key_4m = Digest::SHA1.hexdigest(@localfile_4m+Time.now.to_s)
+        @key_4m = make_unique_key_in_bucket(@key_4m)
+        puts "key_4m=#{@key_4m}"
+
+        @localfile_8m = "8M.txt"
+        File.open(@localfile_8m, "w"){|f| (1 << 23).times{ f.write(rand(9).to_s) }}
+        @key_8m = Digest::SHA1.hexdigest(@localfile_8m+Time.now.to_s)
+        @key_8m = make_unique_key_in_bucket(@key_8m)
+        puts "key_8m=#{@key_8m}"
+
+        @localfile_1m = "1M.txt"
+        File.open(@localfile_1m, "w"){|f| (1 << 20).times{ f.write(rand(9).to_s) }}
+        @key_1m = Digest::SHA1.hexdigest(@localfile_1m+Time.now.to_s)
+        @key_1m = make_unique_key_in_bucket(@key_1m)
+        puts "key_1m=#{@key_1m}"
+      end
+
+      after :all do
+        ### 清除本地临时文件
+        File.unlink(@localfile_5m) if File.exists?(@localfile_5m)
+        File.unlink(@localfile_4m) if File.exists?(@localfile_4m)
+        File.unlink(@localfile_8m) if File.exists?(@localfile_8m)
+        File.unlink(@localfile_1m) if File.exists?(@localfile_1m)
+      end
+
+      ### 测试单文件直传
+      context ".upload_with_token" do
+        it "should works" do
+          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
+          uptoken = Qiniu.generate_upload_token(upopts)
+          code, data, raw_headers = Qiniu::Storage.upload_with_token(
+            uptoken,
+            __FILE__,
+            @bucket,
+            @key,
+            nil,
+            nil,
+            nil,
+            true
+          )
+          code.should == 200
+          puts data.inspect
+          puts raw_headers.inspect
+        end
+      end
+
+      context ".stat" do
+        it "should exists" do
+          code, data = Qiniu::Storage.stat(@bucket, @key)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::Storage.delete(@bucket, @key)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".upload_with_token_2" do
+        it "should works" do
+          upopts = {:scope => @bucket, :expires_in => 3600, :endUser => "why404@gmail.com"}
+          uptoken = Qiniu.generate_upload_token(upopts)
+
+          code, data, raw_headers = Qiniu::Storage.upload_with_token_2(
+            uptoken,
+            __FILE__,
+            @key
+          )
+
+          code.should == 200
+          puts data.inspect
+          puts raw_headers.inspect
+        end
+      end # .upload_with_token_2
+
+      context ".stat" do
+        it "should exists" do
+          code, data = Qiniu::Storage.stat(@bucket, @key)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::Storage.delete(@bucket, @key)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".upload_with_put_policy" do
+        it "should works" do
+          pp = Qiniu::Auth::PutPolicy.new(@bucket, @key)
+          pp.end_user = "why404@gmail.com"
+          puts 'put_policy=' + pp.to_json
+
+          code, data, raw_headers = Qiniu::Storage.upload_with_put_policy(
+            pp,
+            __FILE__,
+            @key + '-not-equal'
+          )
+          code.should_not == 200
+          puts data.inspect
+          puts raw_headers.inspect
+
+          code, data, raw_headers = Qiniu::Storage.upload_with_put_policy(
+            pp,
+            __FILE__,
+            @key
+          )
+
+          code.should == 200
+          puts data.inspect
+          puts raw_headers.inspect
+        end
+      end # .upload_with_put_policy
+
+      context ".stat" do
+        it "should exists" do
+          code, data = Qiniu::Storage.stat(@bucket, @key)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::Storage.delete(@bucket, @key)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      ### 测试断点续上传
+      context ".resumable_upload_with_token" do
+        it "should works" do
+          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
+          uptoken = Qiniu.generate_upload_token(upopts)
+          code, data, raw_headers = Qiniu::Storage.resumable_upload_with_token(
+            uptoken,
+            @localfile_5m,
+            @bucket,
+            @key_5m
+          )
+          (code/100).should == 2
+          puts data.inspect
+          puts raw_headers.inspect
+          puts "key_5m=#{@key_5m}"
+        end
+      end
+
+      context ".stat" do
+        it "should exists" do
+          code, data = Qiniu::Storage.stat(@bucket, @key_5m)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::Storage.delete(@bucket, @key_5m)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".resumable_upload_with_token2" do
+        it "should works" do
+          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
+          uptoken = Qiniu.generate_upload_token(upopts)
+          code, data, raw_headers = Qiniu::Storage.resumable_upload_with_token(
+            uptoken,
+            @localfile_4m,
+            @bucket,
+            @key_4m
+          )
+          (code/100).should == 2
+          puts data.inspect
+          puts raw_headers.inspect
+          puts "key_4m=#{@key_4m}"
+        end
+      end
+
+      context ".stat" do
+        it "should exists" do
+          code, data = Qiniu::Storage.stat(@bucket, @key_4m)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::Storage.delete(@bucket, @key_4m)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".resumable_upload_with_token3" do
+        it "should works" do
+          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
+          uptoken = Qiniu.generate_upload_token(upopts)
+          code, data, raw_headers = Qiniu::Storage.resumable_upload_with_token(
+            uptoken,
+            @localfile_8m,
+            @bucket,
+            @key_8m
+          )
+          (code/100).should == 2
+          puts data.inspect
+          puts raw_headers.inspect
+          puts "key_8m=#{@key_8m}"
+        end
+      end
+
+      context ".stat" do
+        it "should exists" do
+          code, data = Qiniu::Storage.stat(@bucket, @key_8m)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::Storage.delete(@bucket, @key_8m)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".resumable_upload_with_token4" do
+        it "should works" do
+          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
+          uptoken = Qiniu.generate_upload_token(upopts)
+          code, data, raw_headers = Qiniu::Storage.resumable_upload_with_token(
+            uptoken,
+            @localfile_1m,
+            @bucket,
+            @key_1m
+          )
+          (code/100).should == 2
+          puts data.inspect
+          puts raw_headers.inspect
+          puts "key_1m=#{@key_1m}"
+        end
+      end
+
+      context ".stat" do
+        it "should exists" do
+          code, data = Qiniu::Storage.stat(@bucket, @key_1m)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::Storage.delete(@bucket, @key_1m)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+    end
+  end # module Storage
+end # module Qiniu

data/spec/qiniu/utils_spec.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'fakeweb'
+require 'qiniu/utils'
+
+module Qiniu
+  module RS
+    describe Utils do
+      before :all do
+        Struct.new("Response", :code, :body)
+      end
+
+      after :each do
+        FakeWeb.clean_registry
+        FakeWeb.allow_net_connect = true
+      end
+
+      context "safe_json_parse" do
+        it "should works" do
+          Utils.safe_json_parse('{"foo": "bar"}').should == {"foo" => "bar"}
+          Utils.safe_json_parse('{}').should == {}
+        end
+      end
+
+      context ".send_request_with" do
+        it "should works" do
+          FakeWeb.allow_net_connect = false
+          FakeWeb.register_uri(:get, "http://develoepr.qiniu.com/", :body => {:abc => 123}.to_json)
+          res = Utils.send_request_with 'http://develoepr.qiniu.com/', nil, :method => :get
+          res.should == [200, {"abc" => 123}, {}]
+        end
+
+        [400, 500].each do |code|
+          context "upstream return http #{code}" do
+            it "should raise RestClient::RequestFailed" do
+              FakeWeb.allow_net_connect = false
+              FakeWeb.register_uri(:get, "http://develoepr.qiniu.com/", :status => code)
+              lambda {
+                res = Utils.send_request_with 'http://develoepr.qiniu.com/', nil, :method => :get
+              }.should raise_error RestClient::RequestFailed
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/qiniu/version_spec.rb

@@ -0,0 +1,10 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/version'
+
+describe Qiniu::Version do
+  it "should has a VERSION" do
+    Qiniu::Version.to_s.should =~ /^\d+\.\d+\.\d+?$/
+  end
+end