lucid_works 0.7.18 → 0.9.4

data/spec/lib/lucid_works/collection_spec.rb

@@ -6,6 +6,8 @@ describe LucidWorks::Collection do
     @server.reset_collections!
   end
 
+  let(:collection) { @server.collections.first }
+
   describe "CRUD" do
     before do
       @collection_name = "a_new_collection"
@@ -17,6 +19,23 @@ describe LucidWorks::Collection do
       LucidWorks::Collection.all(:parent => @server).size
     end
 
+    describe "validations" do
+      it "requires 'num_shards' to be a positive integer" do
+        ['abc', 1.2, 0].each do |invalid_value|
+          resource = LucidWorks::Collection.new({:parent => @server, :num_shards => invalid_value})
+          resource.should_not be_valid
+          resource.errors[:num_shards].should == ["is not a valid value"]
+        end
+      end
+
+      it "requires 'num_shards' to be present when running in clustered mode" do
+        @server.stub(:clustered?) { true }
+        resource = LucidWorks::Collection.new({:parent => @server})
+        resource.should_not be_valid
+        resource.errors[:num_shards].should == ["can't be blank"]
+      end
+    end
+
     describe ".create" do
       context "with ideal circumstances" do
         it "should create a new collection with the appropriate parameters" do
@@ -72,26 +91,6 @@ describe LucidWorks::Collection do
       #end
     end
 
-    describe ".find" do
-      context "for a nonexistant collection" do
-        it "should raise an exception" do
-          lambda {
-            LucidWorks::Collection.find('nonexistant_collection', :parent => @server)
-          }.should raise_error(RestClient::ResourceNotFound)
-        end
-      end
-
-      context "for an extant collection" do
-        it "should return the collection" do
-          c = LucidWorks::Collection.find(@collection_name, :parent => @server)
-          c.should be_kind_of(LucidWorks::Collection)
-          c.name.should == @collection_name
-          c.instance_dir.should == @instance_dir
-          c.should be_persisted
-        end
-      end
-    end
-
     describe "#destroy" do
       it "should delete the collection" do
         c = @server.collection(@collection_name)
@@ -101,7 +100,7 @@ describe LucidWorks::Collection do
       end
     end
   end
-
+  
   describe "#activities" do
     before do
       @collection = @server.collection('collection1')
@@ -136,13 +135,6 @@ describe LucidWorks::Collection do
   describe "#prime_activities" do
     before do
       @collection = @server.collection('collection1')
-      # require 'ruby-debug'; debugger
-      # activity = LucidWorks::Activity.create(
-      #     :type => 'optimize',
-      #     :start_time => 8600,
-      #     :collection => @collection
-      # )
-      # activity.should be_persisted
     end
     
     it "should not create activities that already exist" do
@@ -204,7 +196,7 @@ describe LucidWorks::Collection do
       @collection.synonyms.first.mapping.should == "lawyer, attorney"
     end
     
-    it "associates each synonym to the collection" do
+    it "associates each synonym with the collection" do
       @collection.synonyms.first.collection.should be(@collection)
     end
 
@@ -214,6 +206,33 @@ describe LucidWorks::Collection do
     end
   end
   
+  describe "#elevations" do
+    before do
+      @collection = @server.collection('collection1')
+      @collection.settings.elevations = {
+        'jeans' => [{'doc' => 'http://mystore.com/products/1', 'exclude' => 'true'}, {'doc' => 'http://mystore.com/products/2'}],
+        'shirts' => [{'doc' => 'http://mystore.com/products/3'}]
+      }
+      @collection.settings.save
+    end
+    
+    it "returns a list of elevations" do
+      @collection.should have(3).elevations
+    end
+    
+    it "sets the elevations' attributes" do
+      elevation = @collection.elevations.first
+      elevation.query.should == 'jeans'
+      elevation.doc_id.should == 'http://mystore.com/products/1'
+      elevation.persisted?.should be_true
+      elevation.excluded?.should be_true
+    end
+    
+    it "associates each elevation with the collection" do
+      @collection.elevations.first.collection.should be(@collection)
+    end
+  end
+  
   describe "#info" do
     before :all do
       @collection = LucidWorks::Collection.first(:parent => @server)
