riak-client 1.4.5 → 2.0.0.rc1

data/spec/integration/riak/cluster_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'riak/cluster'
-
-describe Riak::Cluster, :test_server => false, :slow => true, :nodegen => true do
-  let(:config) { YAML.load_file("spec/support/test_server.yml").symbolize_keys }
-  subject { described_class.new(config) }
-
-  it "should have a list of nodes" do
-    should respond_to(:nodes)
-    subject.nodes.should be_kind_of(Array)
-    subject.nodes.should have(4).items
-    subject.nodes.should be_all {|n| n.kind_of?(Riak::Node) }
-  end
-
-  it "should have a configuration" do
-    should respond_to(:configuration)
-    subject.configuration.should be_kind_of(Hash)
-  end
-
-  it "should require a :source and :root configuration keys" do
-    expect {
-      described_class.new({})
-    }.to raise_error(ArgumentError)
-  end
-
-  it "should not be created initially" do
-    should_not be_exist
-  end
-
-  context "creating the cluster" do
-    before { subject.create }
-    after { subject.destroy }
-
-    it "should generate all nodes inside its root" do
-      subject.root.should be_exist
-      subject.nodes.should be_all {|n| n.exist? }
-    end
-  end
-
-  context "destroying the cluster" do
-    before { subject.create; subject.should be_exist; subject.destroy }
-
-    it "should remove all nodes and its root directory" do
-      subject.should_not be_exist
-    end
-  end
-
-  context "dropping data from the cluster" do
-    it "should make all nodes drop their data" do
-      subject.nodes.each {|n| n.should_receive(:drop) }
-      subject.drop
-    end
-  end
-
-  context "starting the cluster", :slow => true do
-    before { subject.create }
-    after { subject.destroy }
-
-    it "should start all nodes in the cluster" do
-      subject.start
-      subject.nodes.should be_all {|n| n.started? }
-    end
-  end
-
-  context "stopping the cluster", :slow => true do
-    before { subject.create; subject.start; subject.should be_started }
-    after { subject.destroy }
-
-    it "should stop all nodes in the cluster" do
-      subject.stop
-      subject.nodes.should be_all {|n| n.stopped? }
-    end
-  end
-
-  context "joining the cluster together", :slow => true do
-    before { subject.create; subject.start; subject.should be_started }
-    after { subject.destroy }
-
-    it "should join nodes into a cluster" do
-      subject.join
-      node_names = subject.nodes.map {|n| n.name }.sort
-      subject.nodes.should be_all do |n|
-        n.peers.should have(3).items
-        n.peers.sort == (node_names - [n.name])
-      end
-    end
-  end
-end

