seomoz-riak-client 1.0.0.pre

data/spec/riak/beefcake_protobuffs_backend_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'riak/client/beefcake/messages'
+
+describe Riak::Client::BeefcakeProtobuffsBackend do
+  before :each do
+    @client = Riak::Client.new
+    @backend = Riak::Client::BeefcakeProtobuffsBackend.new(@client)
+    @backend.instance_variable_set(:@server_config, {})
+  end
+
+  it "should only write to the socket one time per request" do
+    exp_bucket, exp_keys = 'foo', ['bar']
+    mock_socket = mock("mock TCP socket")
+
+    @backend.stub!(:socket).and_return(mock_socket)
+    mock_socket.should_receive(:write).exactly(1).with do |param|
+      len, code = param[0,5].unpack("NC")
+      req = Riak::Client::BeefcakeProtobuffsBackend::RpbListKeysReq.decode(param[5..-1])
+      code == 17 && req.bucket == exp_bucket
+    end
+
+    responses = Array.new(2) do |index|
+      resp = Riak::Client::BeefcakeProtobuffsBackend::RpbListKeysResp.new
+      if index == 0
+        resp.keys = exp_keys
+      else
+        resp.done = true
+      end
+      resp
+    end
+
+    responses.each do |response|
+      encoded_response = response.encode
+      mock_socket.should_receive(:read).exactly(1).with(5).and_return([1 + encoded_response.length, 18].pack("NC"))
+      mock_socket.should_receive(:read).exactly(1).with(encoded_response.length).and_return(encoded_response)
+    end
+
+    @backend.list_keys(exp_bucket).should == exp_keys
+  end
+end
+
+describe Riak::Client::BeefcakeProtobuffsBackend, '#mapred' do
+  before(:each) do
+    @client = Riak::Client.new
+    @backend = Riak::Client::BeefcakeProtobuffsBackend.new(@client)
+    @backend.instance_variable_set(:@server_config, {})
+  end
+  
+  it "should not return nil for previous phases that don't return anything" do
+    socket = stub(:socket).as_null_object
+    socket.stub(:read).and_return(stub(:socket_header, :unpack => [2, 24]), stub(:socket_message), stub(:socket_header_2, :unpack => [0, 1]))
+    message = stub(:message, :phase => 1, :response => [{}].to_json)
+    message.stub(:done).and_return(false, true)
+    Riak::Client::BeefcakeProtobuffsBackend::RpbMapRedResp.stub(:decode => message)
+    TCPSocket.stub(:new => socket)
+    
+    @backend.mapred('').should == [{}]
+  end
+end

