blobstore_client 0.5.0 → 1.5.0.pre.1113

data/Rakefile

@@ -1,49 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-$:.unshift(File.expand_path("../../rake", __FILE__))
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __FILE__)
-
-require "rubygems"
-require "bundler"
-Bundler.setup(:default, :test)
-
-require "rake"
-begin
-  require "rspec/core/rake_task"
-rescue LoadError
-end
-
-require "bundler_task"
-require "ci_task"
-
-gem_helper = Bundler::GemHelper.new(Dir.pwd)
-
-desc "Build Blobstore Client gem into the pkg directory"
-task "build" do
-  gem_helper.build_gem
-end
-
-desc "Build and install Blobstore Client into system gems"
-task "install" do
-  gem_helper.install_gem
-end
-
-BundlerTask.new
-
-if defined?(RSpec)
-  namespace :spec do
-    desc "Run Unit Tests"
-    rspec_task = RSpec::Core::RakeTask.new(:unit) do |t|
-      t.pattern = "spec/unit/**/*_spec.rb"
-      t.rspec_opts = %w(--format progress --colour)
-    end
-
-    CiTask.new do |task|
-      task.rspec_task = rspec_task
-    end
-  end
-
-  desc "Install dependencies and run tests"
-  task :spec => %w(spec:unit)
-end

data/spec/assets/file

@@ -1 +0,0 @@
-foobar

data/spec/spec_helper.rb

@@ -1,8 +0,0 @@
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
-
-require "rubygems"
-require "bundler"
-Bundler.setup(:default, :test)
-
-require "rspec"
-require "blobstore_client"

data/spec/unit/atmos_blobstore_client_spec.rb

@@ -1,72 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Bosh::Blobstore::AtmosBlobstoreClient do
-
-  before(:each) do
-    @atmos = mock("atmos")
-    Atmos::Store.stub!(:new).and_return(@atmos)
-    atmos_opt = {:url => "http://localhost",
-                 :uid => "uid",
-                 :secret => "secret"}
-
-    @http_client = mock("http-client")
-    ssl_opt = mock("ssl-opt")
-    ssl_opt.stub!(:verify_mode=)
-    @http_client.stub!(:ssl_config).and_return(ssl_opt)
-
-    HTTPClient.stub!(:new).and_return(@http_client)
-    @client = Bosh::Blobstore::AtmosBlobstoreClient.new(atmos_opt)
-  end
-
-  it "should create an object" do
-    data = "some content"
-    object = mock("object")
-
-    @atmos.should_receive(:create).with {|opt|
-      opt[:data].read.should eql data
-      opt[:length].should eql data.length
-    }.and_return(object)
-
-    object.should_receive(:aoid).and_return("test-key")
-
-    object_id = @client.create(data)
-    object_info = MultiJson.decode(Base64.decode64(URI::unescape(object_id)))
-    object_info["oid"].should eql("test-key")
-    object_info["sig"].should_not be_nil
-  end
-
-  it "should delete an object" do
-    object = mock("object")
-    @atmos.should_receive(:get).with(:id => "test-key").and_return(object)
-    object.should_receive(:delete)
-    id = URI::escape(Base64.encode64(MultiJson.encode({:oid => "test-key", :sig => "sig"})))
-    @client.delete(id)
-  end
-
-  it "should fetch an object" do
-    url = "http://localhost/rest/objects/test-key?uid=uid&expires=1893484800&signature=sig"
-    response = mock("response")
-    response.stub!(:status).and_return(200)
-    @http_client.should_receive(:get).with(url).and_yield("some-content").and_return(response)
-    id = URI::escape(Base64.encode64(MultiJson.encode({:oid => "test-key", :sig => "sig"})))
-    @client.get(id).should eql("some-content")
-  end
-
-  it "should refuse to create object without the password" do
-    lambda {
-      no_pass_client = Bosh::Blobstore::AtmosBlobstoreClient.new(:url => "http://localhost", :uid => "uid")
-      no_pass_client.create("foo")
-    }.should raise_error(Bosh::Blobstore::BlobstoreError)
-  end
-
-  it "should be able to read without password" do
-    no_pass_client = Bosh::Blobstore::AtmosBlobstoreClient.new(:url => "http://localhost", :uid => "uid")
-
-    url = "http://localhost/rest/objects/test-key?uid=uid&expires=1893484800&signature=sig"
-    response = mock("response")
-    response.stub!(:status).and_return(200)
-    @http_client.should_receive(:get).with(url).and_yield("some-content").and_return(response)
-    id = URI::escape(Base64.encode64(MultiJson.encode({:oid => "test-key", :sig => "sig"})))
-    no_pass_client.get(id).should eql("some-content")
-  end
-end

data/spec/unit/blobstore_client_spec.rb

