lucid_works 0.3.9 → 0.4.9

data/spec/lib/lucid_works/collection/activity_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe LucidWorks::Collection::Activity do
+  before :all do
+    @server = connect_to_live_server
+    @server.reset_collections!
+    @collection = @server.collections!.first
+  end
+
+  def activity_count
+    @collection.activities!.size
+  end
+
+  class LucidWorks::Collection::Activity
+    def history_size
+      self.histories!.size
+    end
+  end
+
+  describe "CRUD" do
+    describe ".create"do
+      context "with invalid parameters" do
+        before do
+          @activity_params = {:type => 'bogus', :start_time => 8600}
+        end
+
+        it "should not create, and should add errors to model" do
+          a = nil
+          lambda {
+            a = LucidWorks::Collection::Activity.create(@activity_params.merge(:parent => @collection))
+          }.should_not change(self, :activity_count)
+          a.should_not be_persisted
+          a.errors[:type].should_not be_blank
+        end
+      end
+
+      context "with valid parameters" do
+        before do
+          @activity_params = {:type => 'optimize', :start_time => 8600}
+        end
+        it "should create a new activity" do
+          a = nil
+          lambda {
+            a = LucidWorks::Collection::Activity.create(@activity_params.merge(:parent => @collection))
+          }.should change(self, :activity_count).by(1)
+          a.should be_persisted
+          a.errors[:type].should be_blank
+        end
+      end
+
+      describe ".find" do
+        before do
+          @activity = LucidWorks::Collection::Activity.create(
+              :type => 'optimize',
+              :start_time => 8600,
+              :collection => @collection
+          )
+          @activity.should be_persisted
+        end
+
+        it "should return a valid activity" do
+          a = LucidWorks::Collection::Activity.find(@activity.id, :parent => @collection)
+          a.should be_a(LucidWorks::Collection::Activity)
+        end
+        
+        %w{ type period start_time }.each do |attr|
+          it "should have a value for #{attr}" do
+            @activity.send(attr.to_sym).should_not be_nil
+          end
+        end
+      end
+
+      describe "#start" do
+        before do
+          @activity = LucidWorks::Collection::Activity.first(:parent => @collection)
+        end
+
+        # can't check #running? b/c w/out a big index, operation is done faster than we can check
+
+        it "should create a new history" do
+          lambda {
+            @collection.activities!.first.start
+          }.should change(@activity, :history_size).by(1)
+        end
+      end
+    end
+  end
+end

data/spec/lib/lucid_works/collection/prime_activities_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe "LucidWorks::Collection#prime_activities" do
+  class LucidWorks::Collection
+    def activities_count
+      self.activities!.count
+    end
+  end
+
+  before :all do
+    @server = connect_to_live_server
+    @server.reset_collections!
+  end
+
+  context "without pre_existing activities" do
+    describe "the virtual attribute convenience accessors" do
+      before :all do
+        @collection = @server.create_collection(:name => 'collection_with_no_activities_1', :parent => @server)
+        @collection.should be_a LucidWorks::Collection
+      end 
+
+      it "should produce activities of the appropriate type" do
+        @collection.optimize_activity.should          be_a  LucidWorks::Collection::Activity
+        @collection.optimize_activity.type.should     ==    'optimize'
+        @collection.spelling_activity.should          be_a  LucidWorks::Collection::Activity
+        @collection.spelling_activity.type.should     ==    'spelling'
+        @collection.click_activity.should             be_a  LucidWorks::Collection::Activity
+        @collection.click_activity.type.should        ==    'click'
+        @collection.autocomplete_activity.should      be_a LucidWorks::Collection::Activity
+        @collection.autocomplete_activity.type.should ==    'autocomplete'
+      end
+    end
+  end
+
+  describe "#prime_activities" do
+    context "there are already some activities" do
+      before :all do
+        @collection = @server.create_collection(:name => 'collection_with_no_activities_2', :parent => @server)
+        spelling_activity = @collection.create_activity(:type => 'spelling', :start_time => 3600, :active => true)
+        spelling_activity.should be_a LucidWorks::Collection::Activity
+      end
+
+      it "should not create duplicates for existing types" do
+        lambda {
+          @collection.prime_activities
+        }.should change(@collection, :activities_count).by 3
+      end
+    end
+
+    context "there are no activities before calling" do
+      before :all do
+        @collection = @server.create_collection(:name => 'collection_with_no_activities_3', :parent => @server)
+        @collection.should be_a LucidWorks::Collection
+        @collection.activities_count.should == 0
+      end
+
+      describe "and after calling" do
+        before :all do
+          @collection.prime_activities
+        end
+
+        it "should have a virtual attribute for each activity type" do
+          @collection.activities!.count.should == 4
+          @collection.optimize_activity.should          be_a  LucidWorks::Collection::Activity
+          @collection.optimize_activity.type.should     ==    'optimize'
+          @collection.spelling_activity.should          be_a  LucidWorks::Collection::Activity
+          @collection.spelling_activity.type.should     ==    'spelling'
+          @collection.click_activity.should             be_a  LucidWorks::Collection::Activity
+          @collection.click_activity.type.should        ==    'click'
+          @collection.autocomplete_activity.should      be_a LucidWorks::Collection::Activity
+          @collection.autocomplete_activity.type.should ==    'autocomplete'
+        end
+
+        it "should have start times at least an hour apart for each activity" do
+          start_times = @collection.activities!.map(&:start_time).map{|t| Time.iso8601 t}.sort
+          last_time = nil
+          start_times.each do |time|
+            (last_time = time) && next unless last_time
+            (time - last_time).should >= 3600
+            last_time = time
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/lucid_works/collection_spec.rb