data/spec/riak/bucket_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+describe Riak::Bucket do
+  before :each do
+    @client = Riak::Client.new
+    @backend = mock("Backend")
+    @client.stub!(:backend).and_return(@backend)
+    @bucket = Riak::Bucket.new(@client, "foo")
+  end
+
+  describe "when initializing" do
+    it "should require a client and a name" do
+      lambda { Riak::Bucket.new }.should raise_error
+      lambda { Riak::Bucket.new(@client) }.should raise_error
+      lambda { Riak::Bucket.new("foo") }.should raise_error
+      lambda { Riak::Bucket.new("foo", @client) }.should raise_error
+      lambda { Riak::Bucket.new(@client, "foo") }.should_not raise_error
+    end
+
+    it "should set the client and name attributes" do
+      bucket = Riak::Bucket.new(@client, "foo")
+      bucket.client.should == @client
+      bucket.name.should == "foo"
+    end
+  end
+
+  describe "accessing keys" do
+    it "should list the keys" do
+      @backend.should_receive(:list_keys).with(@bucket).and_return(["bar"])
+      @bucket.keys.should == ["bar"]
+    end
+
+    it "should allow streaming keys through block" do
+      @backend.should_receive(:list_keys).with(@bucket).and_yield([]).and_yield(["bar"]).and_yield(["baz"])
+      all_keys = []
+      @bucket.keys do |list|
+        all_keys.concat(list)
+      end
+      all_keys.should == ["bar", "baz"]
+    end
+
+    it "should not cache the list of keys" do
+      @backend.should_receive(:list_keys).with(@bucket).twice.and_return(["bar"])
+      2.times { @bucket.keys.should == ['bar'] }
+    end
+
+    it "should warn about the expense of list-keys when warnings are not disabled" do
+      Riak.disable_list_keys_warnings = false
+      @backend.stub!(:list_keys).and_return(%w{test test2})
+      @bucket.should_receive(:warn)
+      @bucket.keys
+      Riak.disable_list_keys_warnings = true
+    end
+  end
+
+  describe "setting the bucket properties" do
+    it "should prefetch the properties when they are not present" do
+      @backend.stub!(:set_bucket_props)
+      @backend.should_receive(:get_bucket_props).with(@bucket).and_return({"name" => "foo"})
+      @bucket.props = {"precommit" => []}
+    end
+
+    it "should set the new properties on the bucket" do
+      @bucket.instance_variable_set(:@props, {}) # Pretend they are there
+      @backend.should_receive(:set_bucket_props).with(@bucket, { :name => "foo" })
+      @bucket.props = { :name => "foo" }
+    end
+
+    it "should raise an error if an invalid type is given" do
+      lambda { @bucket.props = "blah" }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "fetching the bucket properties" do
+    it "should fetch properties on first access" do
+      @bucket.instance_variable_get(:@props).should be_nil
+      @backend.should_receive(:get_bucket_props).with(@bucket).and_return({"name" => "foo"})
+      @bucket.props.should == {"name" => "foo"}
+    end
+
+    it "should memoize fetched properties" do
+      @backend.should_receive(:get_bucket_props).once.with(@bucket).and_return({"name" => "foo"})
+      @bucket.props.should == {"name" => "foo"}
+      @bucket.props.should == {"name" => "foo"}
+    end
+  end
+
+  describe "fetching an object" do
+    it "should fetch the object via the backend" do
+      @backend.should_receive(:fetch_object).with(@bucket, "db", nil).and_return(nil)
+      @bucket.get("db")
+    end
+
+    it "should use the specified R quroum" do
+      @backend.should_receive(:fetch_object).with(@bucket, "db", 2).and_return(nil)
+      @bucket.get("db", :r => 2)
+    end
+  end
+
+  describe "creating a new blank object" do
+    it "should instantiate the object with the given key, default to JSON" do
+      obj = @bucket.new('bar')
+      obj.should be_kind_of(Riak::RObject)
+      obj.key.should == 'bar'
+      obj.content_type.should == 'application/json'
+    end
+  end
+
+  describe "fetching or creating a new object" do
+    it "should return the existing object if present" do
+      @object = mock("RObject")
+      @backend.should_receive(:fetch_object).with(@bucket,"db", nil).and_return(@object)
+      @bucket.get_or_new('db').should == @object
+    end
+
+    it "should create a new blank object if the key does not exist" do
+      @backend.should_receive(:fetch_object).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, "File not found"))
+      obj = @bucket.get_or_new('db')
+      obj.key.should == 'db'
+      obj.data.should be_blank
+    end
+
+    it "should bubble up non-ok non-missing errors" do
+      @backend.should_receive(:fetch_object).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 500, {}, "File not found"))
+      lambda { @bucket.get_or_new('db') }.should raise_error(Riak::HTTPFailedRequest)
+    end
+
+    it "should pass along the given R quorum parameter" do
+      @object = mock("RObject")
+      @backend.should_receive(:fetch_object).with(@bucket,"db", "all").and_return(@object)
+      @bucket.get_or_new('db', :r => "all").should == @object
+    end
+  end
+
+  describe "get/set allow_mult property" do
+    before :each do
+      @backend.stub!(:get_bucket_props).and_return({"allow_mult" => false})
+    end
+
+    it "should extract the allow_mult property" do
+      @bucket.allow_mult.should be_false
+    end
+
+    it "should set the allow_mult property" do
+      @bucket.should_receive(:props=).with(hash_including('allow_mult' => true))
+      @bucket.allow_mult = true
+    end
+  end
+
+  describe "get/set the N value" do
+    before :each do
+      @backend.stub!(:get_bucket_props).and_return({"n_val" => 3})
+    end
+
+    it "should extract the N value" do
+      @bucket.n_value.should == 3
+    end
+
+    it "should set the N value" do
+      @bucket.should_receive(:props=).with(hash_including('n_val' => 1))
+      @bucket.n_value = 1
+    end
+  end
+
+  [:r, :w, :dw, :rw].each do |q|
+    describe "get/set the default #{q} quorum" do
+      before :each do
+        @backend.stub!(:get_bucket_props).and_return({"r" => "quorum", "w" => "quorum", "dw" => "quorum", "rw" => "quorum"})
+      end
+
+      it "should extract the default #{q} quorum" do
+        @bucket.send(q).should == "quorum"
+      end
+
+      it "should set the #{q} quorum" do
+        @bucket.should_receive(:props=).with(hash_including("#{q}" => 1))
+        @bucket.send("#{q}=",1)
+      end
+    end
+  end
+
+  describe "checking whether a key exists" do
+    it "should return true if the object does exist" do
+      @backend.should_receive(:fetch_object).and_return(mock)
+      @bucket.exists?("foo").should be_true
+    end
+
+    it "should return false if the object doesn't exist" do
+      @backend.should_receive(:fetch_object).and_raise(Riak::HTTPFailedRequest.new(:get, [200,300], 404, {}, "not found"))
+      @bucket.exists?("foo").should be_false
+    end
+  end
+
+  describe "deleting an object" do
+    it "should delete a key from within the bucket" do
+      @backend.should_receive(:delete_object).with(@bucket, "bar", nil)
+      @bucket.delete('bar')
+    end
+
+    it "should use the specified RW quorum" do
+      @backend.should_receive(:delete_object).with(@bucket, "bar", "all")
+      @bucket.delete('bar', :rw => "all")
+    end
+  end
+end