data/spec/integration/riak/http_backends_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-describe "HTTP" do
-  before do
-    @web_port = test_server.http_port
-    @client = Riak::Client.new(:http_port => @web_port)
-  end
-
-  [:ExconBackend, :NetHTTPBackend].each do |klass|
-    bklass = Riak::Client.const_get(klass)
-    if bklass.configured?
-      describe klass.to_s do
-        before do
-          @backend = bklass.new(@client, @client.node)
-        end
-
-        it_should_behave_like "Unified backend API"
-
-        describe "searching fulltext indexes (1.1 and earlier)", :version => "< 1.2.0" do
-          include_context "search corpus setup"
-
-          it 'should find indexed documents, returning ids' do
-            results = @backend.search 'search_test', 'fearless elephant rushed', :fl => 'id'
-            results.should have_key 'docs'
-            results.should have_key 'max_score'
-            results.should have_key 'num_found'
-            results['docs'].should include({"id" => "munchausen-605"})
-          end
-
-          it 'should find indexed documents, returning documents' do
-            # For now use '*' until #122 is merged into riak_search
-            results = @backend.search 'search_test', 'fearless elephant rushed', :fl => '*'
-            results.should have_key 'docs'
-            results.should have_key 'max_score'
-            results.should have_key 'num_found'
-            results['docs'].should include({"id" => "munchausen-605", "value" => "Fearless I advanced against the elephant, desirous to take alive the haughty Tippoo Sahib; but he drew a pistol from his belt, and discharged it full in my face as I rushed upon him, which did me no further harm than wound my cheek-bone, which disfigures me somewhat under my left eye. I could not withstand the rage and impulse of that moment, and with one blow of my sword separated his head from his body.\n"})
-          end
-        end
-
-        context "clearing bucket properties" do
-          it "should return false when unsupported", :version => "< 1.3.0" do
-            @backend.clear_bucket_props('foo').should be_false
-          end
-
-          it "should reset a previously set property to the default", :version => ">= 1.3.0" do
-            bucket = @client['bucketpropscleartest']
-            original_n = @backend.get_bucket_props(bucket)['n_val']
-            @backend.set_bucket_props(bucket, {'n_val' => 2})
-            @backend.get_bucket_props(bucket)['n_val'].should == 2
-            @backend.clear_bucket_props(bucket)
-            @backend.get_bucket_props(bucket)['n_val'].should == original_n
-          end
-        end
-
-        context "using Luwak", :version => "< 1.1.0" do
-          let(:file) { File.open(__FILE__) }
-          let(:key) { "spec.rb" }
-          let(:string) { file.read }
-
-          def retry_400
-            begin
-              yield
-            rescue Riak::HTTPFailedRequest => e
-              # Riak 1.0.x (and possibly earlier) has a bug in
-              # mochiweb that will sometimes leave dangling 400
-              # responses on the wire between requests when the
-              # connection is left open. This will happen sometimes
-              # immediately after a store_file request.
-              if e.code == 400
-                retry
-              else
-                raise
-              end
-            end
-          end
-
-          it "should store an IO with a given key" do
-            @backend.store_file(key, 'text/plain', file)
-            stored_file = retry_400 { @backend.get_file(key) }
-            stored_file.content_type.should == 'text/plain'
-            stored_file.size.should == file.size
-          end
-
-          it "should store a String with a given key" do
-            @backend.store_file(key, 'text/plain', string)
-            stored_file = retry_400 { @backend.get_file(key) }
-            stored_file.content_type.should == 'text/plain'
-            stored_file.size.should == string.bytesize
-          end
-
-          it "should store an IO with a server-defined key" do
-            key = @backend.store_file('text/plain', file)
-            stored_file = retry_400 { @backend.get_file(key) }
-            stored_file.content_type.should == 'text/plain'
-            stored_file.size.should == file.size
-          end
-
-          it "should store a String with a server-defined key" do
-            key = @backend.store_file('text/plain', string)
-            stored_file = retry_400 { @backend.get_file(key) }
-            stored_file.content_type.should == 'text/plain'
-            stored_file.size.should == string.bytesize
-          end
-        end
-
-        describe 'key and bucket escaping' do
-          let(:default_bucket){ @client[rand(36**10).to_s(36)] }
-
-          { 'question mark' => 'question?marks',
-            'hash' => 'hashtag#riak',
-            'slash' => 'slash/fiction',
-            'space' => 'space opera',
-            'plus' => 'plus+one',
-            'caret' => 'caret^top',
-            'square bracket' => 'square[]meal',
-          }.each do |k, v|
-            it "doesn't mangle keys with a #{k} in them" do
-              obj = default_bucket.new v
-              obj.content_type = 'text/plain'
-              obj.data = rand(36**10).to_s(36)
-              obj.store
-              
-              o2 = nil
-              expect{ o2 = default_bucket.get v }.to_not raise_error
-              expect(o2.data).to eq obj.data
-            end
-            
-            it "doesn't mangle buckets with a #{k} in them" do
-              bucket = @client[v]
-              obj = bucket.new rand(36**10).to_s(36)
-              obj.content_type = 'text/plain'
-              obj.data = rand(36**10).to_s(36)
-              obj.store
-
-              o2 = nil
-              expect{ o2 = bucket.get obj.key }.to_not raise_error
-              expect(o2.data).to eq obj.data
-            end
-          end
-        end
-      end
-    end
-  end
-
-  class SizelessReader < Array
-    def read(*args)
-      shift
-    end
-
-    undef :size
-  end
-
-  describe 'NetHTTPBackend' do
-    subject { Riak::Client::NetHTTPBackend.new(@client, @client.node) }
-    shared_examples "IO uploads" do |io|
-      it "should upload without error" do
-        lambda do
-          Timeout::timeout(2) do
-            subject.put(
-                        204,
-                        subject.object_path('nethttp', 'test-io'),
-                        io,
-                        {'Content-Type' => 'text/plain'}
-                        )
-          end
-        end.should_not raise_error
-      end
-    end
-    
-    context "File" do
-      include_examples "IO uploads", File.open(__FILE__)
-    end
-    context "Sized reader" do
-      include_examples "IO uploads", StringIO.new(%w{foo bar baz}.join)
-    end
-    context "Sizeless reader" do
-      include_examples "IO uploads", SizelessReader.new(%w{foo bar baz})
-    end
-  end
-end