@@ -84,6 +84,37 @@ describe LucidWorks::Collection do
     end
   end
 
+  describe "#activities" do
+    before do
+      @collection = LucidWorks::Collection.first(:parent => @server)
+    end
+
+    context "for a collection with some activities" do
+      before do
+        activity = LucidWorks::Collection::Activity.create(
+            :type => 'optimize',
+            :start_time => 8600,
+            :collection => @collection
+        )
+        activity.should be_persisted
+        activity = LucidWorks::Collection::Activity.create(
+            :type => 'spelling',
+            :start_time => 8600,
+            :collection => @collection
+        )
+        activity.should be_persisted
+      end
+
+      it "should return a list of activities" do
+        activities = @collection.activities
+        activities.count.should == 2
+        activities.each do |activity|
+          activity.should be_a(LucidWorks::Collection::Activity)
+        end
+      end
+    end
+  end
+  
   describe "#info" do
     before :all do
       @collection = LucidWorks::Collection.first(:parent => @server)
@@ -229,11 +260,119 @@ describe LucidWorks::Collection do
     end
   end
 
+  describe "#rsolr_connect" do
+    before :each do
+      @collection = LucidWorks::Collection.new(:parent => @server)
+    end
+
+    it "should call RSolr.connect" do
+      RSolr.should_receive(:connect).with(:url => 'fake_url')
+      @collection.rsolr_connect('fake_url')
+    end
+
+    it "should return an RSolr::Client" do
+      @collection.rsolr_connect('fake_url').should be_a(RSolr::Client)
+    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_connect('fake_uri')
+      @collection.rsolr_connect('fake_uri')
+    end
+  end
+  
+  describe "search" do
+    context "using faked out Solr" do
+      before do
+        @collection = LucidWorks::Collection.new(:name => "collection_to_search", :parent => @server)
+        @mock_rsolr_client = double("RSolr::Client")
+        RSolr.stub(:connect) { @mock_rsolr_client }
+      end
+
+      it "should use default search params stored by #rsolr_connect" do
+        @mock_rsolr_client.should_receive(:paginate)
+                          .with(1, 10, '/fake_access_path/solr/collection_to_search/select',
+                                :params => {:q => 'baz', :foo => :bar})
+                          .and_return({})
+
+        @collection.rsolr_connect('http://fake-solr-host.com/fake_access_path', :foo => :bar)
+        @collection.search :q => 'baz'
+      end
+
+      it "should respect pagination variables" do
+        @mock_rsolr_client.should_receive(:paginate)
+                          .with(33, 44, '/fake_access_path/solr/collection_to_search/select',
+                                :params => {:q => 'fake_query', :wt => :ruby})
+                          .and_return({})
+
+        @collection.rsolr_connect('http://fake-solr-host.com/fake_access_path', :wt => :ruby)
+        @collection.search({:q => 'fake_query'}, :page => 33, :per_page => 44)
+      end
+
+      context "when requesting an XML response" do
+        before do
+          @default_search_params = {:wt => :xml}
+          @collection.rsolr_connect('http://fake-solr-host.com/fake_access_path', @default_search_params)
+          @good_xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<response>FooBar</response>\n</xml>"
+        end
+
+        it "should call RSolr.get to perform the search" do
+          @mock_rsolr_client.should_receive(:paginate)
+                            .with(1, 10, '/fake_access_path/solr/collection_to_search/select',
+                                  :params => {:q => 'fake_query', :wt => :xml})
+                            .and_return(@good_xml)
+
+          @collection.search(:q => 'fake_query')
+        end
+
+        it "should parse the XML results" do
+          @mock_rsolr_client.stub(:paginate) { @good_xml }
+          results = @collection.search(:q => 'fake_query')
+          results.should be_a(Nokogiri::XML::Document)
+          results.root.children.first.text.should == "FooBar"
+        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
+            }.should raise_error
+          end
+        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' }
+        end
+
+        it "should raise an error (until I decide what the right answer is)" do
+          collection = LucidWorks::Collection.new(:name => "collection1", :parent => @server)
+          collection.rsolr_connect(@server.instance_variable_get(:'@host'))
+          lambda {
+            collection.search @query_params
+          }.should raise_error
+        end
+      end
+    end
+  end
+
   describe "#fields" do
     before do
       @collection = @server.collections.first
     end