data/spec/riak/client_spec.rb

@@ -0,0 +1,517 @@
+require 'spec_helper'
+
+describe Riak::Client do
+  describe "when initializing" do
+    it "should default to the local interface on port 8098 (8087 for protobuffs)" do
+      client = Riak::Client.new
+      client.host.should == "127.0.0.1"
+      client.http_port.should == 8098
+      client.pb_port.should == 8087
+    end
+
+    it "should accept a protocol" do
+      client = Riak::Client.new :protocol => 'https'
+      client.protocol.should eq('https')
+    end
+
+    it "should accept a host" do
+      client = Riak::Client.new :host => "riak.basho.com"
+      client.host.should == "riak.basho.com"
+    end
+
+    it "should accept an HTTP port" do
+      client = Riak::Client.new :http_port => 9000
+      client.http_port.should == 9000
+    end
+
+    it "should accept a Protobuffs port" do
+      client = Riak::Client.new :pb_port => 9000
+      client.pb_port.should == 9000
+    end
+
+    it "should warn on setting :port" do
+      # TODO: make a deprecation utility class/module instead
+      client = Riak::Client.allocate
+      client.should_receive(:warn).and_return(true)
+      client.send :initialize, :port => 9000
+    end
+
+    it "should accept basic_auth" do
+      client = Riak::Client.new :basic_auth => "user:pass"
+      client.basic_auth.should eq("user:pass")
+    end
+
+    it "should accept a client ID" do
+      client = Riak::Client.new :client_id => "AAAAAA=="
+      client.client_id.should == "AAAAAA=="
+    end
+
+    it "should create a client ID if not specified" do
+      Riak::Client.new.client_id.should_not be_nil
+    end
+
+    it "should accept a path prefix" do
+      client = Riak::Client.new(:prefix => "/jiak/")
+      client.prefix.should == "/jiak/"
+    end
+
+    it "should default the prefix to /riak/ if not specified" do
+      Riak::Client.new.prefix.should == "/riak/"
+    end
+
+    it "should accept a mapreduce path" do
+      client = Riak::Client.new(:mapred => "/mr")
+      client.mapred.should == "/mr"
+    end
+
+    it "should default the mapreduce path to /mapred if not specified" do
+      Riak::Client.new.mapred.should == "/mapred"
+    end
+
+    it "should accept a luwak path" do
+      client = Riak::Client.new(:luwak => "/beans")
+      client.luwak.should == "/beans"
+    end
+
+    it "should default the luwak path to /luwak if not specified" do
+      Riak::Client.new.luwak.should == "/luwak"
+    end
+
+    it "should accept a solr path" do
+      client = Riak::Client.new(:solr => "/solar")
+      client.solr.should == "/solar"
+    end
+  end
+
+  it "should expose a Stamp object" do
+    subject.should respond_to(:stamp)
+    subject.stamp.should be_kind_of(Riak::Stamp)
+  end
+  
+  describe "reconfiguring" do
+    before :each do
+      @client = Riak::Client.new
+    end
+
+    describe "setting the protocol" do
+      it "should allow setting the protocol" do
+        @client.should respond_to(:protocol=)
+        @client.protocol = "https"
+        @client.protocol.should eq("https")
+      end
+
+      it "should require a valid protocol to be set" do
+        lambda { @client.protocol = 'invalid-protocol' }.should(
+                                                           raise_error(ArgumentError, /^'invalid-protocol' is not a valid protocol/))
+      end
+
+      it "should reset the unified backend when changing the protocol" do
+        old = @client.backend
+        @client.protocol = "pbc"
+        old.should_not eq(@client.backend)
+      end
+    end
+
+    describe "setting the host" do
+      it "should allow setting the host" do
+        @client.should respond_to(:host=)
+        @client.host = "riak.basho.com"
+        @client.host.should == "riak.basho.com"
+      end
+
+      it "should require the host to be an IP or hostname" do
+        [238472384972, ""].each do |invalid|
+          lambda { @client.host = invalid }.should raise_error(ArgumentError)
+        end
+        ["127.0.0.1", "10.0.100.5", "localhost", "otherhost.local", "riak.basho.com"].each do |valid|
+          lambda { @client.host = valid }.should_not raise_error
+        end
+      end
+    end
+
+    [:http, :pb].each do |protocol|
+      describe "setting the #{protocol} port" do
+        it "should allow setting the #{protocol} port" do
+          @client.should respond_to("#{protocol}_port=")
+          @client.send("#{protocol}_port=", 9000)
+          @client.send("#{protocol}_port").should == 9000
+        end
+
+        it "should require the port to be a valid number" do
+          [-1,65536,"foo"].each do |invalid|
+            lambda { @client.send("#{protocol}_port=",invalid) }.should raise_error(ArgumentError)
+          end
+          [0,1,65535,8098].each do |valid|
+            lambda { @client.send("#{protocol}_port=", valid) }.should_not raise_error
+          end
+        end
+      end
+    end
+
+    describe "setting the port" do
+      before do
+        @client.stub!(:warn).and_return(true)
+      end
+      it "should raise a deprecation warning" do
+        @client.should_receive(:warn).and_return(true)
+        @client.port = 9000
+      end
+
+      it "should set the port for the selected protocol" do
+        @client.protocol = "pbc"
+        @client.port = 9000
+        @client.pb_port.should == 9000
+      end
+    end
+
+    describe "setting http auth" do
+      it "should allow setting basic_auth" do
+        @client.should respond_to(:basic_auth=)
+        @client.basic_auth = "user:pass"
+        @client.basic_auth.should eq("user:pass")
+      end
+
+      it "should require that basic auth splits into two even parts" do
+        lambda { @client.basic_auth ="user" }.should raise_error(ArgumentError, "basic auth must be set using 'user:pass'")
+      end
+    end
+
+    it "should allow setting the prefix" do
+      @client.should respond_to(:prefix=)
+      @client.prefix = "/another-prefix"
+      @client.prefix.should == "/another-prefix"
+    end
+
+    describe "setting the client id" do
+      it "should accept a string unmodified" do
+        @client.client_id = "foo"
+        @client.client_id.should == "foo"
+      end
+
+      it "should reject an integer equal to the maximum client id" do
+        lambda { @client.client_id = Riak::Client::MAX_CLIENT_ID }.should raise_error(ArgumentError)
+      end
+
+      it "should reject an integer larger than the maximum client id" do
+        lambda { @client.client_id = Riak::Client::MAX_CLIENT_ID + 1 }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "choosing an HTTP backend" do
+    before :each do
+      @client = Riak::Client.new
+    end
+
+    it "should choose the selected backend" do
+      @client.http_backend = :NetHTTP
+      @client.http.should be_instance_of(Riak::Client::NetHTTPBackend)
+
+      @client = Riak::Client.new
+      @client.http_backend = :Excon
+      @client.http.should be_instance_of(Riak::Client::ExconBackend)
+    end
+
+    it "should raise an error when the chosen backend is not valid" do
+      Riak::Client::NetHTTPBackend.should_receive(:configured?).and_return(false)
+      lambda { @client.http }.should raise_error
+    end
+  end
+
+  describe "choosing a Protobuffs backend" do
+    before :each do
+      @client = Riak::Client.new(:protocol => "pbc")
+    end
+
+    it "should choose the selected backend" do
+      @client.protobuffs_backend = :Beefcake
+      @client.protobuffs.should be_instance_of(Riak::Client::BeefcakeProtobuffsBackend)
+    end
+
+    it "should raise an error when the chosen backend is not valid" do
+      Riak::Client::BeefcakeProtobuffsBackend.should_receive(:configured?).and_return(false)
+      lambda { @client.protobuffs }.should raise_error
+    end
+  end
+
+  describe "choosing a unified backend" do
+    before :each do
+      @client = Riak::Client.new
+    end
+
+    it "should use HTTP when the protocol is http or https" do
+      %w[http https].each do |p|
+        @client.protocol = p
+        @client.backend.should be_kind_of(Riak::Client::HTTPBackend)
+      end
+    end
+
+    it "should use Protobuffs when the protocol is pbc" do
+      @client.protocol = "pbc"
+      @client.backend.should be_kind_of(Riak::Client::ProtobuffsBackend)
+    end
+  end
+
+  describe "retrieving a bucket" do
+    before :each do
+      @client = Riak::Client.new
+      @backend = mock("Backend")
+      @client.stub!(:backend).and_return(@backend)
+    end
+
+    it "should return a bucket object" do
+      @client.bucket("foo").should be_kind_of(Riak::Bucket)
+    end
+
+    it "should fetch bucket properties if asked" do
+      @backend.should_receive(:get_bucket_props) {|b| b.name.should == "foo"; {} }
+      @client.bucket("foo", :props => true)
+    end
+
+    it "should memoize bucket parameters" do
+      @bucket = mock("Bucket")
+      Riak::Bucket.should_receive(:new).with(@client, "baz").once.and_return(@bucket)
+      @client.bucket("baz").should == @bucket
+      @client.bucket("baz").should == @bucket
+    end
+  end
+
+  describe "listing buckets" do
+    before do
+      @client = Riak::Client.new
+      @backend = mock("Backend")
+      @client.stub!(:backend).and_return(@backend)
+    end
+
+    after { Riak.disable_list_keys_warnings = true }
+    
+    it "should list buckets" do
+      @backend.should_receive(:list_buckets).and_return(%w{test test2})
+      buckets = @client.buckets
+      buckets.should have(2).items
+      buckets.should be_all {|b| b.is_a?(Riak::Bucket) }
+      buckets[0].name.should == "test"
+      buckets[1].name.should == "test2"
+    end
+
+    it "should warn about the expense of list-buckets when warnings are not disabled" do
+      Riak.disable_list_keys_warnings = false
+      @backend.stub!(:list_buckets).and_return(%w{test test2})
+      @client.should_receive(:warn)
+      @client.buckets
+    end
+  end
+
+  describe "Luwak (large-files) support" do
+    describe "storing a file" do
+      before :each do
+        @client = Riak::Client.new
+        @http = mock(Riak::Client::HTTPBackend)
+        @client.stub!(:http).and_return(@http)
+      end
+
+      it "should store the file in Luwak and return the key/filename when no filename is given" do
+        @http.should_receive(:post).with(201, "/luwak", anything, {"Content-Type" => "text/plain"}).and_return(:code => 201, :headers => {"location" => ["/luwak/123456789"]})
+        @client.store_file("text/plain", "Hello, world").should == "123456789"
+      end
+
+      it "should store the file in Luwak and return the key/filename when the filename is given" do
+        @http.should_receive(:put).with(204, "/luwak", "greeting.txt", anything, {"Content-Type" => "text/plain"}).and_return(:code => 204, :headers => {})
+        @client.store_file("greeting.txt", "text/plain", "Hello, world").should == "greeting.txt"
+      end
+    end
+
+    describe "retrieving a file" do
+      before :each do
+        @client = Riak::Client.new
+        @http = mock(Riak::Client::HTTPBackend)
+        @client.stub!(:http).and_return(@http)
+        @http.should_receive(:get).with(200, "/luwak", "greeting.txt").and_yield("Hello,").and_yield(" world!").and_return({:code => 200, :headers => {"content-type" => ["text/plain"]}})
+      end
+
+      it "should stream the data to a temporary file" do
+        file = @client.get_file("greeting.txt")
+        file.open {|f| f.read.should == "Hello, world!" }
+      end
+
+      it "should stream the data through the given block, returning nil" do
+        string = ""
+        result = @client.get_file("greeting.txt"){|chunk| string << chunk }
+        result.should be_nil
+        string.should == "Hello, world!"
+      end
+
+      it "should expose the original key and content-type on the temporary file" do
+        file = @client.get_file("greeting.txt")
+        file.content_type.should == "text/plain"
+        file.original_filename.should == "greeting.txt"
+      end
+    end
+
+    it "should delete a file" do
+      @client = Riak::Client.new
+      @http = mock(Riak::Client::HTTPBackend)
+      @client.stub!(:http).and_return(@http)
+      @http.should_receive(:delete).with([204,404], "/luwak", "greeting.txt")
+      @client.delete_file("greeting.txt")
+    end
+
+    it "should return true if the file exists" do
+      @client = Riak::Client.new
+      @client.http.should_receive(:head).and_return(:code => 200)
+      @client.file_exists?("foo").should be_true
+    end
+
+    it "should return false if the file doesn't exist" do
+      @client = Riak::Client.new
+      @client.http.should_receive(:head).and_return(:code => 404)
+      @client.file_exists?("foo").should be_false
+    end
+
+    it "should escape the filename when storing, retrieving or deleting files" do
+      @client = Riak::Client.new
+      @http = mock(Riak::Client::HTTPBackend)
+      @client.stub!(:http).and_return(@http)
+      # Delete escapes keys
+      @http.should_receive(:delete).with([204,404], "/luwak", "docs%2FA%20Big%20PDF.pdf")
+      @client.delete_file("docs/A Big PDF.pdf")
+      # Get escapes keys
+      @http.should_receive(:get).with(200, "/luwak", "docs%2FA%20Big%20PDF.pdf").and_yield("foo").and_return(:headers => {"content-type" => ["text/plain"]}, :code => 200)
+      @client.get_file("docs/A Big PDF.pdf")
+      # Streamed get escapes keys
+      @http.should_receive(:get).with(200, "/luwak", "docs%2FA%20Big%20PDF.pdf").and_yield("foo").and_return(:headers => {"content-type" => ["text/plain"]}, :code => 200)
+      @client.get_file("docs/A Big PDF.pdf"){|chunk| chunk}
+      # Put escapes keys
+      @http.should_receive(:put).with(204, "/luwak", "docs%2FA%20Big%20PDF.pdf", "foo", {"Content-Type" => "text/plain"})
+      @client.store_file("docs/A Big PDF.pdf", "text/plain", "foo")
+    end
+  end
+
+  describe "ssl", :ssl => true do
+    before :each do
+      @client = Riak::Client.new
+    end
+
+    it "should allow passing ssl options into the initializer" do
+      lambda { client = Riak::Client.new(:ssl => {:verify_mode => "peer"}) }.should_not raise_error
+    end
+
+    it "should not have ssl options by default" do
+      @client.ssl_options.should be_nil
+    end
+
+    it "should have a blank hash for ssl options if the protocol is set to https" do
+      @client.protocol = 'https'
+      @client.ssl_options.should be_a(Hash)
+    end
+
+    # The api should have an ssl= method for setting up all of the ssl
+    # options.  Once the ssl options have been assigned via `ssl=` they should
+    # be read back out using the read only `ssl_options`.  This is to provide
+    # a seperate api for setting ssl options via client configuration and
+    # reading them inside of a http backend.
+    it "should not allow reading ssl options via ssl" do
+      @client.should_not respond_to(:ssl)
+    end
+
+    it "should now allow writing ssl options via ssl_options=" do
+      @client.should_not respond_to(:ssl_options=)
+    end
+
+    it "should allow setting ssl to true" do
+      @client.ssl = true
+      @client.ssl_options[:verify_mode].should eq('none')
+    end
+
+    it "should allow setting ssl options as a hash" do
+      @client.ssl = {:verify_mode => "peer"}
+      @client.ssl_options[:verify_mode].should eq('peer')
+    end
+
+    it "should set the protocol to https when setting ssl to true" do
+      @client.ssl = true
+      @client.protocol.should eq("https")
+    end
+
+    it "should set the protocol to http when setting ssl to false" do
+      @client.protocol = 'https'
+      @client.ssl = false
+      @client.protocol.should eq('http')
+    end
+
+    it "should should clear ssl options when setting ssl to false" do
+      @client.ssl = true
+      @client.ssl_options.should_not be_nil
+      @client.ssl = false
+      @client.ssl_options.should be_nil
+    end
+
+    it "should set the protocol to https when setting ssl options" do
+      @client.ssl = {:verify_mode => "peer"}
+      @client.protocol.should eq("https")
+    end
+
+    it "should allow setting the verify_mode to none" do
+      @client.ssl = {:verify_mode => "none"}
+      @client.ssl_options[:verify_mode].should eq("none")
+    end
+
+    it "should allow setting the verify_mode to peer" do
+      @client.ssl = {:verify_mode => "peer"}
+      @client.ssl_options[:verify_mode].should eq("peer")
+    end
+
+    it "should not allow setting the verify_mode to anything else" do
+      lambda {@client.ssl = {:verify_mode => :your_mom}}.should raise_error(ArgumentError)
+    end
+
+    it "should default verify_mode to none" do
+      @client.ssl = true
+      @client.ssl_options[:verify_mode].should eq("none")
+    end
+
+    it "should let the backend know if ssl is enabled" do
+      @client.should_not be_ssl_enabled
+      @client.ssl = true
+      @client.should be_ssl_enabled
+    end
+
+    it "should allow setting the pem" do
+      @client.ssl = {:pem => 'i-am-a-pem'}
+      @client.ssl_options[:pem].should eq('i-am-a-pem')
+    end
+
+    it "should set them pem from the contents of pem_file" do
+      filepath = File.expand_path(File.join(File.dirname(__FILE__), '../fixtures/test.pem'))
+      @client.ssl = {:pem_file => filepath}
+      @client.ssl_options[:pem].should eq("i-am-a-pem\n")
+    end
+
+    it "should allow setting the pem_password" do
+      @client.ssl = {:pem_password => 'pem-pass'}
+      @client.ssl_options[:pem_password].should eq('pem-pass')
+    end
+
+    it "should allow setting the ca_file" do
+      @client.ssl = {:ca_file => '/path/to/ca.crt'}
+      @client.ssl_options[:ca_file].should eq('/path/to/ca.crt')
+    end
+
+    it "should allow setting the ca_path" do
+      @client.ssl = {:ca_path => '/path/to/certs/'}
+      @client.ssl_options[:ca_path].should eq('/path/to/certs/')
+    end
+
+    %w[pem ca_file ca_path].each do |option|
+      it "should default the verify_mode to peer when setting the #{option}" do
+        @client.ssl = {option.to_sym => 'test-data'}
+        @client.ssl_options[:verify_mode].should eq("peer")
+      end
+
+      it "should allow setting the verify mode when setting the #{option}" do
+        @client.ssl = {option.to_sym => 'test-data', :verify_mode => "none"}
+        @client.ssl_options[:verify_mode].should eq("none")
+      end
+    end
+  end
+end