erchef-solr 11.4.0

data/lib/chef/solr/solr_installer.rb

@@ -0,0 +1,386 @@
+#
+# 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 'pp'
+require 'optparse'
+require 'chef/solr/version'
+require 'chef/shell_out'
+require 'chef/mixin/shell_out'
+
+class Chef
+  class SolrInstaller
+
+    class Config
+      class CompatConfig
+        def initialize
+          @config_settings = {}
+        end
+
+        def from_file(file)
+          file = File.expand_path(file)
+          if File.readable?(file)
+            instance_eval(IO.read(file), file, 1)
+          else
+            STDERR.puts "Cannot open config file #{file} default settings will be used"
+          end
+          self
+        end
+
+        def method_missing(method_name, *args, &block)
+          if args.size == 1
+            @config_settings[method_name] = args.first
+          elsif args.empty?
+            @config_settings[method_name] or super
+          else
+            super
+          end
+        end
+
+        def to_hash
+          @config_settings
+        end
+      end
+
+
+      def self.default_values
+        @default_values ||= {}
+      end
+
+      def self.configurables
+        @configurables ||= []
+      end
+
+      def self.configurable(value, default=nil)
+        configurables << value
+        attr_accessor value
+        default_values[value] = default if default
+      end
+
+      def each_configurable
+        self.class.configurables.each do |config_param|
+          yield [config_param, send(config_param)]
+        end
+      end
+
+      configurable :config_file, '/etc/chef/solr.rb'
+
+      # Defaults to /var/chef
+      configurable :solr_base_path, nil
+
+      def solr_base_path
+        @solr_base_path || '/var/chef'
+      end
+
+      # Sets the solr_base_path. Also resets solr_home_path, solr_jetty_path,
+      # and solr_data_path.
+      def solr_base_path=(base_path)
+        @solr_home_path, @solr_jetty_path, @solr_data_path = nil,nil,nil
+        @solr_base_path = base_path
+      end
+
+
+      # Computed from base path, defaults to /var/chef/solr
+      configurable :solr_home_path, nil
+
+      def solr_home_path
+        @solr_home_path || File.join(solr_base_path, 'solr')
+      end
+
+      # Computed from base path, defaults to /var/chef/solr-jetty
+      configurable :solr_jetty_path, nil
+
+      def solr_jetty_path
+        @solr_jetty_path || File.join(solr_base_path, 'solr-jetty')
+      end
+
+      # Computed from base path, defaults to /var/chef/solr/data
+      configurable :solr_data_path, nil
+
+      def solr_data_path
+        @solr_data_path || File.join(solr_base_path, 'solr', 'data')
+      end
+
+
+      configurable :user, nil
+
+      configurable :group, nil
+
+      configurable :force, false
+
+      alias :force? :force
+
+      configurable :noop, false
+
+      alias :noop? :noop
+
+      def initialize
+        apply_hash(self.class.default_values)
+      end
+
+      def configure_from(argv)
+        cli_config = CLI.parse_options(argv)
+        #pp :cli_config => cli_config.to_hash
+        config_file_config = CompatConfig.new.from_file(cli_config.config_file).to_hash
+        #pp :config_file_config => config_file_config
+        apply_hash(config_file_config)
+        apply_hash(cli_config.to_hash)
+        #pp :combined_config => self.to_hash
+        self
+      end
+
+      def to_hash
+        self.class.configurables.inject({}) do |hash, config_option|
+          value = instance_variable_get("@#{config_option}".to_sym)
+          hash[config_option] = value if value
+          hash
+        end
+      end
+
+      def apply_hash(hash)
+        hash.each do |key, value|
+          method_for_key = "#{key}=".to_sym
+          if respond_to?(method_for_key)
+            send(method_for_key, value)
+          else
+            STDERR.puts("Configuration setting #{key} is unknown and will be ignored")
+          end
+        end
+      end
+
+      module CLI
+        @config = Config.new
+
+        @option_parser = OptionParser.new do |o|
+          o.banner = "Usage: chef-solr-installer [options]"
+
+          o.on('-c', '--config CONFIG_FILE', 'The configuration file to use') do |conf|
+            @config.config_file = File.expand_path(conf)
+          end
+
+          o.on('-u', '--user USER', "User who will own Solr's data directory") do |u|
+            @config.user = u
+          end
+
+          o.on('-g', '--group GROUP', "Group that will own Solr's data directory") do |g|
+            @config.group = g
+          end
+
+          o.on('-p', '--base-path PATH', "The base path for the installation. Must be given before any -H -W or -D options") do |path|
+            @config.solr_base_path = path
+          end
+
+          o.on('-H', '--solr-home-dir PATH', 'Where to create the Solr home directory. Defaults to BASE_PATH/solr') do |path|
+            @config.solr_home_path = path
+          end
+
+          o.on('-W', '--solr-jetty-path PATH', 'Where to install Jetty for Solr. Defaults to BASE_PATH/solr-jetty ') do |path|
+            @config.solr_jetty_path = path
+          end
+
+          o.on('-D', '--solr-data-path PATH', 'Where to create the Solr data directory. Defaults to BASE_PATH/solr/data') do |path|
+            @config.solr_data_path = path
+          end
+
+          o.on('-n', '--noop', "Don't actually install, just show what would be done by the install") do
+            @config.noop = true
+          end
+
+          o.on('-f', '--force', 'Overwrite any existing installation without asking for confirmation') do
+            @config.force = true
+          end
+
+          o.on_tail('-h', '--help', 'show this message') do
+            puts "chef-solr-installer #{Chef::Solr::VERSION}"
+            puts ''
+            puts o
+            puts ''
+            puts 'Default Settings:'
+            @config.each_configurable do |param, value|
+              value_for_display = value || "none/false"
+              puts "  #{param}:".ljust(20) + " #{value_for_display}"
+            end
+            exit 1
+          end
+
+          o.on_tail('-v', '--version', 'show the version and exit') do
+            puts "chef-solr-installer #{Chef::Solr::VERSION}"
+            exit 0
+          end
+
+        end
+
+        def self.parse_options(argv)
+          @option_parser.parse!(argv.dup)
+          @config
+        end
+
+        def self.config
+          @config
+        end
+
+      end
+
+    end
+
+    include Chef::Mixin::ShellOut
+
+    PACKAGED_SOLR_DIR = File.expand_path( "../../../../solr", __FILE__)
+
+    attr_reader :config
+
+    def initialize(argv)
+      @indent = 0
+      @config = Config.new.configure_from(argv.dup)
+      @overwriting = false
+    end
+
+    def overwriting?
+      @overwriting
+    end
+
+    def chef_solr_installed?
+      File.exist?(config.solr_home_path)
+    end
+
+    def run
+      say ''
+      say "*** DRY RUN ***" if config.noop?
+
+      if chef_solr_installed?
+        @overwriting = true
+        confirm_overwrite unless config.force? || config.noop?
+        scorch_the_earth
+      end
+
+      create_solr_home
+      create_solr_data_dir
+      unpack_solr_jetty
+
+      say ""
+      say "Successfully installed Chef Solr."
+
+      if overwriting?
+        say "You can restore your search index using `knife index rebuild`"
+      end
+    end
+
+    def confirm_overwrite
+      if STDIN.tty? && STDOUT.tty?
+        say "Chef Solr is already installed in #{config.solr_home_path}"
+        print "Do you want to overwrite the current install? All existing Solr data will be lost. [y/n] "
+        unless STDIN.gets =~ /^y/
+          say "Quitting. Try running this with --noop to see what it will change."
+          exit 1
+        end
+      else
+        say(<<-FAIL)
+ERROR: Chef Solr is already installed in #{config.solr_home_path} and you did not use the
+--force option. Use --force to overwrite an existing installation in a non-
+interactive terminal.
+FAIL
+        exit 1
+      end
+    end
+
+    def scorch_the_earth
+      group("Removing the existing Chef Solr installation") do
+        rm_rf(config.solr_home_path)
+        rm_rf(config.solr_jetty_path)
+        rm_rf(config.solr_data_path)
+      end
+    end
+
+    def create_solr_home
+      group("Creating Solr Home Directory") do
+        mkdir_p(config.solr_home_path)
+        chdir(config.solr_home_path) do
+          sh("tar zxvf #{File.join(PACKAGED_SOLR_DIR, 'solr-home.tar.gz')}")
+        end
+      end
+    end
+
+    def create_solr_data_dir
+      group("Creating Solr Data Directory") do
+        mkdir_p(config.solr_data_path)
+        chown(config.solr_data_path)
+      end
+    end
+
+    def unpack_solr_jetty
+      group("Unpacking Solr Jetty") do
+        mkdir_p(config.solr_jetty_path)
+        chdir(config.solr_jetty_path) do
+          sh("tar zxvf #{File.join(PACKAGED_SOLR_DIR, 'solr-jetty.tar.gz')}")
+        end
+        chown(config.solr_jetty_path)
+      end
+    end
+
+    def mkdir_p(directory)
+      say "mkdir -p #{directory}"
+      FileUtils.mkdir_p(directory, :mode => 0755) unless config.noop?
+    end
+
+    def chdir(dir, &block)
+      say "entering #{dir}"
+      if config.noop?
+        yield if block_given? # still call the block so we get the noop output.
+      else
+        Dir.chdir(dir) { yield if block_given? }
+      end
+    end
+
+    def sh(*args)
+      opts = args[1, args.size - 1]
+      opts_msg = opts.empty? ? '' : " #{opts.to_s}"
+      say "#{args.first}#{opts_msg}"
+      shell_out!(*(args << {:cwd => false})) unless config.noop?
+    end
+
+    def chown(file)
+      if config.user
+        msg = "chown -R #{config.user}"
+        msg << ":#{config.group}" if config.group
+        msg << " #{file}"
+        say msg
+        FileUtils.chown_R(config.user, config.group, file) unless config.noop?
+      end
+    end
+
+    def rm_rf(path)
+      say "rm -rf #{path}"
+      FileUtils.rm_rf(path) unless config.noop?
+    end
+
+    def indent
+      @indent += 1
+      yield
+      @indent -= 1
+    end
+
+    def group(message, &block)
+      say(message)
+      indent(&block)
+    end
+
+    def say(message)
+      puts "#{' ' * (2 * @indent)}#{message}"
+    end
+
+  end
+end
+