@@ -1,44 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Bosh::Blobstore::Client do
-
-  it "should have a local provider" do
-    Dir.mktmpdir do |tmp|
-      bs = Bosh::Blobstore::Client.create('local', {:blobstore_path => tmp})
-      bs.should be_instance_of Bosh::Blobstore::LocalClient
-    end
-  end
-
-  it "should have an simple provider" do
-    bs = Bosh::Blobstore::Client.create('simple', {})
-    bs.should be_instance_of Bosh::Blobstore::SimpleBlobstoreClient
-  end
-
-  it "should have an atmos provider" do
-    bs = Bosh::Blobstore::Client.create('atmos', {})
-    bs.should be_instance_of Bosh::Blobstore::AtmosBlobstoreClient
-  end
-
-  it "should have an s3 provider" do
-    options = {:access_key_id => "foo", :secret_access_key => "bar"}
-    bs = Bosh::Blobstore::Client.create('s3', options)
-    bs.should be_instance_of Bosh::Blobstore::S3BlobstoreClient
-  end
-
-  it "should pick S3 provider when S3 is used without credentials" do
-    bs = Bosh::Blobstore::Client.create('s3', {:bucket_name => "foo"})
-    bs.should be_instance_of Bosh::Blobstore::S3BlobstoreClient
-  end
-
-  it "should have an swift provider" do
-    bs = Bosh::Blobstore::Client.create('swift', {})
-    bs.should be_instance_of Bosh::Blobstore::SwiftBlobstoreClient
-  end
-
-  it "should raise an exception on an unknown client" do
-    lambda {
-      bs = Bosh::Blobstore::Client.create('foobar', {})
-    }.should raise_error /^Invalid client provider/
-  end
-
-end

data/spec/unit/local_client_spec.rb

@@ -1,78 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Bosh::Blobstore::LocalClient do
-
-  before(:each) do
-    @tmp = Dir.mktmpdir
-    @options = {"blobstore_path" => @tmp}
-  end
-
-  after(:each) do
-    FileUtils.rm_rf(@tmp)
-  end
-
-  it "should require blobstore_path option" do
-    lambda {
-      client = Bosh::Blobstore::LocalClient.new({})
-    }.should raise_error
-  end
-
-  it "should create blobstore_path direcory if it doesn't exist'" do
-    dir = File.join(@tmp, "blobstore")
-    client = Bosh::Blobstore::LocalClient.new({"blobstore_path" => dir})
-    File.directory?(dir).should be_true
-  end
-
-  describe "operations" do
-
-    describe "get" do
-      it "should retrive the correct contents" do
-        File.open(File.join(@tmp, 'foo'), 'w') do |fh|
-          fh.puts("bar")
-        end
-
-        client = Bosh::Blobstore::LocalClient.new(@options)
-        client.get("foo").should == "bar\n"
-      end
-    end
-
-    describe "create" do
-      it "should store a file" do
-        test_file = File.join(File.dirname(__FILE__), "../assets/file")
-        client = Bosh::Blobstore::LocalClient.new(@options)
-        fh = File.open(test_file)
-        id = client.create(fh)
-        fh.close
-        original = File.new(test_file).readlines
-        stored = File.new(File.join(@tmp, id)).readlines
-        stored.should == original
-      end
-
-      it "should store a string" do
-        client = Bosh::Blobstore::LocalClient.new(@options)
-        string = "foobar"
-        id = client.create(string)
-        stored = File.new(File.join(@tmp, id)).readlines
-        stored.should == [string]
-      end
-    end
-
-    describe "delete" do
-      it "should delete an id" do
-        client = Bosh::Blobstore::LocalClient.new(@options)
-        string = "foobar"
-        id = client.create(string)
-        client.delete(id)
-        File.exist?(File.join(@tmp, id)).should_not be_true
-      end
-
-      it "should raise NotFound error when trying to delete a missing id" do
-        client = Bosh::Blobstore::LocalClient.new(@options)
-        lambda {
-          client.delete("missing")
-          }.should raise_error Bosh::Blobstore::NotFound
-      end
-    end
-
-  end
-end

data/spec/unit/s3_blobstore_client_spec.rb