-    it "should return a valid LucidWorks::Collection::Field" do
+    it "should return a valid LucidWorks::Field" do
       @collection.should respond_to(:field)
       field = @collection.field('body')
       field.should be_a(LucidWorks::Field)

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

@@ -20,21 +20,25 @@ describe LucidWorks::Datasource::History do
   end
 
   describe "#crawl_stopped" do
-    it "should be tested" do
-      pending "write some tests"
-      # TODO
+    it "should convert to a Time with the correct value" do
+      history = LucidWorks::Datasource::History.new(:parent => @fake_server, :crawlStopped => "2011-03-25T21:20:52+0000")
+      history.crawl_stopped.should be_a(Time)
+      # Time.iso8601("2011-03-25T21:20:52+0000").to_yaml # => "--- 2011-03-25 21:20:52 Z\n"
+      history.crawl_stopped.should == YAML.load("--- 2011-03-25 21:20:52 Z")
     end
   end
 
   describe "#crawl_started" do
-    it "should be tested" do
-      pending "write some tests"
-      # TODO
+    it "should convert to a Time with the correct value" do
+      history = LucidWorks::Datasource::History.new(:parent => @fake_server, :crawlStarted => "2011-03-25T21:20:52+0000")
+      history.crawl_started.should be_a(Time)
+      # Time.iso8601("2011-03-25T21:20:52+0000").to_yaml # => "--- 2011-03-25 21:20:52 Z\n"
+      history.crawl_started.should == YAML.load("--- 2011-03-25 21:20:52 Z")
     end
   end
 
   describe "#duration" do
-    it "should be tested" do
+    it "should subtract crawlStarted form crawlStopped and return the difference in seconds" do
       include ActiveSupport::Duration
 
       history = LucidWorks::Datasource::History.new(:parent => @fake_server)

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

@@ -1,52 +1,84 @@
 require 'spec_helper'
 
 describe LucidWorks::Datasource::Status do
-  describe "state predicate methods" do
-    it "should be tested" do
-      pending "write some tests"
-      # TODO
-    end
+  before do
+    @server = connect_to_live_server
+    @status = LucidWorks::Datasource::Status.new(:parent => @server)
   end
 
-  describe "#none?" do
-    it "should be tested" do
-      pending "write some tests"
-      # TODO
+  describe "state predicate methods" do
+
+    STATES = %w{idle stopped aborted exception finished stopping aborting running}
+
+    STATES.each do |actual_state|
+      describe "when state is #{actual_state}," do
+        before { @status.crawlState = actual_state.upcase }
+
+        (STATES - ['stopped']).each do |testing_state|
+          predicate = "#{testing_state}?"
+          describe predicate do
+            if actual_state == testing_state
+              it "should return true" do
+                @status.send(predicate).should be_true
+              end
+            else
+              it "should return false" do
+                @status.send(predicate).should be_false
+              end
+            end
+          end
+        end
+      end
     end
   end
 
   describe "#stopped?" do
-    it "should be tested" do
-      pending "write some tests"
-      # TODO
-    end
-  end
+    subject { @status }
 
-  describe "#post_processing?" do
-    it "should be tested" do
-      pending "write some tests"
-      # TODO
+    truth_table = {
+      'IDLE'     => true, 'STOPPED'  => true,  'ABORTED'  => true,  'EXCEPTION' => true,
+      'FINISHED' => true, 'STOPPING' => false, 'ABORTING' => false, 'RUNNING'   => false
+    }
+    truth_table.each do |state, expected_result|
+      describe "when state is #{state}" do
+        before { @status.crawlState = state }
+        if expected_result
+          it { should be_stopped }
+        else
+          it { should_not be_stopped }
+        end
+      end
     end
   end
 
-  describe "#doc_count" do
-    it "should be tested" do
-      pending "write some tests"
-      # TODO
-    end
-  end
+  describe "#post_processing?" do
+    subject { @status }
 
-  describe "#crawl_started_to_date_time" do
-    it "should be tested" do
-      pending "write some tests"
-      # TODO
+    truth_table = {
+      'IDLE'     => false, 'STOPPED'  => false, 'ABORTED'  => false, 'EXCEPTION' => false,
+      'FINISHED' => false, 'STOPPING' => true,  'ABORTING' => true,  'RUNNING'   => false
+    }
+    truth_table.each do |state, expected_result|
+      describe "when state is #{state}" do
+        before { @status.crawlState = state }
+        if expected_result
+          it { should be_post_processing }
+        else
+          it { should_not be_post_processing }
+        end
+      end
     end
   end
 
-  describe "#elapsed_time" do
-    it "should be tested" do
-      pending "write some tests"
-      # TODO
+  describe "#doc_count" do
+    it "should sum numUpdated, numNew and numUnchanged" do
+      status = LucidWorks::Datasource::Status.new(
+        :parent => @server,
+        :numUpdated   => 11,
+        :numNew       => 22,
+        :numUnchanged => 33
+      )
+      status.doc_count.should == 66
     end
   end
 end