ripple 0.6.1 → 0.7.0

data/spec/riak/walk_spec_spec.rb

@@ -1,208 +0,0 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-require File.expand_path("../spec_helper", File.dirname(__FILE__))
-
-describe Riak::WalkSpec do
-  describe "initializing" do
-    describe "with a hash" do
-      it "should be empty by default" do
-        spec = Riak::WalkSpec.new({})
-        spec.bucket.should == "_"
-        spec.tag.should == "_"
-        spec.keep.should be_false
-      end
-
-      it "should extract the bucket" do
-        spec = Riak::WalkSpec.new({:bucket => "foo"})
-        spec.bucket.should == "foo"
-        spec.tag.should == "_"
-        spec.keep.should be_false
-      end
-
-      it "should extract the tag" do
-        spec = Riak::WalkSpec.new({:tag => "foo"})
-        spec.bucket.should == "_"
-        spec.tag.should == "foo"
-        spec.keep.should be_false
-      end
-
-      it "should extract the keep" do
-        spec = Riak::WalkSpec.new({:keep => true})
-        spec.bucket.should == "_"
-        spec.tag.should == "_"
-        spec.keep.should be_true
-      end
-    end
-
-    describe "with three arguments for bucket, tag, and keep" do
-      it "should assign the bucket, tag, and keep" do
-        spec = Riak::WalkSpec.new("foo", "next", false)
-        spec.bucket.should == "foo"
-        spec.tag.should == "next"
-        spec.keep.should be_false
-      end
-
-      it "should make the bucket '_' when false or nil" do
-        spec = Riak::WalkSpec.new(nil, "next", false)
-        spec.bucket.should == "_"
-        spec = Riak::WalkSpec.new(false, "next", false)
-        spec.bucket.should == "_"
-      end
-
-      it "should make the tag '_' when false or nil" do
-        spec = Riak::WalkSpec.new("foo", nil, false)
-        spec.tag.should == "_"
-        spec = Riak::WalkSpec.new("foo", false, false)
-        spec.tag.should == "_"
-      end
-
-      it "should make the keep false when false or nil" do
-        spec = Riak::WalkSpec.new(nil, nil, nil)
-        spec.keep.should be_false
-        spec = Riak::WalkSpec.new(nil, nil, false)
-        spec.keep.should be_false
-      end
-    end
-
-    it "should raise an ArgumentError for invalid arguments" do
-      lambda { Riak::WalkSpec.new }.should raise_error(ArgumentError)
-      lambda { Riak::WalkSpec.new("foo") }.should raise_error(ArgumentError)
-      lambda { Riak::WalkSpec.new("foo","bar") }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "converting to a string" do
-    before :each do
-      @spec = Riak::WalkSpec.new({})
-    end
-
-    it "should be the empty spec by default" do
-      @spec.to_s.should == "_,_,_"
-    end
-
-    it "should include the bucket when set" do
-      @spec.bucket = "foo"
-      @spec.to_s.should == "foo,_,_"
-    end
-
-    it "should include the tag when set" do
-      @spec.tag = "next"
-      @spec.to_s.should == "_,next,_"
-    end
-
-    it "should include the keep when true" do
-      @spec.keep = true
-      @spec.to_s.should == "_,_,1"
-    end
-  end
-
-  describe "creating from a list of parameters" do
-    it "should detect hashes and WalkSpecs interleaved with other parameters" do
-      specs = Riak::WalkSpec.normalize(nil,"next",nil,{:bucket => "foo"},Riak::WalkSpec.new({:tag => "child", :keep => true}))
-      specs.should have(3).items
-      specs.should be_all {|s| s.kind_of?(Riak::WalkSpec) }
-      specs.join("/").should == "_,next,_/foo,_,_/_,child,1"
-    end
-  end
-
-  describe "matching other objects with ===" do
-    before :each do
-      @spec = Riak::WalkSpec.new({})
-    end
-
-    it "should not match objects that aren't links or walk specs" do
-      @spec.should_not === "foo"
-    end
-
-    describe "matching links" do
-      before :each do
-        @link = Riak::Link.new("/riak/foo/bar", "next")
-      end
-
-      it "should match a link when the bucket and tag are not specified" do
-        @spec.should === @link
-      end
-
-      it "should match a link when the bucket is the same" do
-        @spec.bucket = "foo"
-        @spec.should === @link
-      end
-
-      it "should not match a link when the bucket is different" do
-        @spec.bucket = "bar"
-        @spec.should_not === @link
-      end
-
-      it "should match a link when the tag is the same" do
-        @spec.tag = "next"
-        @spec.should === @link
-      end
-
-      it "should not match a link when the tag is different" do
-        @spec.tag = "previous"
-        @spec.should_not === @link
-      end
-
-      it "should match a link when the bucket and tag are the same" do
-        @spec.bucket = "foo"
-        @spec.should === @link
-      end
-    end
-
-    describe "matching walk specs" do
-      before :each do
-        @other = Riak::WalkSpec.new({})
-      end
-
-      it "should match a walk spec that is equivalent" do
-        @spec.should === @other
-      end
-
-      it "should not match a walk spec that has a different keep value" do
-        @other.keep = true
-        @spec.should_not === @other
-      end
-
-      it "should match a walk spec with a more specific bucket" do
-        @other.bucket = "foo"
-        @spec.should === @other
-      end
-
-      it "should match a walk spec with the same bucket" do
-        @other.bucket = "foo"; @spec.bucket = "foo"
-        @spec.should === @other
-      end
-
-      it "should not match a walk spec with a different bucket" do
-        @other.bucket = "foo"; @spec.bucket = "bar"
-        @spec.should_not === @other
-      end
-
-      it "should match a walk spec with a more specific tag" do
-        @other.tag = "next"
-        @spec.should === @other
-      end
-
-      it "should match a walk spec with the same tag" do
-        @other.tag = "next"; @spec.tag = "next"
-        @spec.should === @other
-      end
-
-      it "should not match a walk spec with a different tag" do
-        @other.tag = "next"; @spec.tag = "previous"
-        @spec.should_not === @other
-      end
-    end
-  end
-end