@@ -1,282 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Bosh::Blobstore::S3BlobstoreClient do
-
-  before(:each) do
-    @aws_mock_options = {
-      :access_key_id     => "KEY",
-      :secret_access_key => "SECRET",
-      :use_ssl           => true,
-      :port              => 443
-    }
-  end
-
-  def s3_blobstore(options)
-    Bosh::Blobstore::S3BlobstoreClient.new(options)
-  end
-
-  describe "read only mode" do
-    it "does not establish S3 connection on creation" do
-      AWS::S3::Base.should_not_receive(:establish_connection!)
-      @client = s3_blobstore("bucket_name" => "test")
-    end
-
-    it "should raise an error on deletion" do
-      @client = s3_blobstore("bucket_name" => "test")
-      lambda {
-        @client.delete("id")
-      }.should raise_error "unsupported action"
-    end
-
-    it "should raise an error on creation" do
-      @client = s3_blobstore("bucket_name" => "test")
-      lambda {
-        @client.create("id")
-      }.should raise_error "unsupported action"
-    end
-
-    it "should fetch objects" do
-      simple = mock("simple", :to_ary => nil, :get_file => %w[foo id])
-      Bosh::Blobstore::SimpleBlobstoreClient.should_receive(:new).and_return(simple)
-      @client = s3_blobstore("bucket_name" => "test")
-      @client.get_file("foo", "id")
-    end
-  end
-
-  describe "options" do
-
-    it "establishes S3 connection on creation" do
-      AWS::S3::Base.should_receive(:establish_connection!).with(@aws_mock_options)
-
-      @client = s3_blobstore("encryption_key"    => "bla",
-                             "bucket_name"       => "test",
-                             "access_key_id"     => "KEY",
-                             "secret_access_key" => "SECRET")
-
-      @client.encryption_key.should == "bla"
-      @client.bucket_name.should == "test"
-    end
-
-    it "supports Symbol option keys too" do
-      AWS::S3::Base.should_receive(:establish_connection!).with(@aws_mock_options)
-
-      @client = s3_blobstore(:encryption_key    => "bla",
-                             :bucket_name       => "test",
-                             :access_key_id     => "KEY",
-                             :secret_access_key => "SECRET")
-
-      @client.encryption_key.should == "bla"
-      @client.bucket_name.should == "test"
-    end
-  end
-
-  describe "operations" do
-
-    before :each do
-      @client = s3_blobstore(:encryption_key    => "bla",
-                             :bucket_name       => "test",
-                             :access_key_id     => "KEY",
-                             :secret_access_key => "SECRET")
-    end
-
-    describe "create" do
-
-      it "should create an object" do
-        encrypted_file = nil
-        @client.should_receive(:generate_object_id).and_return("object_id")
-        @client.should_receive(:encrypt_stream).with { |from_file, _|
-          from_file.read.should eql("some content")
-          true
-        }.and_return {|_, to_file|
-          encrypted_file = to_file
-          nil
-        }
-
-        AWS::S3::S3Object.should_receive(:store).with { |key, data, bucket|
-          key.should eql("object_id")
-          data.path.should eql(encrypted_file.path)
-          bucket.should eql("test")
-          true
-        }
-        @client.create("some content").should eql("object_id")
-      end
-
-      it "should not encrypt when encryption key is missing" do
-        client = s3_blobstore(:bucket_name       => "test",
-                              :access_key_id     => "KEY",
-                              :secret_access_key => "SECRET")
-        client.should_receive(:generate_object_id).and_return("object_id")
-        client.should_not_receive(:encrypt_stream)
-
-        AWS::S3::S3Object.should_receive(:store)
-        client.create("some content").should eql("object_id")
-      end
-
-      it "should raise an exception when there is an error creating an object" do
-        encrypted_file = nil
-        @client.should_receive(:generate_object_id).and_return("object_id")
-        @client.should_receive(:encrypt_stream).with { |from_file, _|
-          from_file.read.should eql("some content")
-          true
-        }.and_return {|_, to_file|
-          encrypted_file = to_file
-          nil
-        }
-
-        AWS::S3::S3Object.should_receive(:store).with { |key, data, bucket|
-          key.should eql("object_id")
-          data.path.should eql(encrypted_file.path)
-          bucket.should eql("test")
-          true
-        }.and_raise(AWS::S3::S3Exception.new("Epic Fail"))
-        lambda {
-          @client.create("some content")
-        }.should raise_error(Bosh::Blobstore::BlobstoreError, "Failed to create object, S3 response error: Epic Fail")
-      end
-
-    end
-
-    describe "fetch" do
-
-      it "should fetch an object" do
-        mock_s3_object = mock("s3_object")
-        mock_s3_object.stub!(:value).and_yield("ENCRYPTED")
-        AWS::S3::S3Object.should_receive(:find).with("object_id", "test").and_return(mock_s3_object)
-        @client.should_receive(:decrypt_stream).with { |from, _|
-          encrypted = ""
-          from.call(lambda {|segment| encrypted << segment})
-          encrypted.should eql("ENCRYPTED")
-          true
-        }.and_return {|_, to|
-          to.write("stuff")
-        }
-        @client.get("object_id").should == "stuff"
-      end
-
-      it "should not decrypt when encryption key is missing" do
-        client = s3_blobstore(:bucket_name       => "test",
-                              :access_key_id     => "KEY",
-                              :secret_access_key => "SECRET")
-
-        mock_s3_object = mock("s3_object")
-        mock_s3_object.stub!(:value).and_yield("stuff")
-        AWS::S3::S3Object.should_receive(:find).with("object_id", "test").and_return(mock_s3_object)
-        client.should_not_receive(:decrypt_stream)
-
-        client.get("object_id").should == "stuff"
-      end
-
-      it "should raise an exception when there is an error fetching an object" do
-        AWS::S3::S3Object.should_receive(:find).with("object_id", "test").and_raise(AWS::S3::S3Exception.new("Epic Fail"))
-        lambda {
-          @client.get("object_id")
-        }.should raise_error(Bosh::Blobstore::BlobstoreError, "Failed to find object 'object_id', S3 response error: Epic Fail")
-      end
-
-      it "should raise more specific NotFound exception when object is not found" do
-        AWS::S3::S3Object.should_receive(:find).with("object_id", "test").and_raise(AWS::S3::NoSuchKey.new("NO KEY", "test"))
-        lambda {
-          @client.get("object_id")
-        }.should raise_error(Bosh::Blobstore::BlobstoreError, "S3 object 'object_id' not found")
-      end
-
-    end
-
-    describe "delete" do
-
-      it "should delete an object" do
-        AWS::S3::S3Object.should_receive(:delete).with("object_id", "test")
-        @client.delete("object_id")
-      end
-
-      it "should raise an exception when there is an error deleting an object" do
-        AWS::S3::S3Object.should_receive(:delete).with("object_id", "test").and_raise(AWS::S3::S3Exception.new("Epic Fail"))
-        lambda {
-          @client.delete("object_id")
-        }.should raise_error(Bosh::Blobstore::BlobstoreError, "Failed to delete object 'object_id', S3 response error: Epic Fail")
-      end
-
-    end
-
-    describe "encryption" do
-
-      before :each do
-        @from_path = File.join(Dir::tmpdir, "from-#{UUIDTools::UUID.random_create}")
-        @to_path = File.join(Dir::tmpdir, "to-#{UUIDTools::UUID.random_create}")
-      end
-
-      after :each do
-        FileUtils.rm_f(@from_path)
-        FileUtils.rm_f(@to_path)
-      end
-
-      it "encrypt/decrypt works as long as key is the same" do
-        File.open(@from_path, "w") { |f| f.write("clear text") }
-        File.open(@from_path, "r") do |from|
-          File.open(@to_path, "w") do |to|
-            @client.send(:encrypt_stream, from, to)
-          end
-        end
-
-        Base64.encode64(File.read(@to_path)).should eql("XCUKDXXzjh43DmNylgVpQQ==\n")
-
-        File.open(@from_path, "w") { |f| f.write(File.read(@to_path)) }
-        File.open(@from_path, "r") do |from|
-          File.open(@to_path, "w") do |to|
-            @client.send(:decrypt_stream, from, to)
-          end
-        end
-
-        File.read(@to_path).should eql("clear text")
-      end
-
-      it "encrypt/decrypt doesn't have padding issues for very small inputs" do
-        File.open(@from_path, "w") { |f| f.write("c") }
-        File.open(@from_path, "r") do |from|
-          File.open(@to_path, "w") do |to|
-            @client.send(:encrypt_stream, from, to)
-          end
-        end
-
-        Base64.encode64(File.read(@to_path)).should eql("S1ZnX5gPfm/rQbRCcShHSg==\n")
-
-        File.open(@from_path, "w") { |f| f.write(File.read(@to_path)) }
-        File.open(@from_path, "r") do |from|
-          File.open(@to_path, "w") do |to|
-            @client.send(:decrypt_stream, from, to)
-          end
-        end
-
-        File.read(@to_path).should eql("c")
-      end
-
-      it "should raise an exception if incorrect encryption key is used" do
-        File.open(@from_path, "w") { |f| f.write("clear text") }
-        File.open(@from_path, "r") do |from|
-          File.open(@to_path, "w") do |to|
-            @client.send(:encrypt_stream, from, to)
-          end
-        end
-
-        Base64.encode64(File.read(@to_path)).should eql("XCUKDXXzjh43DmNylgVpQQ==\n")
-
-        client2 = s3_blobstore(:encryption_key    => "zzz",
-                               :bucket_name       => "test",
-                               :access_key_id     => "KEY",
-                               :secret_access_key => "SECRET")
-
-        File.open(@from_path, "w") { |f| f.write(File.read(@to_path)) }
-        File.open(@from_path, "r") do |from|
-          File.open(@to_path, "w") do |to|
-            lambda {
-              client2.send(:decrypt_stream, from, to)
-            }.should raise_error(Bosh::Blobstore::BlobstoreError, "Decryption error: bad decrypt")
-          end
-        end
-      end
-
-    end
-
-  end
-
-end