data/spec/integration/riak/node_spec.rb

@@ -1,170 +0,0 @@
-require 'spec_helper'
-require 'riak/node'
-require 'yaml'
-
-describe Riak::Node, :test_server => false, :slow => true, :nodegen => true do
-  let(:test_server_config){ YAML.load_file("spec/support/test_server.yml") }
-  let(:node){ described_class.new(:root => ".ripplenode", :source => test_server_config['source']) }
-  subject { node }
-  after { node.stop if node.started? }
-  after(:all) { node.destroy }
-
-  context "finding the base_dir and version" do
-    its(:base_dir) { should be_directory }
-    its(:version) { should match /^\d+.\d+.\d+$/ }
-  end
-
-  context "creation" do
-    before { subject.create }
-    after { subject.destroy }
-
-    describe "generating the manifest" do
-      it "should store the configuration manifest in the node directory" do
-        (subject.root + '.node.yml').should be_exist
-      end
-    end
-
-    describe "generating app.config" do
-      let(:file) { subject.etc + 'app.config'}
-      let(:contents) { file.read }
-
-      it "should create the app.config file in the node directory" do
-        file.should be_exist
-      end
-
-      it "should generate a correct Erlang configuration" do
-        contents.should =~ /\A\[.*\]\.\Z/m
-      end
-
-      it "should set the ports starting from the given port" do
-        contents.should include('{http, [{"127.0.0.1", 8080}]}')
-        contents.should include('{pb_port, 8081}')
-        contents.should include('{handoff_port, 8082}')
-      end
-
-      it "should set the ring directory to point to the node data directory" do
-        contents.should include("{ring_state_dir, \"#{subject.root + 'data/ring'}\"}")
-      end
-    end
-
-    describe "generating vm.args" do
-      let(:file){ subject.etc + 'vm.args' }
-      let(:contents) { file.read }
-
-      it "should create the vm.args file in the node directory" do
-        file.should be_exist
-      end
-
-      it "should set a quasi-random node name by default" do
-        contents.should match(/-name riak\d+@127\.0\.0\.1/)
-      end
-
-      it "should set a quasi-random cookie by default" do
-        contents.should match(/-setcookie \d+_\d+/)
-      end
-    end
-
-    describe "generating the environment script" do
-      let(:file) { (subject.version >= '1.4.0') ? subject.env_script : subject.control_script }
-      let(:contents) { file.read }
-
-      it "should create the script in the node directory" do
-        file.should be_exist
-      end
-
-      it "should modify the RUNNER_SCRIPT_DIR to point to the node directory" do
-        contents.should match(/RUNNER_SCRIPT_DIR=#{subject.bin.to_s}/)
-      end
-
-      it "should modify the RUNNER_ETC_DIR to point to the node directory" do
-        contents.should match(/RUNNER_ETC_DIR=#{subject.etc.to_s}/)
-      end
-
-      it "should modify the RUNNER_USER to point to none" do
-        contents.should match(/RUNNER_USER=$/)
-      end
-
-      it "should modify the RUNNER_LOG_DIR to point to the node directory" do
-        contents.should match(/RUNNER_LOG_DIR=#{subject.log.to_s}/)
-      end
-
-      it "should modify the RUNNER_BASE_DIR so that it is not relative" do
-        contents.should_not match(/RUNNER_BASE_DIR=\$\{RUNNER_SCRIPT_DIR%\/\*\}/)
-        contents.should match(/RUNNER_BASE_DIR=(.*)/) do |path|
-          path.strip.should == subject.root.to_s
-        end
-      end
-
-      it "should modify the PIPE_DIR to point to the node directory" do
-        contents.should match(/PIPE_DIR=#{subject.pipe.to_s}\/?/)
-      end
-    end
-  end
-
-  context "destroying" do
-    before { subject.create; subject.destroy }
-
-    it "should remove the node directory and all its contents" do
-      subject.root.should_not be_exist
-    end
-  end
-
-  context "dropping data" do
-    before do
-      subject.create
-      subject.start # Make it create some data directories
-      subject.with_console do |console|
-        # Write a ringfile
-        console.command "riak_core_ring_manager:write_ringfile()."
-      end
-      # Don't restart the node after dropping so we can see the handiwork
-      subject.stop
-      subject.drop
-    end
-
-    it "should remove all data from the node" do
-      (subject.root + 'data').children.map {|dir| dir.children }.flatten.should be_empty
-    end
-
-    it "should remove the ring" do
-      (subject.root + 'data/ring').children.should be_empty
-    end
-  end
-
-  context "starting" do
-    before { subject.create; subject.start }
-    it { should be_started }
-    after { subject.stop }
-  end
-
-  context "stopping" do
-    before { subject.create; subject.start; subject.stop }
-    it { should be_stopped }
-  end
-
-  context "attaching" do
-    before { subject.create; subject.start }
-
-    it "should attach to the running node" do
-      console = subject.attach
-      console.should be_kind_of(Riak::Node::Console)
-      expect {
-        console.command "ok."
-        console.close
-      }.to_not raise_error
-    end
-  end
-
-  context "running" do
-    before { subject.create; subject.start; subject.stop }
-
-    it "should read the console log" do
-      if subject.version >= "1.0.0"
-        subject.read_console_log(:debug, :info, :notice).should_not be_empty
-        subject.read_console_log('debug'..'emergency').should_not be_empty
-        subject.read_console_log(:info).should_not be_empty
-        subject.read_console_log(:foo).should be_empty
-      end
-    end
-  end
-end

data/spec/integration/riak/test_server_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-require 'riak/test_server'
-
-describe Riak::TestServer, :nodegen => true do
-  subject { test_server }
-  let(:app_config) { (subject.etc + 'app.config').read }
-
-  it "should add the test backends to the code path" do
-    erl_src = File.expand_path("../../../../erl_src", __FILE__)
-    subject.env[:riak_kv][:add_paths].should include(erl_src)
-    app_config.should match(/\{add_paths, \[.*#{erl_src.inspect}.*\]\}/)
-  end
-
-  it "should use the KV test backend" do
-    backend = if subject.version < "1.0.0"
-                :riak_kv_test014_backend
-              elsif subject.version < "1.2.0"
-                :riak_kv_test_backend
-              else
-                :riak_kv_memory_backend
-              end
-    subject.kv_backend.should == backend
-    subject.env[:riak_kv][:storage_backend].should == backend
-    app_config.should include("{storage_backend, #{backend}}")
-  end
-
-  it "should use the Search test backend" do
-    subject.search_backend.should == :riak_search_test_backend
-    subject.env[:riak_search][:search_backend].should == :riak_search_test_backend
-    app_config.should include("{search_backend, riak_search_test_backend}")
-  end
-
-  it "should clear stored data" do
-    # TODO: use $test_server.to_host when client/host split is finished.
-    client = Riak::Client.new(:http_port => subject.http_port)
-    obj = client['test_bucket'].new("test_item")
-    obj.data = {"data" => "testing"}
-    obj.store # rescue nil
-
-    subject.drop
-    expect {
-      client['test_bucket']['test_item']
-    }.to raise_error(Riak::FailedRequest)
-  end
-
-  it "should not clobber user-specified paths in riak_kv/add_paths [seancribbs/ripple #256]", :test_server => false do
-    # clean up the existing directory so the config is not overwritten
-    test_server.send(:delete)
-    config = {
-      :root => subject.root,
-      :source => subject.source,
-      :env => {:riak_kv => {:add_paths => ["app/mapreduce/erlang"]}}
-    }
-    ts = described_class.new(config)
-    ts.env[:riak_kv][:add_paths].should include("app/mapreduce/erlang")
-  end
-end