data/spec/spec.opts

@@ -1 +0,0 @@
---color

data/spec/support/http_backend_implementation_examples.rb

@@ -1,215 +0,0 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-shared_examples_for "HTTP backend" do
-  describe "HEAD requests" do
-    before :each do
-      setup_http_mock(:head, @backend.path("/riak/","foo").to_s, :body => "")
-    end
-
-    it "should return only the headers when the request succeeds" do
-      response = @backend.head(200, "/riak/","foo")
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.head(301, "/riak/", "foo") }.should raise_error(Riak::FailedRequest)
-    end
-
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.head(200, "/riak/") }.should raise_error(ArgumentError)
-    end
-
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.head([200, 301], "/riak/", "foo") }.should_not raise_error(Riak::FailedRequest)
-    end
-  end
-
-  describe "GET requests" do
-    before :each do
-      setup_http_mock(:get, @backend.path("/riak/","foo").to_s, :body => "Success!")
-    end
-
-    it "should return the response body and headers when the request succeeds" do
-      response = @backend.get(200, "/riak/","foo")
-      response[:body].should == "Success!"
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.get(304, "/riak/","foo") }.should raise_error(Riak::FailedRequest)
-    end
-
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.get([200, 301], "/riak/","foo") }.should_not raise_error(Riak::FailedRequest)
-    end
-    
-    it "should yield successive chunks of the response to the given block but not return the entire body" do
-      chunks = ""
-      response = @backend.get(200, "/riak/","foo") do |chunk|
-        chunks << chunk
-      end
-      chunks.should == "Success!"
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.get(200, "/riak/") }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "DELETE requests" do
-    before :each do
-      setup_http_mock(:delete, @backend.path("/riak/","foo").to_s, :body => "Success!")
-    end
-
-    it "should return the response body and headers when the request succeeds" do
-      response = @backend.delete(200, "/riak/","foo")
-      response[:body].should == "Success!"
-      response[:headers].should be_kind_of(Hash)
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.delete(304, "/riak/","foo") }.should raise_error(Riak::FailedRequest)
-    end
-    
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.delete([200, 301], "/riak/","foo") }.should_not raise_error(Riak::FailedRequest)
-    end
-    
-    it "should yield successive chunks of the response to the given block but not return the entire body" do
-      chunks = ""
-      response = @backend.delete(200, "/riak/","foo") do |chunk|
-        chunks << chunk
-      end
-      chunks.should == "Success!"
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.delete(200, "/riak/") }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "PUT requests" do
-    before :each do
-      setup_http_mock(:put, @backend.path("/riak/","foo").to_s, :body => "Success!")
-    end
-
-    it "should return the response body, headers, and code when the request succeeds" do
-      response = @backend.put(200, "/riak/","foo", "This is the body.")
-      response[:body].should == "Success!"
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.put(204, "/riak/","foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
-    end
-    
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.put([200, 204], "/riak/","foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
-    end
-    
-    
-    it "should yield successive chunks of the response to the given block but not return the entire body" do
-      chunks = ""
-      response = @backend.put(200, "/riak/","foo", "This is the body.") do |chunk|
-        chunks << chunk
-      end
-      chunks.should == "Success!"
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.put(200, "/riak/") }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error if no body data is given" do
-      lambda { @backend.put(200, "/riak/","foo") }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error if the body is not a string" do
-      lambda { @backend.put(200, "/riak/","foo", 123) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "POST requests" do
-    before :each do
-      setup_http_mock(:post, @backend.path("/riak/","foo").to_s, :body => "Success!")
-    end
-
-    it "should return the response body, headers, and code when the request succeeds" do
-      response = @backend.post(200, "/riak/","foo", "This is the body.")
-      response[:body].should == "Success!"
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.post(204, "/riak/", "foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
-    end
-
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.post([200, 204], "/riak/", "foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
-    end
-
-    it "should yield successive chunks of the response to the given block but not return the entire body" do
-      chunks = ""
-      response = @backend.post(200, "/riak/", "foo", "This is the body.") do |chunk|
-        chunks << chunk
-      end
-      chunks.should == "Success!"
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.post(200, "/riak/") }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error if no body data is given" do
-      lambda { @backend.post(200, "/riak/", "foo") }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error if the body is not a string" do
-      lambda { @backend.post(200, "/riak/", "foo", 123) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "Responses with no body" do
-    [204, 205, 304].each do |code|
-      [:get, :post, :put, :delete].each do |method|
-        it "should not return a body on #{method.to_s.upcase} for #{code}" do
-          setup_http_mock(method, @backend.path("/riak/","foo").to_s, :status => code)
-          response = if method == :post || method == :put
-                       @backend.send(method, code,"/riak/","foo", "This is the body")
-                     else
-                       @backend.send(method, code, "/riak/", "foo")
-                     end
-          response.should_not have_key(:body)
-        end
-      end
-    end
-  end
-end

data/spec/support/mock_server.rb

@@ -1,58 +0,0 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-# Based on code from Rob Styles and Chris Tierney found at:
-#   http://dynamicorange.com/2009/02/18/ruby-mock-web-server/
-require 'rack'
-
-class MockServer
-  def initialize(port = 4000, pause = 1)
-    @block = nil
-    @parent_thread = Thread.current
-    @thread = Thread.new do
-      Rack::Handler::WEBrick.run(self, :Port => port, :AccessLog => [], :Logger => NullLogger.new)
-    end
-    sleep pause # give the server time to fire up… YUK!
-  end
-
-  def stop
-    Thread.kill(@thread)
-  end
-
-  def attach(&block)
-    @block = block
-  end
-
-  def detach()
-    @block = nil
-  end
-
-  def call(env)
-    begin
-      raise "Specify a handler for the request using attach(block), the block should return a valid rack response and can test expectations" unless @block
-      @block.call(env)
-    rescue Exception => e
-      @parent_thread.raise e
-      [ 500, { 'Content-Type' => 'text/plain', 'Content-Length' => '13' }, [ 'Bad test code' ]]
-    end
-  end
-
-  class NullLogger
-    def fatal(msg) end
-    def error(msg) end
-    def warn(msg)  end
-    def info(msg)  end
-    def debug(msg) end
-  end
-end