data/lib/chef/solr/version.rb

@@ -0,0 +1,11 @@
+class Chef
+  class Solr
+    VERSION = '11.0.0.alpha.1'
+
+    # Solr Schema. Used to detect incompatibilities between installed solr and
+    # chef-solr versions.
+    SCHEMA_NAME = "chef"
+    SCHEMA_VERSION = '1.2'
+
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+-cbfs

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright (c) 2012 Thomas Bishop
+# 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 'rspec'
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
+$:.unshift(File.expand_path('../../lib/', __FILE__))
+$:.unshift(File.expand_path('../../../chef/lib', __FILE__))
+
+require 'chef/solr'

data/spec/unit/application/solr_spec.rb

@@ -0,0 +1,569 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright (c) 2012 Thomas Bishop
+# 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/application/solr'
+
+describe Chef::Solr::Application::Solr do
+
+  describe 'initialize' do
+    it 'should have a default config_file option' do
+      subject.config[:config_file].should == '/etc/chef/solr.rb'
+    end
+  end
+
+  describe 'schema_file_path' do
+    it 'should return the default schema file path' do
+      subject.schema_file_path.should == '/var/chef/solr/conf/schema.xml'
+    end
+
+    context 'with a custom solr home path' do
+      it 'should return the schema path' do
+        Chef::Config.stub(:[]).with(:solr_home_path).
+                               and_return('/opt/chef/solr')
+        subject.schema_file_path.should == '/opt/chef/solr/conf/schema.xml'
+      end
+    end
+
+  end
+
+  describe 'solr_config_file_path' do
+    it 'should return the default solr config path' do
+      subject.solr_config_file_path.should == '/var/chef/solr/conf/solrconfig.xml'
+    end
+
+    context 'with a custom solr home path' do
+      it 'should return the solr config path' do
+        Chef::Config.stub(:[]).with(:solr_home_path).
+                               and_return('/opt/chef/solr')
+        subject.solr_config_file_path.should == '/opt/chef/solr/conf/solrconfig.xml'
+      end
+    end
+
+  end
+
+  describe 'schema_document' do
+    before do
+      @schema_path = '/opt/chef/solr/conf/schema.xml'
+      subject.stub :schema_file_path => @schema_path
+      @doc_contents = '<?xml version="1.0" encoding="UTF-8" ?><foo>bar</foo>'
+    end
+
+    it 'should read the schema file at the correct path' do
+      REXML::Document.stub(:new)
+      File.should_receive(:open).with(@schema_path, 'r').
+                                 and_yield(@doc_contents)
+      subject.schema_document
+    end
+
+    it 'should return the schema' do
+      File.stub(:open).and_yield(@doc_contents)
+      subject.schema_document.should be_a REXML::Document
+    end
+  end
+
+  describe 'config_document' do
+    before do
+      @solr_config_path = '/opt/chef/solr/conf/solrconfig.xml'
+      subject.stub :solr_config_file_path => @solr_config_path
+      @doc_contents = '<?xml version="1.0" encoding="UTF-8" ?><foo>bar</foo>'
+    end
+
+    it 'should read the config file at the correct path' do
+      REXML::Document.stub(:new)
+      File.should_receive(:open).with(@solr_config_path, 'r').
+                                 and_yield(@doc_contents)
+      subject.config_document
+    end
+
+    it 'should return an REXML document' do
+      File.stub(:open).and_yield(@doc_contents)
+      subject.config_document.should be_a REXML::Document
+    end
+  end
+
+  describe 'schema_attributes' do
+    it 'should return the attributes of the schema element' do
+      schema_doc_contents = '<?xml version="1.0" encoding="UTF-8" ?>'
+      schema_doc_contents << '<schema name="chef" version="1.2"></schema>'
+      subject.stub(:schema_document).
+              and_return(REXML::Document.new(schema_doc_contents))
+
+      subject.schema_attributes["name"].should == 'chef'
+      subject.schema_attributes["version"].should == '1.2'
+    end
+  end
+
+  describe 'solr_main_index_elements' do
+    before do
+      doc_contents = '<?xml version="1.0" encoding="UTF-8" ?>'
+      doc_contents << '<config><mainIndex>'
+      doc_contents << '<maxFieldLength>10000</maxFieldLength>'
+      doc_contents << '</mainIndex></config>'
+      subject.stub(:config_document).
+              and_return(REXML::Document.new(doc_contents))
+    end
+
+    it 'should return a collection of the REXML elements' do
+      subject.solr_main_index_elements.each { |e| e.should be_a REXML::Element }
+    end
+
+    it 'should return the correct elements' do
+      subject.solr_main_index_elements.first.name.should == 'maxFieldLength'
+      subject.solr_main_index_elements.first.text.should == '10000'
+    end
+  end
+
+  describe 'solr_schema_name' do
+    it 'should return the schema name' do
+      subject.stub :schema_attributes => { 'name' => 'chef' }
+      subject.solr_schema_name.should == 'chef'
+    end
+  end
+
+  describe 'solr_schema_version' do
+    it 'should return the schema version' do
+      subject.stub :schema_attributes => { 'version' => '1.2' }
+      subject.solr_schema_version.should == '1.2'
+    end
+  end
+
+  describe 'solr_main_index_max_field_length' do
+    before do
+      @elements = [ REXML::Element.new('useCompoundFile').add_text('false'),
+                    REXML::Element.new('ramBufferSizeMB').add_text('32'),
+                    REXML::Element.new('maxFieldLength').add_text('10000') ]
+      subject.stub :solr_main_index_elements => @elements
+    end
+
+    it 'should return the value of maxFieldLimit as an integer' do
+      subject.solr_main_index_max_field_length.should == 10000
+    end
+
+    context 'if unable to find the maxFieldLimit' do
+      before do
+        elements = @elements.select { |e| e.name != 'maxFieldLength' }
+        subject.stub :solr_main_index_elements => elements
+      end
+
+      it 'should return nil' do
+        subject.solr_main_index_max_field_length.should be_nil
+      end
+    end
+
+  end
+
+  describe 'valid_schema_name?' do
+    it 'should return true if the schema name matches' do
+      subject.stub :solr_schema_name => Chef::Solr::SCHEMA_NAME
+      subject.valid_schema_name?.should be_true
+    end
+
+    it 'should return false if the schema name does not match' do
+      subject.stub :solr_schema_name => 'foo'
+      subject.valid_schema_name?.should be_false
+    end
+  end
+
+  describe 'valid_schema_version?' do
+    it 'should return true if the version name matches' do
+      subject.stub :solr_schema_version => Chef::Solr::SCHEMA_VERSION
+      subject.valid_schema_version?.should be_true
+    end
+
+    it 'should return false if the version name does not match' do
+      subject.stub :solr_schema_version => '-1.0'
+      subject.valid_schema_version?.should be_false
+    end
+  end
+
+  describe 'check_value_of_main_index_max_field_length' do
+    it 'should log a warning if it is set to <= 10000' do
+      subject.stub :solr_main_index_max_field_length => 10000
+      pattern = /maxFieldLimit.+set to.+recommended to increase this value/
+      Chef::Log.should_receive(:warn).with(pattern)
+      subject.check_value_of_main_index_max_field_length
+    end
+
+    it 'should not log a warning if it is set to > 10000' do
+      subject.stub :solr_main_index_max_field_length => 10001
+      Chef::Log.should_not_receive(:warn)
+      subject.check_value_of_main_index_max_field_length
+    end
+
+    context 'if it is not set' do
+      it 'should log a warning if it is not set' do
+        subject.stub :solr_main_index_max_field_length => nil
+        Chef::Log.should_receive(:warn).
+                  with(/Unable to determine the maxFieldLimit for the mainIndex/)
+        subject.check_value_of_main_index_max_field_length
+      end
+    end
+
+  end
+
+  describe 'solr_home_exists?' do
+    before do
+      Chef::Config.stub(:[]).with(:solr_home_path).
+                             and_return('/opt/chef/solr')
+    end
+
+    it 'should return true if the solr home exists' do
+      File.stub(:directory?).with('/opt/chef/solr').
+                             and_return(true)
+      subject.solr_home_exist?.should be_true
+    end
+
+    it 'should return false if the solr home does not exist' do
+      File.stub(:directory?).with('/opt/chef/solr').
+                             and_return(false)
+      subject.solr_home_exist?.should be_false
+    end
+  end
+
+  describe 'solr_data_dir_exists?' do
+    before do
+      Chef::Config.stub(:[]).with(:solr_data_path).
+                             and_return('/opt/chef/solr')
+    end
+
+    it 'should return true if the solr data dir exists' do
+      File.stub(:directory?).with('/opt/chef/solr').
+                             and_return(true)
+      subject.solr_data_dir_exist?.should be_true
+    end
+
+    it 'should return false if the solr data dir does not exist' do
+      File.stub(:directory?).with('/opt/chef/solr').
+                             and_return(false)
+      subject.solr_data_dir_exist?.should be_false
+    end
+  end
+
+  describe 'solr_jetty_home_exists?' do
+    before do
+      Chef::Config.stub(:[]).with(:solr_jetty_path).
+                             and_return('/opt/chef/solr')
+    end
+
+    it 'should return true if the solr jetty dir exists' do
+      File.stub(:directory?).with('/opt/chef/solr').
+                             and_return(true)
+      subject.solr_jetty_home_exist?.should be_true
+    end
+
+    it 'should return false if the solr jetty dir does not exist' do
+      File.stub(:directory?).with('/opt/chef/solr').
+                             and_return(false)
+      subject.solr_jetty_home_exist?.should be_false
+    end
+  end
+
+  describe 'assert_solr_installed!' do
+
+    context 'when unsuccessful' do
+      before do
+        message = /chef solr is not installed.+home.+data.+jetty.+misconfigured/i
+        Chef::Log.should_receive(:fatal).with(message).and_return(true)
+        Chef::Log.stub(:fatal)
+      end
+
+      context 'because the solr home does not exist' do
+        before do
+          subject.stub :solr_home_exist? => false
+          subject.stub :solr_data_dir_exist => true
+          subject.stub :solr_jetty_home_exist => true
+        end
+
+        it 'should log messages and exit' do
+          lambda {
+            subject.assert_solr_installed!
+          }.should raise_error SystemExit
+        end
+      end
+
+      context 'because the solr data dir does not exist' do
+        before do
+          subject.stub :solr_home_exist? => true
+          subject.stub :solr_data_dir_exist => false
+          subject.stub :solr_jetty_home_exist => true
+        end
+
+        it 'should log messages and exit' do
+          lambda {
+            subject.assert_solr_installed!
+          }.should raise_error SystemExit
+        end
+      end
+
+      context 'because the solr jetty home does not exist' do
+        before do
+          subject.stub :solr_home_exist? => true
+          subject.stub :solr_data_dir_exist => true
+          subject.stub :solr_jetty_home_exist => false
+        end
+
+        it 'should log messages and exit' do
+          lambda {
+            subject.assert_solr_installed!
+          }.should raise_error SystemExit
+        end
+      end
+
+    end
+
+    context 'when solr home, data dir, and jetty home exist' do
+      before do
+        ['home', 'data_dir', 'jetty_home'].each do |item|
+          subject.stub "solr_#{item}_exist?".to_sym => true
+        end
+      end
+
+      it 'should not exit' do
+        subject.assert_solr_installed!.should_not raise_error SystemExit
+      end
+    end
+
+  end
+
+  describe 'assert_valid_schema!' do
+    context 'when unsuccessful' do
+      before do
+        message = /chef solr installation.+upgraded.+/i
+        Chef::Log.should_receive(:fatal).with(message).and_return(true)
+        Chef::Log.stub(:fatal)
+        subject.stub :solr_schema_version => ''
+      end
+
+      context 'because the schema name is not valid' do
+        before do
+          subject.stub :valid_schema_name? => false
+          subject.stub :valid_schema_version => true
+        end
+
+        it 'should log messages and exit' do
+          lambda {
+            subject.assert_valid_schema!
+          }.should raise_error SystemExit
+        end
+      end
+
+      context 'because the schema version is not valid' do
+        before do
+          subject.stub :valid_schema_name? => true
+          subject.stub :valid_schema_version => false
+        end
+
+        it 'should log messages and exit' do
+          lambda {
+            subject.assert_valid_schema!
+          }.should raise_error SystemExit
+        end
+      end
+
+    end
+
+    context 'when the schema name and version are valid' do
+      before do
+        ['name', 'version'].each do |item|
+          subject.stub "valid_schema_#{item}?".to_sym => true
+        end
+      end
+
+      it 'should not exit' do
+        subject.assert_valid_schema!.should_not raise_error SystemExit
+      end
+    end
+
+  end
+
+  describe 'setup_application' do
+    before do
+      Chef::Daemon.should_receive :change_privilege
+    end
+
+    it 'should see if solr is installed' do
+      subject.stub :assert_valid_schema!
+      subject.stub :check_value_of_main_index_max_field_length
+      subject.should_receive :assert_solr_installed!
+      subject.setup_application
+    end
+
+    it 'should see if the schema is valid' do
+      subject.stub :assert_solr_installed!
+      subject.stub :check_value_of_main_index_max_field_length
+      subject.should_receive :assert_valid_schema!
+      subject.setup_application
+    end
+
+    it 'should check the maxFieldLimit setting' do
+      subject.stub :assert_solr_installed!
+      subject.stub :assert_valid_schema!
+      subject.should_receive :check_value_of_main_index_max_field_length
+      subject.setup_application
+    end
+
+    context 'with solr installed and a valid schema' do
+      before do
+        subject.stub :assert_solr_installed!
+        subject.stub :assert_valid_schema!
+        subject.stub :check_value_of_main_index_max_field_length
+      end
+
+      context 'with -L or --logfile' do
+        before do
+          @log_location = '/var/log/chef_solr.log'
+          Chef::Config.stub(:[]).with(:log_location).and_return(@log_location)
+          Chef::Config.stub(:[]).with(:log_level).and_return(:info)
+        end
+
+        it 'should open the log file for appending' do
+          File.should_receive(:new).with(@log_location, 'a')
+          subject.setup_application
+        end
+      end
+
+      it 'should set the log level' do
+        Chef::Config.stub(:[]).with(:log_location).and_return(nil)
+        Chef::Config.stub(:[]).with(:log_level).and_return(:info)
+        Chef::Log.should_receive(:level=).with(:info)
+        subject.setup_application
+      end
+    end
+
+  end
+
+  describe 'run_application' do
+    context 'with -d or --daemonize' do
+      before do
+        Chef::Config[:daemonize] = true
+        Kernel.stub :exec
+        Dir.stub :chdir
+      end
+
+      it 'should daemonize' do
+        Chef::Daemon.should_receive(:daemonize).with('chef-solr')
+        subject.run_application
+      end
+    end
+
+    it 'should change to the jetty home dir' do
+      Kernel.stub :exec
+      Dir.should_receive(:chdir).with(Chef::Config[:solr_jetty_path])
+      subject.run_application
+    end
+
+    context 'after changing to the jetty home dir' do
+      before do
+        Dir.should_receive(:chdir).and_yield
+        Chef::Daemon.stub :daemonize
+        Chef::Log.stub :info
+      end
+
+      it 'should start the process with the default settings' do
+        cmd = "java -Xmx#{Chef::Config[:solr_heap_size]} "
+        cmd << "-Xms#{Chef::Config[:solr_heap_size]} "
+        cmd << "-Dsolr.data.dir=#{Chef::Config[:solr_data_path]} "
+        cmd << "-Dsolr.solr.home=#{Chef::Config[:solr_home_path]} "
+        cmd << "-jar #{File.join(Chef::Config[:solr_jetty_path], 'start.jar')}"
+
+        Kernel.should_receive(:exec).with(cmd)
+        subject.run_application
+      end
+
+      it 'should log the command that solr is started with' do
+        cmd = /java.+solr.+jar.+start\.jar/
+        Chef::Log.should_receive(:info).with(cmd)
+        Kernel.stub :exec
+        subject.run_application
+      end
+
+      context 'with custom heap' do
+        it 'should start the process with the custom setting' do
+          Chef::Config[:solr_heap_size] = '2048M'
+          cmd_fragment = /-Xmx2048M -Xms2048M/
+          Kernel.should_receive(:exec).with(cmd_fragment)
+          subject.run_application
+        end
+      end
+
+      context 'with custom data path' do
+        it 'should start the process with the custom setting' do
+          Chef::Config[:solr_data_path] = '/opt/chef/solr_data'
+          cmd_fragment = /-Dsolr\.data\.dir=\/opt\/chef\/solr_data/
+          Kernel.should_receive(:exec).with(cmd_fragment)
+          subject.run_application
+        end
+      end
+
+      context 'with custom home path' do
+        it 'should start the process with the custom setting' do
+          Chef::Config[:solr_home_path] = '/opt/chef/solr/'
+          cmd_fragment = /-Dsolr\.solr\.home=\/opt\/chef\/solr/
+          Kernel.should_receive(:exec).with(cmd_fragment)
+          subject.run_application
+        end
+      end
+
+      context 'with custom jetty path' do
+        it 'should start the process with the custom setting' do
+          Chef::Config[:solr_jetty_path] = '/opt/chef/solr_jetty/'
+          cmd_fragment = /-jar \/opt\/chef\/solr_jetty\/start.jar/
+          Kernel.should_receive(:exec).with(cmd_fragment)
+          subject.run_application
+        end
+      end
+
+      context 'with custom java opts' do
+        it 'should start the java process with the custom setting' do
+          Chef::Config[:solr_java_opts] = '-XX:UseLargePages'
+          cmd_fragment = /-XX:UseLargePages/
+          Kernel.should_receive(:exec).with(cmd_fragment)
+          subject.run_application
+        end
+      end
+
+      context 'with -L or --logfile' do
+        it 'should close the previously opened log file and reopen it' do
+          Kernel.stub :exec
+          subject.logfile = StringIO.new
+          subject.should_receive(:close_and_reopen_log_file)
+          subject.run_application
+        end
+      end
+
+    end
+
+  end
+
+  describe 'close_and_reopen_log_file' do
+    it 'should close the log and reopen it' do
+      log = StringIO.new
+      Chef::Log.should_receive :close
+      STDOUT.should_receive(:reopen).with log
+      STDERR.should_receive(:reopen).with log
+      subject.logfile = log
+      subject.close_and_reopen_log_file
+    end
+  end
+
+  describe 'run' do
+    it { should respond_to :run}
+  end
+
+end