@@ -256,7 +275,7 @@ describe LucidWorks::Collection do
       @collection.should be_valid
       @ds1 = LucidWorks::Datasource.create(
         :collection => @collection,
-        :crawler => LucidWorks::Datasource::CRAWLERS['file'],
+        :crawler => 'lucid.aperture',
         :type => "file",
         :name => "US zoneinfo",
         :path => "/usr/share/zoneinfo/US",
@@ -265,7 +284,7 @@ describe LucidWorks::Collection do
       @ds1.should be_valid
       @ds2 = LucidWorks::Datasource.create(
         :collection => @collection,
-        :crawler => LucidWorks::Datasource::CRAWLERS['web'],
+        :crawler => 'lucid.aperture',
         :type => 'web',
         :name => "nothing_com",
         :url => "http://nothing.com/",
@@ -359,110 +378,150 @@ describe LucidWorks::Collection do
     end
   end
 
-  describe "#rsolr" do
-    before :each do
+  describe "#search" do
+    def mock_solr_result
+      @mock_solr_result ||= mock('solr_result', :request => {:uri => 'some_uri'}, :response => {:status => 200})
+    end
+
+    before do
       @collection = LucidWorks::Collection.new(:name => "collection_to_search", :parent => @server)
-      mock_server = double('server', :host => 'fake_url')
+      mock_server = double('server', :server_uri => 'http://fake-solr-host.com')
       @collection.stub(:server) { mock_server }
+      @mock_rsolr_client = double("RSolr::Client").as_null_object
+      RSolr.stub(:connect) { @mock_rsolr_client }
+      @mock_rsolr_client.stub(:get) { mock_solr_result }
     end
 
-    it "should call RSolr.connect" do
-      RSolr.should_receive(:connect).with(:url => 'fake_url')
-      @collection.rsolr
+    it "opens a connection pointing to the proper server and collection" do
+      RSolr.should_receive(:connect).with(:url => 'http://fake-solr-host.com/solr/collection_to_search')
+      @collection.search(:some => :solr_params)
     end
 
-    it "should return an RSolr::Client" do
-      @collection.rsolr.should be_a(RSolr::Client)
+    it "caches the connection" do
+      RSolr.should_receive(:connect).once
+      @collection.search(:some => :solr_params)
+      @collection.search(:some => :solr_other_params)
     end
 
-    it "should not call RSolr.connect again if it is called again" do
-      mock_rsolr_client = double("RSolr::Client")
-      RSolr.should_receive(:connect).once.and_return(mock_rsolr_client)
-      @collection.rsolr
-      @collection.rsolr
+    it "delegates to RSolr#get to perform the search" do
+      @mock_rsolr_client.should_receive(:get).
+        with('select', :params => {:some => :solr_params}).and_return(mock_solr_result)
+      @collection.search(:some => :solr_params)
     end
-  end
-  
-  describe "#search" do
-    context "using faked out Solr" do
-      before do
-        @collection = LucidWorks::Collection.new(:name => "collection_to_search", :parent => @server)
-        mock_server = double('server', :host => 'http://fake-solr-host.com/fake_access_path')
-        @collection.stub(:server) { mock_server }
-        @mock_rsolr_client = double("RSolr::Client")
-        RSolr::Ext.stub(:connect) { @mock_rsolr_client }
+
+    context "with pagination options" do
+      it "delegates to RSolr#paginate" do
+        @mock_rsolr_client.should_receive(:paginate).
+          with(33, 44, 'select', :params => {:some => :solr_params}).and_return(mock_solr_result)
+        @collection.search({:some => :solr_params}, {:page => 33, :per_page => 44})
       end
+    end
+  end
 
-      it "should pass thru pagination variables" do
-        @mock_rsolr_client.should_receive(:find).
-          with('/fake_access_path/solr/collection_to_search/select', :q => 'fake_query', :wt => :ruby, :page => 33, :per_page => 44).
-          and_return({})
+  describe "#fields" do
+    it "should return a valid LucidWorks::Field" do
+      collection.should respond_to(:field)
+      field = collection.field('body')
+      field.should be_a(LucidWorks::Field)
+    end
+  end
 
-        @collection.search(:q => 'fake_query', :wt => :ruby, :page => 33, :per_page => 44)
-      end
+  describe "#dynamic_fields" do
+    it "should return a valid LucidWorks::DynamicField" do
+      collection.should respond_to(:dynamicfield)
+      field = collection.dynamicfield('*_t')
+      field.should be_a(LucidWorks::Dynamicfield)
+    end
+  end
 
-      context "when requesting an XML response" do
-        before do
-          @good_xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<response>FooBar</response>\n</xml>"
-        end
+  describe "#caches" do
+    it "returns all caches" do
+      collection.should have(4).caches
+    end
+  end
 
-        it "should call RSolr.get to perform the search" do
-          @mock_rsolr_client.should_receive(:find).
-            with('/fake_access_path/solr/collection_to_search/select', :q => 'fake_query', :wt => :xml, :page => 1, :per_page => 10).
-            and_return(@good_xml)
+  describe "#update_caches_attributes" do
+    before(:each) do
+      %w(document_cache filter_cache).each do |cache_name|
+        collection.cache(cache_name).update_attributes(:size => '512', :autowarm_count => '') # reset attributes used in nested examples
+      end
+    end
+    
+    context "with valid attributes" do
+      it "updates the requested caches" do
+        collection.update_caches_attributes('document_cache' => {'size' => '1024'}, 'filter_cache' => {'size' => '2048'})
+        collection.cache('document_cache').size.should == '1024'
+        collection.cache('filter_cache').size.should == '2048'
+      end
+      
+      it "returns true" do
+        collection.update_caches_attributes('document_cache' => {'size' => '1024'}, 'filter_cache' => {'size' => '2048'}).should be_true
+      end
+    end
 
-          @collection.search(:q => 'fake_query', :wt => :xml)
+    context "with invalid attributes" do
+      context "triggering validation errors" do
+        let(:invalid_params) { {'document_cache' => {'size' => '1024'}, 'filter_cache' => {'size' => ''}} }
+        
+        it "doesn't update any of the requested caches" do
+          collection.update_caches_attributes(invalid_params)
+          collection.cache('document_cache').size.should == '512'
+          collection.cache('filter_cache').size.should == '512'
         end
-
-        it "should parse the XML results" do
-          @mock_rsolr_client.stub(:find) { @good_xml }
-          results = @collection.search(:q => 'fake_query', :wt => :xml)
-          results.should be_a(Nokogiri::XML::Document)
-          results.root.children.first.text.should == "FooBar"
+        
+        it "reports errors" do
+          collection.update_caches_attributes(invalid_params)
+          filter_cache = collection.caches.detect {|cache| cache.name == 'filter_cache' } # don't reload the caches
+          filter_cache.errors.should_not be_empty
         end
 
-        context "when the search returns invalid XML" do
-          before do
-            @mock_rsolr_client.stub(:get) { "this is not xml" }
-          end
-
-          it "should raise an error" do
-            lambda {
-              @collection.search(:wt => :xml)
-            }.should raise_error
-          end
+        it "returns false" do
+          collection.update_caches_attributes(invalid_params).should be_false
         end
       end
-    end
-
-    context "when using a live collection" do
-      before do
-        @collection = @server.collections.first
-      end
-
-      describe "when given a bad search" do
-        before do
-          @query_params = { :defType => 'lucene', :q => 'datefield:[FOO' }
+      
+      context "triggering API errors" do
+        let(:invalid_params) { {'filter_cache' => {'autowarm_count' => 'abc'}} }
+
+        it "reports errors" do
+          collection.update_caches_attributes(invalid_params)
+          filter_cache = collection.caches.detect {|cache| cache.name == 'filter_cache' } # don't reload the caches
+          filter_cache.errors.should_not be_empty
         end
 
-        it "should raise an error (until I decide what the right answer is)" do
-          lambda {
-            @collection.search @query_params
-          }.should raise_error
+        it "returns false" do
+          collection.update_caches_attributes(invalid_params).should be_false
         end
       end
     end
   end
+  
+  describe "#available_templates" do
+    it "returns all templates" do
+      collection.available_templates.should == ["default.zip","essential.zip"]
+    end
+  end
+  
+  describe "#commit" do
+    def mock_rsolr_client
+      @mock_rsolr_client ||= double("RSolr::Client")
+    end
 
-  describe "#fields" do
-    before do
-      @collection = @server.collections.first
+    before(:each) do
+      RSolr.stub(:connect) { @mock_rsolr_client }
     end
-    it "should return a valid LucidWorks::Field" do
-      @collection.should respond_to(:field)
-      field = @collection.field('body')
-      field.should be_a(LucidWorks::Field)
-      field.should respond_to(:field_type)
+    
+    it "delegates to RSolr" do
+      mock_rsolr_client.should_receive(:commit)
+      collection.commit
+    end
+  end
+
+  describe "#request_handler" do
+    it "returns the requested request handler" do
+      request_handler = collection.request_handler('lucid')
+      request_handler.should be_a(LucidWorks::RequestHandler)
+      request_handler.name.should == "lucid"
     end
   end
 end

data/spec/lib/lucid_works/datasource/schedule_spec.rb

@@ -29,6 +29,17 @@ describe LucidWorks::Datasource::Schedule do
   end
 
   describe '#frequency' do
+    it "assumes an 'every' frequency when period ranges from 1 to 59 minutes" do
+      @schedule.period = 0
+      @schedule.frequency.should_not == 'every'
+      @schedule.period = 1 * 60
+      @schedule.frequency.should == 'every'
+      @schedule.period = 59 * 60
+      @schedule.frequency.should == 'every'
+      @schedule.period = 60 * 60
+      @schedule.frequency.should_not == 'every'
+    end
+
     it "should return 'weekly' when period == num of seconds in a week" do
       @schedule.period = 604800
       @schedule.frequency.should == 'weekly'
@@ -70,7 +81,7 @@ describe LucidWorks::Datasource::Schedule do
     # Time objects are precise to the millisecond
     # we cheat by converting to string, which is only accurate to the second
     # but if these test are run on a second boundary, they might wrongly fail
-    # 
+    #
     context 'start_time is in the past' do
       before do
         @now = Time.iso8601(Time.now.utc.iso8601)
@@ -89,7 +100,7 @@ describe LucidWorks::Datasource::Schedule do
       
       context 'Time since self.start_time is not even multiple of self.period' do
         describe 'one interval has passed' do
-          before do 
+          before do
             @schedule.start_time = @now - 11.minutes
             @schedule.period = 10.minutes
           end
@@ -121,7 +132,7 @@ describe LucidWorks::Datasource::Schedule do
     end
   end
 
-  describe '#active, #active=' do 
+  describe '#active, #active=' do
     it 'should maintain specified value' do
       @schedule.active = true
       @schedule.active.should == true
@@ -177,6 +188,24 @@ describe LucidWorks::Datasource::Schedule do
       end
     end
     
+    describe "with an 'every' frequency" do
+      let(:attributes) { {"frequency"=>"every", "period" => "1800"} }
+
+      it "ceils start_time based on the period" do
+        Timecop.freeze Time.iso8601("2012-11-07T10:12:33Z") do
+          @schedule.schedule = attributes
+          @schedule.start_time.should == Time.iso8601("2012-11-07T10:30:00Z")
+        end
+      end
+
+      it "sets the period" do
+        Timecop.freeze Time.iso8601("2012-11-07T10:12:33Z") do
+          @schedule.schedule = attributes
+          @schedule.period.should == 1800
+        end
+      end
+    end
+
     context 'supplied start time has elapsed w/rt current interval' do
       describe 'with hourly frequency' do
         it "should advance the start time" do
@@ -184,11 +213,11 @@ describe LucidWorks::Datasource::Schedule do
           hourly_at_quarter_past = {"frequency"=>"hourly", "start"=>{"minutes"=>"15"}}
           quarter_past_1_am = Time.iso8601('2011-05-09T01:15:00Z').in_time_zone('Eastern Time (US & Canada)')
           
-          Timecop.freeze                        half_past_midnight do
-            @schedule.start_time.should_not ==  quarter_past_1_am
+          Timecop.freeze half_past_midnight do
+            @schedule.start_time.should_not == quarter_past_1_am
           
-            @schedule.schedule =                hourly_at_quarter_past
-            @schedule.start_time.should ==      quarter_past_1_am
+            @schedule.schedule = hourly_at_quarter_past
+            @schedule.start_time.should == quarter_past_1_am
           end
         end
       end
@@ -198,11 +227,11 @@ describe LucidWorks::Datasource::Schedule do
           today_at_noon = Time.iso8601("2011-05-09T12:00:00Z").in_time_zone('Eastern Time (US & Canada)')
           tomorrow_at_eleven_am = Time.iso8601('2011-05-10T11:00:00Z').in_time_zone('Eastern Time (US & Canada)')
           daily_at_11_am = {"frequency"=>"daily", "start"=>{"hours" => "11", "minutes"=>"00"}}
-          Timecop.freeze                      today_at_noon do
-            @schedule.start_time.should_not ==  tomorrow_at_eleven_am
+          Timecop.freeze today_at_noon do
+            @schedule.start_time.should_not == tomorrow_at_eleven_am
           
-            @schedule.schedule =                daily_at_11_am
-            @schedule.start_time.should ==      tomorrow_at_eleven_am
+            @schedule.schedule = daily_at_11_am
+            @schedule.start_time.should == tomorrow_at_eleven_am
           end
         end
       end
@@ -215,14 +244,14 @@ describe LucidWorks::Datasource::Schedule do
             weekly_on_wednesday = {"frequency"=>"weekly", "start"=>{"days" => "2", "hours" => "0", "minutes"=>"00"}}
           
           # just make sure I'm not on crack
-            friday_of_this_week.weekday.should ==     'Friday'
-            wednesday_of_next_week.weekday.should ==  'Wednesday'
+            friday_of_this_week.weekday.should == 'Friday'
+            wednesday_of_next_week.weekday.should == 'Wednesday'
           
-          Timecop.freeze                        friday_of_this_week do
-            @schedule.start_time.should_not ==  wednesday_of_next_week
+          Timecop.freeze friday_of_this_week do
+            @schedule.start_time.should_not == wednesday_of_next_week
           
-            @schedule.schedule =                weekly_on_wednesday
-            @schedule.start_time.should ==      wednesday_of_next_week
+            @schedule.schedule = weekly_on_wednesday
+            @schedule.start_time.should == wednesday_of_next_week
           end
         end
       end
@@ -231,16 +260,16 @@ describe LucidWorks::Datasource::Schedule do
     context 'supplied time has not elapsed w/rt current interval' do
       describe 'with hourly frequency' do
         it "should not advance the start time" do
-          half_past_midnight =                Time.iso8601("2011-05-09T00:30:00Z")
-          three_quarters_past_midnight =      Time.iso8601('2011-05-09T00:45:00Z')
-          hourly_at_three_quarters_past =     {"frequency"=>"hourly", "start"=>{"minutes"=>"45"}}
+          half_past_midnight = Time.iso8601("2011-05-09T00:30:00Z")
+          three_quarters_past_midnight = Time.iso8601('2011-05-09T00:45:00Z')
+          hourly_at_three_quarters_past = {"frequency"=>"hourly", "start"=>{"minutes"=>"45"}}
           
-          Timecop.freeze                        half_past_midnight do
-            @schedule.start_time.should_not ==  three_quarters_past_midnight
+          Timecop.freeze half_past_midnight do
+            @schedule.start_time.should_not == three_quarters_past_midnight
             @schedule.frequency.should_not == 'hourly'
           
-            @schedule.schedule =                hourly_at_three_quarters_past
-            @schedule.start_time.should ==      three_quarters_past_midnight
+            @schedule.schedule = hourly_at_three_quarters_past
+            @schedule.start_time.should == three_quarters_past_midnight
             @schedule.frequency.should == 'hourly'
           end
         end
@@ -248,16 +277,16 @@ describe LucidWorks::Datasource::Schedule do
       
       describe 'with daily frequency' do
         it "should not advance the start time" do
-          today_at_noon =                     Time.iso8601("2011-05-09T12:00:00Z")
-          today_at_1pm =                      Time.iso8601('2011-05-09T13:00:00Z')
-          daily_at_1pm =                      {"frequency"=>"daily", "start"=>{"hours" => "13", "minutes"=>"00"}}
+          today_at_noon = Time.iso8601("2011-05-09T12:00:00Z")
+          today_at_1pm = Time.iso8601('2011-05-09T13:00:00Z')
+          daily_at_1pm = {"frequency"=>"daily", "start"=>{"hours" => "13", "minutes"=>"00"}}
 
-          Timecop.freeze                        today_at_noon do
-            @schedule.start_time.should_not ==  today_at_1pm
+          Timecop.freeze today_at_noon do
+            @schedule.start_time.should_not == today_at_1pm
             @schedule.frequency.should_not == 'daily'
 
-            @schedule.schedule =                daily_at_1pm
-            @schedule.start_time.should ==      today_at_1pm
+            @schedule.schedule = daily_at_1pm
+            @schedule.start_time.should == today_at_1pm
             @schedule.frequency.should == 'daily'
           end
         end
@@ -266,20 +295,20 @@ describe LucidWorks::Datasource::Schedule do
       describe 'with weekly frequency' do
         it "should not advance the start time" do
           # note: Rails week starts on Monday
-            wednesday_of_this_week =          Time.iso8601("2011-05-11T00:00:00Z")
-            thursday_of_this_week =           Time.iso8601('2011-05-12T00:00:00Z')
-            weekly_on_thursday =              {"frequency"=>"weekly", "start"=>{"days" => "3", "hours" => "0", "minutes"=>"00"}}
+            wednesday_of_this_week = Time.iso8601("2011-05-11T00:00:00Z")
+            thursday_of_this_week = Time.iso8601('2011-05-12T00:00:00Z')
+            weekly_on_thursday = {"frequency"=>"weekly", "start"=>{"days" => "3", "hours" => "0", "minutes"=>"00"}}
 
           # just make sure I'm not on crack
-            wednesday_of_this_week.weekday.should ==  'Wednesday'
-            thursday_of_this_week.weekday.should ==   'Thursday'
+            wednesday_of_this_week.weekday.should == 'Wednesday'
+            thursday_of_this_week.weekday.should == 'Thursday'
           
-          Timecop.freeze                        wednesday_of_this_week do
-            @schedule.start_time.should_not ==  thursday_of_this_week
+          Timecop.freeze wednesday_of_this_week do
+            @schedule.start_time.should_not == thursday_of_this_week
             @schedule.frequency.should_not == 'weekly'
 
-            @schedule.schedule =                weekly_on_thursday
-            @schedule.start_time.should ==      thursday_of_this_week
+            @schedule.schedule = weekly_on_thursday
+            @schedule.start_time.should == thursday_of_this_week
             @schedule.frequency.should == 'weekly'
           end
         end
@@ -334,9 +363,9 @@ describe LucidWorks::Datasource::Schedule do
     
       it 'should be true if period is standard but start_time is > 1 period from now' do
         some_random_time = Time.parse("2011-04-15 13:11:56")
-        more_than_a_day_later = some_random_time.advance(:days => 2) 
+        more_than_a_day_later = some_random_time.advance(:days => 2)
         
-        Timecop.freeze   some_random_time do
+        Timecop.freeze some_random_time do
           @schedule.frequency = 'daily'
           @schedule.start_time = more_than_a_day_later
 
@@ -351,8 +380,8 @@ describe LucidWorks::Datasource::Schedule do
         a_standard_schedule = {"frequency"=>"hourly", "start"=>{"minutes"=>"15"}}
         some_random_specific_time = Time.iso8601('2011-05-09T01:15:00Z')
         
-        Timecop.freeze                        some_random_specific_time do
-          @schedule.schedule =                a_standard_schedule
+        Timecop.freeze some_random_specific_time do
+          @schedule.schedule = a_standard_schedule
         
           @schedule.should_not be_custom
         end
@@ -360,7 +389,7 @@ describe LucidWorks::Datasource::Schedule do
       
       it 'should be false if period is standard and start time is > 1 period in the past' do
         some_random_time = Time.parse("2011-04-15 13:11:56")
-        more_than_a_day_ago = some_random_time.advance(:days => -2) 
+        more_than_a_day_ago = some_random_time.advance(:days => -2)
         Timecop.freeze some_random_time do
           @schedule.frequency = 'daily'
           @schedule.start_time = more_than_a_day_ago
@@ -399,4 +428,4 @@ describe LucidWorks::Datasource::Schedule do
       @schedule.active.should == true
     end
   end
-end
+end

data/spec/lib/lucid_works/datasource/status_spec.rb

@@ -8,7 +8,7 @@ describe LucidWorks::Datasource::Status do
 
   describe "state predicate methods" do
 
-    STATES = %w{idle stopped aborted exception finished stopping aborting running}
+    STATES = %w{idle stopped aborted exception finished stopping aborting running unknown}
 
     STATES.each do |actual_state|
       describe "when state is #{actual_state}," do
@@ -36,8 +36,8 @@ describe LucidWorks::Datasource::Status do
     subject { @status }
 
     truth_table = {
-      'IDLE'     => true, 'STOPPED'  => true,  'ABORTED'  => true,  'EXCEPTION' => true,
-      'FINISHED' => true, 'STOPPING' => false, 'ABORTING' => false, 'RUNNING'   => false
+      'IDLE'     => true, 'STOPPED'  => true,  'ABORTED'  => true,  'EXCEPTION' => true, 'FINISHED' => true, 'UNKNOWN' => true,
+      'STOPPING' => false, 'ABORTING' => false, 'RUNNING'   => false
     }
     truth_table.each do |state, expected_result|
       describe "when state is #{state}" do
@@ -55,8 +55,8 @@ describe LucidWorks::Datasource::Status do
     subject { @status }
 
     truth_table = {
-      'IDLE'     => false, 'STOPPED'  => false, 'ABORTED'  => false, 'EXCEPTION' => false,
-      'FINISHED' => false, 'STOPPING' => true,  'ABORTING' => true,  'RUNNING'   => false
+      'IDLE'     => false, 'STOPPED'  => false, 'ABORTED'  => false, 'EXCEPTION' => false, 'FINISHED' => false, 'UNKNOWN' => false,
+      'STOPPING' => true,  'ABORTING' => true,  'RUNNING'   => false
     }
     truth_table.each do |state, expected_result|
       describe "when state is #{state}" do