microwave 1.0.4 → 11.400.2

data/spec/unit/solr_query/solr_http_request_spec.rb

@@ -1,244 +0,0 @@
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2011 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 'spec_helper'
-
-require 'chef/solr_query'
-require 'net/http'
-
-describe Chef::SolrQuery::SolrHTTPRequest do
-  before do
-    Chef::Config[:solr_url] = "http://example.com:8983"
-    Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@solr_url, nil)
-    Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@url_prefix, nil)
-
-    @request = Chef::SolrQuery::SolrHTTPRequest.new(:GET, '/solr/select')
-  end
-
-  it "defaults to using the configured solr_url" do
-    Chef::SolrQuery::SolrHTTPRequest.solr_url.should == "http://example.com:8983"
-  end
-
-  it "supports solr_url with a path" do
-    Chef::Config[:solr_url] = "http://example.com:8983/test"
-    Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@solr_url, nil)
-
-    Chef::SolrQuery::SolrHTTPRequest.solr_url.should == "http://example.com:8983/test"
-  end
-
-  it "updates the Solr URL as you like" do
-    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234"
-    Chef::SolrQuery::SolrHTTPRequest.solr_url.should == "http://chunkybacon.org:1234"
-  end
-
-  it "updates the URL prefix with a path" do
-    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234/something"
-    Chef::SolrQuery::SolrHTTPRequest.url_prefix.should == "/something"
-  end
-
-  it "removes extra / at the end of solr_url" do
-    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234/extra/"
-    Chef::SolrQuery::SolrHTTPRequest.url_prefix.should == "/extra"
-  end
-
-  it "creates a Net::HTTP client for the base Solr URL" do
-    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234"
-    http_client = Chef::SolrQuery::SolrHTTPRequest.http_client
-    http_client.address.should == "chunkybacon.org"
-    http_client.port.should == 1234
-  end
-
-  it "creates a Net::HTTP client for the base Solr URL ignoring the path" do
-    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234/test"
-    http_client = Chef::SolrQuery::SolrHTTPRequest.http_client
-    http_client.address.should == "chunkybacon.org"
-    http_client.port.should == 1234
-  end
-
-  it "defaults url_prefix to /solr if the configured solr_url has no path" do
-    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234"
-    Chef::SolrQuery::SolrHTTPRequest.url_prefix.should == "/solr"
-  end
-
-  it "defaults url_prefix to the path from the configured solr_url" do
-    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://chunkybacon.org:1234/test"
-    Chef::SolrQuery::SolrHTTPRequest.url_prefix.should == "/test"
-  end
-
-  describe "when configured with the Solr URL" do
-    before 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)
-      Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
-    end
-
-    describe "when executing a select query" do
-      before(:each) do
-        @http_response = mock(
-          "Net::HTTP::Response",
-          :kind_of? => Net::HTTPSuccess,
-          :body => '{"some": "hash" }'
-        )
-        @solr = Chef::SolrQuery.from_params(:type => 'node',
-                                            :q => "hostname:latte")
-        @params = @solr.to_hash
-        @http = mock("Net::HTTP", :request => @http_response)
-        Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
-      end
-
-      describe "when the HTTP call is successful" do
-        it "should call get to /solr/select with the escaped query" do
-          txfm_query = "q=content%3Ahostname__%3D__latte"
-          Net::HTTP::Get.should_receive(:new).with(%r(/solr/select?.+#{txfm_query}))
-          Chef::SolrQuery::SolrHTTPRequest.select(@params)
-        end
-
-        it "uses Solr's JSON response format" do
-          Net::HTTP::Get.should_receive(:new).with(%r(wt=json))
-          Chef::SolrQuery::SolrHTTPRequest.select(@params)
-        end
-
-        it "uses indent=off to get a compact response" do
-          Net::HTTP::Get.should_receive(:new).with(%r(indent=off))
-          Chef::SolrQuery::SolrHTTPRequest.select(@params)
-        end
-
-        it "uses the filter query to restrict the result set" do
-          filter_query =@solr.filter_query.gsub('+', '%2B').gsub(':', "%3A").gsub(' ', '+')
-          Net::HTTP::Get.should_receive(:new).with(/fq=#{Regexp.escape(filter_query)}/)
-          Chef::SolrQuery::SolrHTTPRequest.select(@params)
-        end
-
-        it "returns the evaluated response body" do
-          res = Chef::SolrQuery::SolrHTTPRequest.select(@params)
-          res.should == {"some" => "hash" }
-        end
-      end
-    end
-
-    describe "when updating" do
-      before do
-        Net::HTTP::Post.stub!(:new).and_return(@http_request)
-      end
-
-      it "should post to /solr/update" do
-        @doc = "<xml is the old tldr>"
-        Net::HTTP::Post.should_receive(:new).with("/solr/update", "Content-Type" => "text/xml").and_return(@http_request)
-        Chef::SolrQuery::SolrHTTPRequest.update(@doc)
-      end
-
-      it "should set the body of the request to the stringified doc" do
-        @http_request.should_receive(:body=).with("foo")
-        Chef::SolrQuery::SolrHTTPRequest.update(:foo)
-      end
-
-      it "should send the request to solr" do
-        @http.should_receive(:request).with(@http_request).and_return(@http_response)
-        Chef::SolrQuery::SolrHTTPRequest.update(:foo)
-      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
-          response = mock("Net:HTTPResponse test double", :code => 500, :message => "oops", :class => exception)
-          @http.should_receive(:request).with(instance_of(Net::HTTP::Get)).and_return(response)
-          response.should_receive(:error!).and_raise(exception)
-          Chef::Log.should_receive(:fatal).with("Search Query to Solr failed (#{exception} 500 oops)")
-
-          lambda {@request.run('Search Query to Solr')}.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
-        @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("HTTP Request to Solr failed.  Chef::Exceptions::SolrConnectionError exception: Errno::ECONNREFUSED (net/http undefined method closed?) attempting to contact http://example.com:8983")
-        lambda {
-          @request.run
-        }.should raise_error(Chef::Exceptions::SolrConnectionError)
-      end
-    end
-
-  end
-
-  describe "when configured with the Solr URL with a path" do
-    before do
-      Chef::Config[:solr_url] = "http://example.com:8983/test"
-      Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@solr_url, nil)
-      Chef::SolrQuery::SolrHTTPRequest.instance_variable_set(:@url_prefix, nil)
-
-      @request = Chef::SolrQuery::SolrHTTPRequest.new(:GET, '/solr/select')
-
-      @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)
-      Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
-    end
-
-    describe "when executing a select query" do
-      before(:each) do
-        @http_response = mock(
-          "Net::HTTP::Response",
-          :kind_of? => Net::HTTPSuccess,
-          :body => '{"some": "hash" }'
-        )
-        @solr = Chef::SolrQuery.from_params(:type => 'node',
-                                            :q => "hostname:latte")
-        @params = @solr.to_hash
-        @http = mock("Net::HTTP", :request => @http_response)
-        Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
-      end
-
-      describe "when the HTTP call is successful" do
-        it "should call get to /test/select with the escaped query" do
-          txfm_query = "q=content%3Ahostname__%3D__latte"
-          Net::HTTP::Get.should_receive(:new).with(%r(/test/select?.+#{txfm_query}))
-          Chef::SolrQuery::SolrHTTPRequest.select(@params)
-        end
-      end
-    end
-
-    describe "when updating" do
-      before do
-        Net::HTTP::Post.stub!(:new).and_return(@http_request)
-      end
-
-      it "should post to /test/update" do
-        @doc = "<xml is the old tldr>"
-        Net::HTTP::Post.should_receive(:new).with("/test/update", "Content-Type" => "text/xml").and_return(@http_request)
-        Chef::SolrQuery::SolrHTTPRequest.update(@doc)
-      end
-    end
-  end
-end

data/spec/unit/solr_query_spec.rb

@@ -1,203 +0,0 @@
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2010, 2011 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 'spec_helper'
-
-require 'chef/solr_query'
-require 'net/http'
-
-#require 'rspec/mocks'
-
-describe Chef::SolrQuery do
-  before do
-    Chef::SolrQuery::SolrHTTPRequest.solr_url = "http://example.com:8983"
-
-    @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)
-    Chef::SolrQuery::SolrHTTPRequest.stub!(:http_client).and_return(@http)
-    Net::HTTP::Post.stub!(:new).and_return(@http_request)
-    Net::HTTP::Get.stub!(:new).and_return(@http_request)
-    @doc = { "foo" => "bar" }
-  end
-
-  before(:each) do
-    @solr = Chef::SolrQuery.new
-  end
-
-  it "sets filter query params" do
-    @solr.filter_by(:database => 'chef')
-    @solr.filter_query.should == "+X_CHEF_database_CHEF_X:chef"
-  end
-
-  it "filters by type when querying for a builtin type" do
-    @solr.filter_by_type("node")
-    @solr.filter_query.should == "+X_CHEF_type_CHEF_X:node"
-  end
-
-  it "filters by type for data bag items" do
-    @solr.filter_by_type("users")
-    @solr.filter_query.split(" ").sort.should == ['+X_CHEF_type_CHEF_X:data_bag_item', '+data_bag:users']
-  end
-
-  it "stores the main query" do
-    @solr.query = "role:prod AND tags:chef-server"
-    @solr.query.should == "role:prod AND tags:chef-server"
-  end
-
-  describe "when generating query params for select" do
-    before(:each) do
-      @solr = Chef::SolrQuery.from_params(:type => 'node', :q => "hostname:latte")
-      @params = @solr.to_hash
-    end
-
-    it "includes the query as q" do
-      @params[:q].should == "content:hostname__=__latte"
-    end
-
-    it "sets the response format to json" do
-      @params[:wt].should == "json"
-    end
-
-    it "uses indent=off to get a compact response" do
-      @params[:indent].should == "off"
-    end
-
-    it "includes the filter query to restrict the result set" do
-      @params[:fq].should == @solr.filter_query
-    end
-
-    it "defaults to returning 1000 rows" do
-      @params[:rows].should == 1000
-    end
-
-    it "returns the number of rows requested" do
-      @solr.params[:rows] = 500
-      @solr.to_hash[:rows].should == 500
-    end
-
-    it "offsets the row selection if requested" do
-      @solr.params[:start] = 500
-      @solr.to_hash[:start].should == 500
-    end
-
-  end
-
-  describe "when querying solr" do
-    before do
-      @couchdb = mock("CouchDB Test Double", :couchdb_database => "chunky_bacon")
-      @couchdb.stub!(:kind_of?).with(Chef::CouchDB).and_return(true) #ugh.
-      @solr = Chef::SolrQuery.from_params({:type => 'node', :q => "hostname:latte", :start => 10, :rows => 5}, @couchdb)
-      @docs = [1,2,3,4,5].map { |doc_id| {'X_CHEF_id_CHEF_X' => doc_id} }
-      @solr_response = {"response" => {"docs" => @docs, "start" => 10, "results" => 123}}
-      Chef::SolrQuery::SolrHTTPRequest.should_receive(:select).with(@solr.to_hash).and_return(@solr_response)
-    end
-
-    it "it collects the document ids from the response" do
-      @solr.object_ids.should == [1,2,3,4,5]
-    end
-
-    it "does a bulk get of the objects from CouchDB" do
-      @couchdb.should_receive(:bulk_get).with([1,2,3,4,5]).and_return(%w{obj1 obj2 obj3 obj4 obj5})
-      @solr.objects.should == %w{obj1 obj2 obj3 obj4 obj5}
-    end
-
-  end
-
-  describe "when forcing a Solr commit" do
-    it "sends valid commit xml to solr" do
-      Chef::SolrQuery::SolrHTTPRequest.should_receive(:update).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<commit/>\n")
-      @solr.commit
-    end
-  end
-
-  describe "when deleting a database from Solr" do
-    it "sends a valid delete query to solr and forces a commit" do
-      Chef::SolrQuery::SolrHTTPRequest.should_receive(:update).with("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<delete><query>X_CHEF_database_CHEF_X:chef</query></delete>\n")
-      @solr.should_receive(:commit)
-      @solr.delete_database("chef")
-    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(:delete_database).with("chunky_bacon")
-      @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.should_receive(:delete_database).with("chunky_bacon")
-      @solr.should_receive(:reindex_all).with(Chef::ApiClient).and_return(true)
-      @solr.should_receive(:reindex_all).with(Chef::Environment).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.should_receive(:delete_database).with("chunky_bacon")
-      @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.should_receive(:delete_database).with("chunky_bacon")
-      @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

data/spec/unit/webui_user_spec.rb

@@ -1,238 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright (c) 2009 Daniel DeLeo
-# 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 'spec_helper'
-
-describe Chef::WebUIUser do
-  
-  before do
-    @webui_user = Chef::WebUIUser.new
-  end
-  
-  it "stores the admin status of the user" do
-    @webui_user.admin.should be_false
-    @webui_user.admin = true
-    @webui_user.admin.should be_true
-    @webui_user.should be_admin
-  end
-  
-  it "stores the name with underscores subbed for dots" do
-    @webui_user.name.should be_nil
-    @webui_user.name = "foo.bar.baz"
-    @webui_user.name.should == "foo_bar_baz"
-  end
-  
-  it "can be initialized with a hash to set instance variables" do
-    opt_hsh = {'name'=>'mud', 'salt'=>'just_a_lil', 'password'=>'beefded',
-              'openid'=>'notsomuch', '_rev'=>'0', '_id'=>'tehid'}
-    webui_user = Chef::WebUIUser.new(opt_hsh)
-    webui_user.name.should        == 'mud'
-    webui_user.salt.should        == 'just_a_lil'
-    webui_user.password.should    == 'beefded'
-    webui_user.openid.should      == 'notsomuch'
-    webui_user.couchdb_rev.should == '0'
-    webui_user.couchdb_id.should  == 'tehid'
-  end
-  
-  describe "when setting or verifying a password" do
-    it "raises an error when the password doesn't match the confirmation password" do
-      lambda {@webui_user.set_password("nomnomnom", "yukyukyuk")}.should raise_error(ArgumentError, /do not match/)
-    end
-    
-    it "doesn't allow blank passwords" do
-      lambda {@webui_user.set_password("", "")}.should raise_error(ArgumentError, /cannot be blank/)
-    end
-    
-    it "doesn't allow passwords less than 6 characters" do
-      lambda {@webui_user.set_password("2shrt", "2shrt")}.should raise_error(ArgumentError, /minimum of 6 characters/)
-    end
-    
-    it "generates a salt and hashes the password when the password is valid" do
-      @webui_user.set_password("valid_pw", "valid_pw")
-      @webui_user.salt.should_not be_nil
-      @webui_user.password.should match(/[0-9a-f]{32}/)
-    end
-    
-    it "verifies a correct password" do
-      @webui_user.set_password("valid_pw", "valid_pw")
-      @webui_user.verify_password("valid_pw").should be_true
-    end
-    
-    it "doesn't verify an incorrect password" do
-      @webui_user.set_password("valid_pw", "valid_pw")
-      @webui_user.verify_password("invalid_pw").should be_false
-    end
-  end
-  
-  describe "when doing CRUD operations via API" do
-    before do
-      @webui_user.name = "test_user"
-      @rest = mock("Chef::REST")
-      Chef::REST.stub!(:new).and_return(@rest)
-    end
-    
-    it "finds users by name via GET" do
-      @rest.should_receive(:get_rest).with("users/mud")
-      Chef::WebUIUser.load("mud")
-    end
-    
-    it "finds all ids in the database via GET" do
-      @rest.should_receive(:get_rest).with("users")
-      Chef::WebUIUser.list
-    end
-    
-    it "finds all documents in the database via GET" do
-      robots  = Chef::WebUIUser.new("name"=>"we_robots")
-      happy   = Chef::WebUIUser.new("name"=>"are_happy_robots")
-      query_results = [robots,happy]
-      query_obj = mock("Chef::Search::Query")
-      query_obj.should_receive(:search).with(:user).and_yield(query_results.first).and_yield(query_results.last)
-      Chef::Search::Query.stub!(:new).and_return(query_obj)
-      Chef::WebUIUser.list(true).should == {"we_robots" => robots, "are_happy_robots" => happy}
-    end
-    
-    it "updates via PUT when saving" do
-      @rest.should_receive(:put_rest).with("users/test_user", @webui_user)
-      @webui_user.save
-    end
-    
-    it "falls back to creating via POST if updating returns 404" do
-      response = mock("Net::HTTPResponse", :code => "404")
-      not_found = Net::HTTPServerException.new("404", response)
-      @rest.should_receive(:put_rest).with("users/test_user", @webui_user).and_raise(not_found)
-      @rest.should_receive(:post_rest).with("users", @webui_user)
-      @webui_user.save
-    end
-    
-    it "creates via POST" do
-      @rest.should_receive(:post_rest).with("users", @webui_user)
-      @webui_user.create
-    end
-    
-    it "deletes itself with DELETE" do
-      @rest.should_receive(:delete_rest).with("users/test_user")
-      @webui_user.destroy
-    end
-  end
-  
-  describe "when doing CRUD operations to the DB" do
-    before do
-      @webui_user.name = "relaxed_test"
-      @couchdb = mock("Chef::Couchdb")
-      Chef::CouchDB.stub(:new).and_return(@couchdb)
-      @webui_user.instance_variable_set(:@couchdb, @couchdb)
-    end
-    
-    it "finds users by name" do
-      @couchdb.should_receive(:load).with("webui_user", "test_user")
-      Chef::WebUIUser.cdb_load("test_user")
-    end
-    
-    it "finds all ids in the database" do
-      couch_rows = {"one"=>"mos_def","two"=>"and","three"=>"talib_kweli"}.map do |key, val|
-        {"key" => key, "value" => val}
-      end
-      couch_return_val = {"rows" => couch_rows}
-      @couchdb.should_receive(:list).with("users", false).and_return(couch_return_val)
-      Chef::WebUIUser.cdb_list.sort.should == %w{one two three}.sort
-    end
-    
-    it "finds all documents in the database" do
-      couch_rows = {"one"=>"mos_def","two"=>"and","three"=>"talib_kweli"}.map do |key, val|
-        {"key" => key, "value" => val}
-      end
-      couch_return_val = {"rows" => couch_rows}
-      @couchdb.should_receive(:list).with("users", true).and_return(couch_return_val)
-      Chef::WebUIUser.cdb_list(true).sort.should == %w{mos_def and talib_kweli}.sort
-    end
-    
-    it "updates and saves documents" do
-      @couchdb.should_receive(:store).with("webui_user", "relaxed_test", @webui_user).and_return("rev"=>"run")
-      @webui_user.cdb_save
-      @webui_user.couchdb_rev.should == "run"
-    end
-    
-    it "deletes itself" do
-      @webui_user = Chef::WebUIUser.new("_rev" => "run", "name" => "relaxed_test")
-      @couchdb.should_receive(:delete).with("webui_user", "relaxed_test", "run")
-      @webui_user.cdb_destroy
-    end
-  end
-  
-  describe "when converting to/from JSON" do
-    before do
-      @webui_user.name = "test_user"
-    end
-    
-    it "keeps type data so it can be deserialized" do
-      @webui_user.to_json.should match(Regexp.escape('"json_class":"Chef::WebUIUser"'))
-    end
-    
-    it "includes the name, salt, password, openid and admin status" do
-      @webui_user = Chef::WebUIUser.new("name"=>"test_user","password"=>"pw","salt"=>"pirate","openid"=>"really?")
-      @webui_user.admin = true
-      json = @webui_user.to_json
-      
-      json.should match(Regexp.escape('"name":"test_user"'))
-      json.should match(Regexp.escape('"password":"pw"'))
-      json.should match(Regexp.escape('"salt":"pirate"'))
-      json.should match(Regexp.escape('"openid":"really?"'))
-      json.should match(Regexp.escape('"admin":true'))
-    end
-    
-    it "includes the couchdb _rev if available" do
-      @webui_user = Chef::WebUIUser.new("_rev"=>"RuN")
-      json = @webui_user.to_json
-      json.should match(Regexp.escape('"_rev":"RuN"'))
-    end
-    
-    it "includes the couchdb _id if available" do
-      @webui_user = Chef::WebUIUser.new("_id"=>"ego")
-      json = @webui_user.to_json
-      json.should match(Regexp.escape('"_id":"ego"'))
-    end
-  end
-  
-  describe "behaving like a couch-able (relaxed?) object (cf CHEF-864)" do
-    it "has an attr reader for couchdb_id" do
-      @webui_user.should_not respond_to(:couchdb_id=)
-      @webui_user.should respond_to(:couchdb_id)
-      @webui_user.instance_variable_set(:@couchdb_id, "a big long UUID")
-      @webui_user.couchdb_id.should == "a big long UUID"
-    end
-    
-    it "sets its couchdb id when loading from the database" do
-      # reqs via REST eventually get to Chef::JSONCompat.from_json
-      webui_user = Chef::JSONCompat.from_json('{"salt":null,"name":"test_user","json_class":"Chef::WebUIUser","admin":false,"openid":null,"password":null,"chef_type":"webui_user","_id":"IdontNeedNoID"}')
-      webui_user.couchdb_id.should == "IdontNeedNoID"
-    end
-    
-    it "has an attr reader for couchdb_rev" do
-      @webui_user.should_not respond_to(:couchdb_rev=)
-      @webui_user.should respond_to(:couchdb_rev)
-      @webui_user.instance_variable_set(:@couchdb_rev, "a couchdb version string")
-      @webui_user.couchdb_rev.should == "a couchdb version string"
-    end
-    
-    it "sets the couchdb_rev when loading from the database" do
-      webui_user = Chef::JSONCompat.from_json('{"salt":null,"name":"test_user","json_class":"Chef::WebUIUser","admin":false,"openid":null,"password":null,"chef_type":"webui_user","_id":"IdontNeedNoID","_rev":"moto"}')
-      webui_user.couchdb_rev.should == "moto"
-    end
-  end
-  
-end