chef-solr 0.9.18 → 0.10.0.beta.0

data/lib/chef/solr/query.rb

@@ -1,99 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Nuo Yan (<nuo@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# 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 'chef/couchdb'
-require 'chef/node'
-require 'chef/role'
-require 'chef/data_bag'
-require 'chef/data_bag_item'
-require 'chef/solr'
-require 'chef/log'
-require 'chef/config'
-
-class Chef
-  class Solr
-    class Query < Chef::Solr
-      
-      # Create a new Query object - takes the solr_url and optional
-      # Chef::CouchDB object to inflate objects into.
-      def initialize(solr_url=Chef::Config[:solr_url], couchdb = nil)
-        super(solr_url)
-        if couchdb.nil?
-          @database = Chef::Config[:couchdb_database]
-          @couchdb = Chef::CouchDB.new(nil, Chef::Config[:couchdb_database])
-        else
-          unless couchdb.kind_of?(Chef::CouchDB)
-            Chef::Log.warn("Passing the database name to Chef::Solr::Query initialization is deprecated. Please pass in the Chef::CouchDB object instead.")
-            @database = couchdb
-            @couchdb = Chef::CouchDB.new(nil, couchdb)
-          else
-            @database = couchdb.couchdb_database
-            @couchdb = couchdb
-          end
-        end 
-      end
-
-      # A raw query against CouchDB - takes the type of object to find, and raw
-      # Solr options.
-      #
-      # You'll wind up having to page things yourself.
-      def raw(type, options={})
-        qtype = case type
-                when "role",:role,"node",:node,"client",:client
-                  type
-                else
-                  [ "data_bag_item", type ]
-                end
-        results = solr_select(@database, qtype, options)
-        Chef::Log.debug("Searching #{@database} #{qtype.inspect} for #{options.inspect} with results:\n#{results.inspect}") 
-        objects = if results["response"]["docs"].length > 0
-                    bulk_objects = @couchdb.bulk_get( results["response"]["docs"].collect { |d| d["X_CHEF_id_CHEF_X"] } )
-                    Chef::Log.debug("bulk get of objects: #{bulk_objects.inspect}")
-                    bulk_objects
-                  else
-                    []
-                  end
-        [ objects, results["response"]["start"], results["response"]["numFound"], results["responseHeader"] ] 
-      end
-
-      # Search Solr for objects of a given type, for a given query. If you give
-      # it a block, it will handle the paging for you dynamically.
-      def search(type, query="*:*", sort='X_CHEF_id_CHEF_X asc', start=0, rows=1000, &block)
-        options = {
-          :q => query,
-          :start => start,
-          :rows => rows 
-        }
-        options[:sort] = sort if sort && ! sort.empty?
-        objects, start, total, response_header = raw(type, options)
-        if block
-          objects.each { |o| block.call(o) }
-          unless (start + objects.length) >= total
-            nstart = start + rows
-            search(type, query, sort, nstart, rows, &block)
-          end
-          true
-        else
-          [ objects, start, total ]
-        end
-      end
-    end
-  end
-end
-

data/spec/chef/solr/index_spec.rb

@@ -1,187 +0,0 @@
-require File.expand_path(File.join("#{File.dirname(__FILE__)}", '..', '..', 'spec_helper'))
-
-
-
-describe Chef::Solr::Index do
-  before(:each) do
-    @index = Chef::Solr::Index.new
-  end
-
-  describe "initialize" do
-    it "should return a Chef::Solr::Index" do
-      @index.should be_a_kind_of(Chef::Solr::Index)
-    end
-  end
-
-  describe "add" do
-    before(:each) do
-      @index.stub!(:solr_add).and_return(true)
-      @index.stub!(:solr_commit).and_return(true)
-    end
-
-    it "should take an object that responds to .keys as it's argument" do
-      lambda { @index.add(1, "chef_opscode", "node", { :one => :two }) }.should_not raise_error(ArgumentError)
-      lambda { @index.add(1, "chef_opscode", "node", "SOUP") }.should raise_error(ArgumentError)
-      lambda { @index.add(2, "chef_opscode", "node", mock("Foo", :keys => true)) }.should_not raise_error(ArgumentError)
-    end
-
-    it "should index the object as a single flat hash, with only strings or arrays as values" do
-      validate = {
-        "X_CHEF_id_CHEF_X" => [1],
-        "X_CHEF_database_CHEF_X" => ["monkey"],
-        "X_CHEF_type_CHEF_X" => ["snakes"],
-        "foo" => ["bar"],
-        "battles" => [ "often", "but", "for" ],
-        "battles_often" => ["sings like smurfs"],
-        "often" => ["sings like smurfs"],
-        "battles_but" => ["still has good records"],
-        "but" => ["still has good records"],
-        "battles_for" => [ "all", "of", "that" ],
-        "for" => [ "all", "of", "that" ],
-        "snoopy" => ["sits-in-a-barn"],
-        "battles_X" => [ "sings like smurfs", "still has good records", "all", "of", "that" ],
-        "X_often" =>[ "sings like smurfs"],
-        "X_but" => ["still has good records"],
-        "X_for" => [ "all", "of", "that" ]
-      }
-      to_index = @index.add(1, "monkey", "snakes", {
-        "foo" => :bar,
-        "battles" => {
-          "often" => "sings like smurfs",
-          "but" => "still has good records",
-          "for" => [ "all", "of", "that" ]
-        },
-        "snoopy" => "sits-in-a-barn"
-      })
-
-      validate.each do |k, v|
-        if v.kind_of?(Array)
-          to_index[k].sort.should == v.sort
-        else
-          to_index[k].should == v
-        end
-      end
-    end
-
-    it "should send the document to solr" do
-      @index.should_receive(:solr_add)
-      @index.add(1, "monkey", "snakes", { "foo" => "bar" })
-    end
-  end
-
-  describe "delete" do
-    it "should delete by id" do
-      @index.should_receive(:solr_delete_by_id).with(1)
-      @index.delete(1)
-    end
-  end
-
-  describe "delete_by_query" do
-    it "should delete by query" do
-      @index.should_receive(:solr_delete_by_query).with("foo:bar")
-      @index.delete_by_query("foo:bar")
-    end
-  end
-
-  describe "flatten_and_expand" do
-    before(:each) do
-      @fields = Hash.new
-    end
-
-    it "should set a value for the parent as key, with the key as the value" do
-      @fields = @index.flatten_and_expand("omerta" => { "one" => "woot" })
-      @fields["omerta"].should == ["one"]
-    end
-
-    it "should call itself recursively for values that are hashes" do
-      @fields = @index.flatten_and_expand({ "one" => { "two" => "three", "four" => { "five" => "six" } }})
-      expected = {"one" => [ "two", "four" ],
-                  "one_two" => ["three"],
-                  "X_two" => ["three"],
-                  "two" => ["three"],
-                  "one_four" => ["five"],
-                  "X_four" => ["five"],
-                  "one_X" => [ "three", "five" ],
-                  "one_four_five" => ["six"],
-                  "X_four_five" => ["six"],
-                  "one_X_five" => ["six"],
-                  "one_four_X" => ["six"],
-                  "five" => ["six"]}
-      expected.each do |k, v|
-        @fields[k].should == v
-      end
-    end
-
-    it "should call itself recursively for hashes nested in arrays" do
-      @fields = @index.flatten_and_expand({ :one => [ { :two => "three" }, { :four => { :five => "six" } } ] })
-      expected = {"one_X_five" => ["six"],
-                  "one_four" => ["five"],
-                  "one_X" => [ "three", "five" ],
-                  "two" => ["three"],
-                  "one_four_X" => ["six"],
-                  "X_four" => ["five"],
-                  "X_four_five" => ["six"],
-                  "one" => [ "two", "four" ],
-                  "one_four_five" => ["six"],
-                  "five" => ["six"],
-                  "X_two" => ["three"],
-                  "one_two" => ["three"]}
-
-      expected.each do |key, expected_value|
-        @fields[key].should == expected_value
-      end
-    end
-
-    it "generates unlimited levels of expando fields when expanding" do
-      expected_keys = ["one",
-                       "one_two",
-                       "X_two",
-                       "one_X",
-                       "one_two_three",
-                       "X_two_three",
-                       "one_X_three",
-                       "one_two_X",
-                       "one_two_three_four",
-                       "X_two_three_four",
-                       "one_X_three_four",
-                       "one_two_X_four",
-                       "one_two_three_X",
-                       "one_two_three_four_five",
-                       "X_two_three_four_five",
-                       "one_X_three_four_five",
-                       "one_two_X_four_five",
-                       "one_two_three_X_five",
-                       "one_two_three_four_X",
-                       "six",
-                       "one_two_three_four_five_six",
-                       "X_two_three_four_five_six",
-                       "one_X_three_four_five_six",
-                       "one_two_X_four_five_six",
-                       "one_two_three_X_five_six",
-                       "one_two_three_four_X_six",
-                       "one_two_three_four_five_X"].sort
-
-      nested = {:one => {:two => {:three => {:four => {:five => {:six => :end}}}}}}
-      @fields = @index.flatten_and_expand(nested)
-
-      @fields.keys.sort.should include(*expected_keys)
-    end
-
-  end
-
-  describe "creating expando fields" do
-    def make_expando_fields(parts)
-      expando_fields = []
-      @index.each_expando_field(parts) { |ex| expando_fields << ex }
-      expando_fields
-    end
-
-    it "joins the fields with a big X" do
-      make_expando_fields(%w{foo bar baz qux}).should == ["X_bar_baz_qux", "foo_X_baz_qux", "foo_bar_X_qux", "foo_bar_baz_X"]
-      make_expando_fields(%w{foo bar baz}).should == ["X_bar_baz", "foo_X_baz", "foo_bar_X"]
-      make_expando_fields(%w{foo bar}).should == ["X_bar", "foo_X"]
-      make_expando_fields(%w{foo}).should == []
-    end
-  end
-
-end

data/spec/chef/solr/query_spec.rb

@@ -1,14 +0,0 @@
-require File.expand_path(File.join("#{File.dirname(__FILE__)}", '..', '..', 'spec_helper'))
-
-describe Chef::Solr::Query do
-  before(:each) do
-    @query = Chef::Solr::Query.new
-  end
-
-  describe "initialize" do
-    it "should return a Chef::Solr::Query" do
-      @query.should be_a_kind_of(Chef::Solr::Query)
-    end
-  end
-end
-

data/spec/chef/solr_spec.rb

@@ -1,301 +0,0 @@
-require File.expand_path(File.join("#{File.dirname(__FILE__)}", '..', 'spec_helper'))
-require 'net/http'
-
-describe Chef::Solr do
-  before(:each) do 
-    @solr = Chef::Solr.new
-  end
-
-  describe "initialize" do
-    it "should create a new Chef::Solr object" do
-      @solr.should be_a_kind_of(Chef::Solr)
-    end
-
-    it "should accept an alternate solr url" do
-      solr = Chef::Solr.new("http://example.com")
-      solr.solr_url.should eql("http://example.com")
-    end
-  end
-
-  describe "solr_select" do
-    before(:each) do
-      @http_response = mock(
-        "Net::HTTP::Response", 
-        :kind_of? => Net::HTTPSuccess,
-        :body => "{ :some => :hash }"
-      )
-      @http = mock("Net::HTTP", :request => @http_response)
-      @solr.http = @http
-    end
-
-    describe "when the HTTP call is successful" do
-      it "should call get to /solr/select with the escaped query" do
-        Net::HTTP::Get.should_receive(:new).with(%r(q=hostname%3Alatte))
-        @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-      end
-
-      it "should call get to /solr/select with wt=ruby" do
-        Net::HTTP::Get.should_receive(:new).with(%r(wt=ruby))
-        @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-      end
-
-      it "should call get to /solr/select with indent=off" do
-        Net::HTTP::Get.should_receive(:new).with(%r(indent=off))
-        @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-      end
-
-      it "should call get to /solr/select with filter query" do
-        Net::HTTP::Get.should_receive(:new).with(/fq=%2BX_CHEF_database_CHEF_X%3Achef_opscode\+%2BX_CHEF_type_CHEF_X%3Anode/)
-        @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-      end
-
-      it "should return the evaluated response body" do
-        res = @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-        res.should == { :some => :hash }
-      end
-    end
-
-    describe "when the HTTP call is unsuccessful" do
-      [Timeout::Error, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EINVAL].each do |exception|
-        it "should rescue, log an error message, and raise a SolrConnectionError encountering exception #{exception}" do
-          lambda {
-            @http.should_receive(:request).with(instance_of(Net::HTTP::Get)).and_raise(exception)
-            Chef::Log.should_receive(:fatal).with(/Search Query to Solr '(.+?)' failed.  Chef::Exceptions::SolrConnectionError exception: #{exception}:.+/)
-            @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-          }.should raise_error(Chef::Exceptions::SolrConnectionError)
-        end
-      end
-
-      it "should rescue, log an error message, and raise a SolrConnectionError when encountering exception NoMethodError and net/http closed? bug" do
-        lambda {
-          @no_method_error = NoMethodError.new("undefined method 'closed\?' for nil:NilClass")
-          @http.should_receive(:request).with(instance_of(Net::HTTP::Get)).and_raise(@no_method_error)
-          Chef::Log.should_receive(:fatal).with(/Search Query to Solr '(.+?)' failed.  Chef::Exceptions::SolrConnectionError exception: Errno::ECONNREFUSED.+net\/http undefined method closed.+/)
-          @solr.solr_select("chef_opscode", "node", :q => "hostname:latte")
-        }.should raise_error(Chef::Exceptions::SolrConnectionError)
-      end
-    end
-  end
-
-  describe "post_to_solr" do
-    before(:each) do
-      @http_response = mock(
-        "Net::HTTP::Response", 
-        :kind_of? => Net::HTTPSuccess,
-        :body => "{ :some => :hash }"
-      )
-      @http_request = mock(
-        "Net::HTTP::Request",
-        :body= => true
-      )
-      @http = mock("Net::HTTP", :request => @http_response)
-      @solr.http = @http
-      Net::HTTP::Post.stub!(:new).and_return(@http_request)
-      @doc = { "foo" => "bar" }
-    end
-
-    describe 'when the HTTP call is successful' do
-      it "should post to /solr/update" do
-        Net::HTTP::Post.should_receive(:new).with("/solr/update", "Content-Type" => "text/xml").and_return(@http_request)
-        @solr.post_to_solr(@doc)
-      end
-
-      it "should set the body of the request to the stringified doc" do
-        @http_request.should_receive(:body=).with("foo")
-        @solr.post_to_solr(:foo)
-      end
-
-      it "should send the request to solr" do
-        @http.should_receive(:request).with(@http_request).and_return(@http_response)
-        @solr.post_to_solr(:foo).should
-      end
-    end
-
-    describe "when the HTTP call is unsuccessful due to an exception" do
-      it "should post to /solr/update" do
-        Net::HTTP::Post.should_receive(:new).with("/solr/update", "Content-Type" => "text/xml").and_return(@http_request)
-        @solr.post_to_solr(@doc)
-      end
-
-      it "should set the body of the request to the stringified doc" do
-        @http_request.should_receive(:body=).with("foo")
-        @solr.post_to_solr(:foo)
-      end
-
-      [Timeout::Error, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EINVAL].each do |exception|
-        it "should rescue and log an error message when encountering exception #{exception} and then re-raise it" do
-          lambda {
-            @http.should_receive(:request).with(@http_request).and_raise(exception)
-            Chef::Log.should_receive(:fatal).with(/POST to Solr '(.+?)' failed.  Chef::Exceptions::SolrConnectionError exception: #{exception}:.+/)
-            @solr.post_to_solr(:foo)
-          }.should raise_error(Chef::Exceptions::SolrConnectionError)
-        end
-      end
-
-      it "should rescue and log an error message when encountering exception NoMethodError and net/http closed? bug" do
-        lambda {
-          @no_method_error = NoMethodError.new("undefined method 'closed\?' for nil:NilClass")
-          @http.should_receive(:request).with(@http_request).and_raise(@no_method_error)
-          Chef::Log.should_receive(:fatal).with(/POST to Solr '(.+?)' failed.  Chef::Exceptions::SolrConnectionError exception: Errno::ECONNREFUSED.+net\/http undefined method closed.+/)
-          @solr.post_to_solr(:foo)
-        }.should raise_error(Chef::Exceptions::SolrConnectionError)
-      end
-    end
-  end
-
-  describe "solr_add" do
-    before(:each) do
-      @solr.stub!(:post_to_solr).and_return(true)
-      @data = { "foo" => ["bar"] }
-    end
-
-    it "should send valid XML to solr" do
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<add><doc><field name=\"foo\">bar</field></doc></add>\n")
-      @solr.solr_add(@data)
-    end
-
-    it "XML escapes content before sending to SOLR" do
-      @data["foo"] = ["<&>"]
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<add><doc><field name=\"foo\">&lt;&amp;&gt;</field></doc></add>\n")
-
-      @solr.solr_add(@data)
-    end
-
-    it "XML escapes keys before sending to SOLR" do
-      @data.delete("foo")
-      @data["foo&bar"] = ["baz"]
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<add><doc><field name=\"foo&amp;bar\">baz</field></doc></add>\n")
-
-      @solr.solr_add(@data)
-    end
-  end
-
-  describe "solr_commit" do
-    before(:each) do
-      @solr.stub!(:post_to_solr).and_return(true)
-    end
-
-    it "should send valid commit xml to solr" do
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<commit/>\n")
-      @solr.solr_commit
-    end
-  end
-
-  describe "solr_optimize" do
-    before(:each) do
-      @solr.stub!(:post_to_solr).and_return(true)
-    end
-
-    it "should send valid commit xml to solr" do
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<optimize/>\n")
-      @solr.solr_optimize
-    end
-  end
-
-  describe "solr_rollback" do
-    before(:each) do
-      @solr.stub!(:post_to_solr).and_return(true)
-    end
-
-    it "should send valid commit xml to solr" do
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rollback/>\n")
-      @solr.solr_rollback
-    end
-  end
-
-  describe "solr_delete_by_id" do
-    before(:each) do
-      @solr.stub!(:post_to_solr).and_return(true)
-    end
-
-    it "should send valid delete id xml to solr" do
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<delete><id>1</id></delete>\n")
-      @solr.solr_delete_by_id(1)
-    end
-
-    it "should accept multiple ids" do
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<delete><id>1</id><id>2</id></delete>\n")
-      @solr.solr_delete_by_id([ 1, 2 ])
-    end
-  end
-
-  describe "solr_delete_by_query" do
-    before(:each) do
-      @solr.stub!(:post_to_solr).and_return(true)
-    end
-
-    it "should send valid delete id xml to solr" do
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<delete><query>foo:bar</query></delete>\n")
-      @solr.solr_delete_by_query("foo:bar")
-    end
-
-    it "should accept multiple ids" do
-      @solr.should_receive(:post_to_solr).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<delete><query>foo:bar</query><query>baz:bum</query></delete>\n")
-      @solr.solr_delete_by_query([ "foo:bar", "baz:bum" ])
-    end
-  end
-  
-  describe "rebuilding the index" do
-    before do
-      Chef::Config[:couchdb_database] = "chunky_bacon"
-    end
-    
-    it "deletes the index and commits" do
-      @solr.should_receive(:solr_delete_by_query).with("X_CHEF_database_CHEF_X:chunky_bacon")
-      @solr.should_receive(:solr_commit)
-      @solr.stub!(:reindex_all)
-      Chef::DataBag.stub!(:cdb_list).and_return([])
-      @solr.rebuild_index
-    end
-    
-    it "reindexes Chef::ApiClient, Chef::Node, and Chef::Role objects, reporting the results as a hash" do
-      @solr.stub!(:solr_delete_by_query).with("X_CHEF_database_CHEF_X:chunky_bacon")
-      @solr.stub!(:solr_commit)
-      @solr.should_receive(:reindex_all).with(Chef::ApiClient).and_return(true)
-      @solr.should_receive(:reindex_all).with(Chef::Node).and_return(true)
-      @solr.should_receive(:reindex_all).with(Chef::Role).and_return(true)
-      Chef::DataBag.stub!(:cdb_list).and_return([])
-      
-      result = @solr.rebuild_index
-      result["Chef::ApiClient"].should == "success"
-      result["Chef::Node"].should == "success"
-      result["Chef::Role"].should == "success"
-    end
-    
-    it "does not reindex Chef::OpenIDRegistration or Chef::WebUIUser objects" do
-      # hi there. the reason we're specifying this behavior is because these objects
-      # are not properly indexed in the first place and trying to reindex them
-      # tickles a bug in our CamelCase to snake_case code. See CHEF-1009.
-      @solr.stub!(:solr_delete_by_query).with("X_CHEF_database_CHEF_X:chunky_bacon")
-      @solr.stub!(:solr_commit)
-      @solr.stub!(:reindex_all).with(Chef::ApiClient)
-      @solr.stub!(:reindex_all).with(Chef::Node)
-      @solr.stub!(:reindex_all).with(Chef::Role)
-      @solr.should_not_receive(:reindex_all).with(Chef::OpenIDRegistration)
-      @solr.should_not_receive(:reindex_all).with(Chef::WebUIUser)
-      Chef::DataBag.stub!(:cdb_list).and_return([])
-      
-      @solr.rebuild_index
-    end
-    
-    it "reindexes databags" do
-      one_data_item = Chef::DataBagItem.new
-      one_data_item.raw_data = {"maybe"=>"snakes actually are evil", "id" => "just_sayin"}
-      two_data_item = Chef::DataBagItem.new
-      two_data_item.raw_data = {"tone_depth"=>"rumble_fish", "id" => "eff_yes"}
-      data_bag = Chef::DataBag.new
-      data_bag.stub!(:list).and_return([one_data_item, two_data_item])
-      
-      @solr.stub!(:solr_delete_by_query).with("X_CHEF_database_CHEF_X:chunky_bacon")
-      @solr.stub!(:solr_commit)
-      @solr.stub!(:reindex_all)
-      Chef::DataBag.stub!(:cdb_list).and_return([data_bag])
-      
-      data_bag.should_receive(:add_to_index)
-      one_data_item.should_receive(:add_to_index)
-      two_data_item.should_receive(:add_to_index)
-      
-      @solr.rebuild_index["Chef::DataBag"].should == "success"
-    end
-  end
-end