lucid_works 0.1.1

data/spec/lib/lucid_works/collection_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe LucidWorks::Collection do
+  before :all do
+    @server = connect_to_live_server
+    @server.reset_collections!
+  end
+
+  describe "CRUD" do
+    before do
+      @collection_name = "a_new_collection"
+      @instance_dir = "my_instance_dir"
+    end
+
+    def collection_count
+      LucidWorks::Collection.all(:parent => @server).size
+    end
+
+    describe ".create" do
+      context "with ideal circumstances" do
+        it "should create a new collection with the appropriate name" do
+          lambda {
+            c = LucidWorks::Collection.create(:name => @collection_name,
+                                              :instance_dir => @instance_dir,
+                                              :parent => @server)
+            c.should be_kind_of(LucidWorks::Collection)
+            c.name.should == @collection_name
+            c.instance_dir.should == @instance_dir
+            c.should be_persisted
+          }.should change(self, :collection_count).by(1)
+        end
+      end
+
+      context "without a name" do
+        it "should not create" do
+          c = LucidWorks::Collection.create(:name => '', :parent => @server)
+          c.should_not be_persisted
+          c.errors.should_not be_empty
+          c.errors[:name].should_not be_blank
+        end
+      end
+
+      context "with a conflicting name" do
+        before do
+          @conflicting_name = "already_extant_collection"
+          LucidWorks::Collection.create(:name => @conflicting_name, :parent => @server)
+        end
+
+        it "should detect a conflict error" do
+          c = LucidWorks::Collection.create(:name => @conflicting_name, :parent => @server)
+          c.should_not be_persisted
+          c.errors[:name].should include "collection already exists"
+        end
+      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)
+        lambda {
+          c.destroy
+        }.should change(self, :collection_count).by(-1)
+      end
+    end
+  end
+
+  describe "#info" do
+    before :all do
+      @collection = LucidWorks::Collection.first(:parent => @server)
+      @info = @collection.info
+    end
+
+    it "should return a valid LucidWorks::Collection::Info" do
+      @info.should be_a(LucidWorks::Collection::Info)
+      @info.should be_valid
+    end
+
+    %w{ free_disk_space index_last_modified }.each do |attr|
+      it "should have a value for #{attr}" do
+        @info.send(attr.to_sym).should_not be_nil
+      end
+    end
+  end
+
+  describe "#settings" do
+    before :all do
+      @collection = LucidWorks::Collection.first(:parent => @server)
+      @settings = @collection.settings
+    end
+
+    it "should return a valid LucidWorks::Collection::Settings" do
+      @settings.should be_a(LucidWorks::Collection::Settings)
+      @settings.should be_valid
+    end
+
+    %w{ spellcheck display_facets }.each do |attr|
+      it "should have a value for #{attr}" do
+        @settings.send(attr.to_sym).should_not be_nil
+      end
+    end
+  end
+
+  context "for a collection with 2 datasources" do
+    before :all do
+      @collection = LucidWorks::Collection.create(:name => "collection-for-testing-datasources", :parent => @server)
+      @collection.should be_valid
+      @ds1 = LucidWorks::Datasource.create(
+        :collection => @collection,
+        :crawler => "lucid.aperture",
+        :type => LucidWorks::Datasource::TYPES[:FileSystemDataSource][:type],
+        :name => "US zoneinfo",
+        :path => "/usr/share/zoneinfo/US",
+        :crawl_depth => 1
+      )
+      @ds1.should be_valid
+      @ds2 = LucidWorks::Datasource.create(
+        :collection => @collection,
+        :crawler => "lucid.aperture",
+        :type => LucidWorks::Datasource::TYPES[:WebDataSource][:type],
+        :name => "nothing_com",
+        :url => "http://nothing.com/",
+        :crawl_depth => 1
+      )
+      @ds2.should be_valid
+      # Schedule a crawl to create some history
+      @schedule = @ds1.build_schedule
+      @schedule.period = '0'
+      @schedule.start_time = '0'
+      @schedule.active = true
+      @schedule.type = 'index'
+      @schedule.save
+      begin
+        Timeout::timeout(60) do
+          begin
+            sleep 1
+            status = @ds1.status!
+          end while status.crawlState != 'FINISHED'
+        end
+      rescue Timeout::Error
+        raise "Timed out waiting for collection #{@collection.name} datasource #{@ds1.name} crawl to complete"
+      end
+    end
+
+    describe "#datasource" do
+      it "should retrieve a single data source" do
+        ds = @collection.datasource(@ds1.id)
+        ds.should be_a(LucidWorks::Datasource)
+        ds.name.should == @ds1.name
+      end
+    end
+
+    describe '#datasources' do
+
+      it "should retrieve an array of data sources" do
+        datasources = @collection.datasources
+        datasources.should be_a(Array)
+        datasources.size.should == 2
+        datasources.each { |ds| ds.should be_a(LucidWorks::Datasource) }
+        datasources.map(&:name).should =~ [@ds1.name, @ds2.name]
+      end
+
+      it "should put a reference back to the collection in the datasources" do
+        datasources = @collection.datasources
+        datasources.each do |ds|
+          ds.collection.should == @collection
+        end
+      end
+
+#      context "with a bogus :include option" do
+#        it "should raise an error" do
+#          lambda {
+#            @collection.datasources(:include => :sprinkles)
+#          }.should raise_error(RuntimeError)
+#        end
+#      end
+
+      context "with option include :status" do
+        it "should attempt to retrieve all datasources and their status" do
+          datasources = @collection.datasources(:include => :status)
+          datasource = datasources.detect { |ds| ds.id == @ds1.id }
+          status = datasource.status
+          status.should be_a(LucidWorks::Datasource::Status)
+        end
+      end
+
+      context "with option include :history and :status" do
+        it "should attempt to retrieve all datasources and their statuses and history" do
+          datasources = @collection.datasources(:include => [:histories, :status])
+          datasource = datasources.detect { |ds| ds.id == @ds1.id }
+          datasource.histories.first.should be_a(LucidWorks::Datasource::History)
+          datasource.histories.first.crawlState.should == "FINISHED"
+          status = datasource.status
+          status.should be_a(LucidWorks::Datasource::Status)
+          status.crawlState.should == 'FINISHED'
+        end
+      end
+    end
+  end
+
+  describe "#empty!" do
+    before do
+      @collection = @server.collections.first
+    end
+
+    it "should DELETE /api/collections/<collection_id>/index" do
+      RestClient.should_receive(:delete).with("#{@collection.uri}/index", :params => {:key => 'iaccepttherisk'})
+
+      @collection.empty!
+    end
+  end
+end

data/spec/lib/lucid_works/datasource_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+describe LucidWorks::Datasource do
+  before :all do
+    @server = connect_to_live_server
+    @server.reset_collections!
+    @collection = @server.collections.first
+  end
+
+  describe "CRUD" do
+
+    def datasource_count
+      @collection.datasources!.size
+    end
+
+    describe ".create" do
+
+      context "with no parameters" do
+        before do
+          @parameters =  {
+            :parent => @collection
+          }
+        end
+
+        it "should not create a datasource, and add a base error" do
+          d = nil
+          lambda {
+            d = LucidWorks::Datasource.create(@parameters)
+          }.should_not change(self, :datasource_count)
+          d.errors[:base].should == ["No input content found"]
+        end
+      end
+
+      context "without a crawler specified" do
+        before do
+          @parameters = {
+            :collection => @collection,
+            :type => LucidWorks::Datasource::TYPES[:WebDataSource][:type],
+            :name => "foo"
+          }
+        end
+
+        it "should not create a datasource, and add an invalid error to crawler" do
+          d = nil
+          lambda {
+            d = LucidWorks::Datasource.create(@parameters)
+          }.should_not change(self, :datasource_count)
+          d.errors[:crawler].should_not be_empty
+          d.errors[:base].should be_blank
+        end
+      end
+
+      context "without a datasource type" do
+        before do
+          @parameters = {
+            :parent => @collection,
+            :name => "foo",
+          }
+        end
+
+        it "should not create a datasource, and add an invalid error to type" do
+          d = nil
+          lambda {
+            d = LucidWorks::Datasource.create(@parameters)
+          }.should_not change(self, :datasource_count)
+          d.errors[:type].should_not be_empty
+          d.errors[:base].should be_blank
+        end
+      end
+
+      context "with invalid parameters" do
+        before do
+          @parameters = {
+            :collection => @collection,
+            :name => "foo",
+            :crawler => "lucid.aperture",
+            :type => LucidWorks::Datasource::TYPES[:WebDataSource][:type],
+            :url => "invalid url",
+            :crawl_depth => "invalid crawl depth"
+          }
+        end
+
+        it "should not create a datasource, and add errors for the invalid parameters" do
+          d = nil
+          lambda {
+            d = LucidWorks::Datasource.create(@parameters)
+          }.should_not change(self, :datasource_count)
+          d.errors[:url].should_not be_empty
+          d.errors[:crawl_depth].should_not be_empty
+          d.errors[:base].should be_blank
+        end
+      end
+
+      context "with valid parameters" do
+        before do
+          @parameters = {
+            :collection => @collection,
+            :crawler => "lucid.aperture",
+            :type => LucidWorks::Datasource::TYPES[:WebDataSource][:type],
+            :name => "Lucid Imagination Website",
+            :url => "http://www.lucidimagination.com/",
+            :crawl_depth => 2,
+            :exclude_paths => [
+              "http://www\\.lucidimagination\\.com/blog/tag/.*",
+              "http://www\\.lucidimagination\\.com/search\\?.*"
+            ],
+            :include_paths => [
+              "http://www\\.lucidimagination\\.com/.*"
+            ]
+          }
+        end
+
+        it "should create a datasource" do
+          lambda {
+            d = LucidWorks::Datasource.create(@parameters)
+            d.should be_kind_of(LucidWorks::Datasource)
+            d.should be_persisted
+          }.should change(self, :datasource_count).by(1)
+        end
+      end
+    end
+
+    describe ".find" do
+      context "for an extant datasource" do
+        before do
+          @datasource = LucidWorks::Datasource.create(
+            :collection => @collection,
+            :crawler => "lucid.aperture",
+            :type => LucidWorks::Datasource::TYPES[:FileSystemDataSource][:type],
+            :name => "slash_temp",
+            :path => "/tmp",
+            :crawl_depth => 2
+          )
+          @datasource.should be_persisted
+        end
+
+        it "should retrieve the datasource" do
+          d = LucidWorks::Datasource.find(@datasource.id, :collection => @collection)
+          d.should be_persisted
+          d.name.should == @datasource.name
+        end
+      end
+    end
+
+    describe "#save" do
+      context "for an extant datasource" do
+        before do
+          @datasource = LucidWorks::Datasource.create(
+            :collection => @collection,
+            :crawler => "lucid.aperture",
+            :type => LucidWorks::Datasource::TYPES[:FileSystemDataSource][:type],
+            :name => "datasource we are going to update",
+            :path => "/fake_ds_to_be_updated",
+            :crawl_depth => 2
+          )
+          @datasource.should be_persisted
+        end
+
+        it "should update the datasource" do
+          @datasource.name = "updated datasource"
+          @datasource.save
+          LucidWorks::Datasource.find(@datasource.id, :collection => @collection).name.should == "updated datasource"
+        end
+      end
+    end
+
+    describe "#destroy" do
+      context "for an extant datasource" do
+        before do
+          @datasource = LucidWorks::Datasource.create(
+            :collection => @collection,
+            :crawler => "lucid.aperture",
+            :type => LucidWorks::Datasource::TYPES[:FileSystemDataSource][:type],
+            :name => "datasource we are going to delete",
+            :path => "/fake_ds_to_be_deleted",
+            :crawl_depth => 2
+          )
+          @datasource.should be_persisted
+        end
+
+        it "should delete the datasource" do
+          lambda {
+            @datasource.destroy
+          }.should change(self, :datasource_count).by(-1)
+          lambda {
+            LucidWorks::Datasource.find(@datasource.id, :collection => @collection)
+          }.should raise_error(RestClient::ResourceNotFound)
+        end
+      end
+    end
+  end
+
+  describe "#status" do
+    before :all do
+      @datasource = LucidWorks::Datasource.create(
+        :collection => @collection,
+        :crawler => "lucid.aperture",
+        :type => LucidWorks::Datasource::TYPES[:FileSystemDataSource][:type],
+        :name => "datasource we are going to get a status of",
+        :path => "/fake_ds_to_get_status_of",
+        :crawl_depth => 2
+      )
+      @datasource.should be_persisted
+      @status = @datasource.status
+    end
+
+    it "should return a valid LucidWorks::Collection::Datasource::Status" do
+      @status.should be_a(LucidWorks::Datasource::Status)
+      @status.should be_valid
+    end
+
+    %w{ crawlState numUnchanged }.each do |attr|
+      it "should have a value for #{attr}" do
+        @status.send(attr.to_sym).should_not be_nil
+      end
+    end
+  end
+
+  describe "#schedule" do
+    it "should retrieve the datasource's schedule" do
+      @datasource = LucidWorks::Datasource.create(
+        :collection => @collection,
+        :crawler => "lucid.aperture",
+        :type => LucidWorks::Datasource::TYPES[:FileSystemDataSource][:type],
+        :name => "datasource we are going to get a schedule of",
+        :path => "/fake_ds_to_get_schedule_of",
+        :crawl_depth => 2
+      )
+      @datasource.should be_persisted
+
+      schedule = @datasource.schedule
+      schedule.should be_a(LucidWorks::Datasource::Schedule)
+      schedule.should be_persisted
+      schedule.datasource.should == @datasource
+      schedule.type.should == "index"
+      schedule.period.should == 0
+      schedule.active.should == false
+    end
+  end
+
+  describe "#build_index" do
+    it "should return a new LucidWorks::Datasource::Index for this datasource" do
+      @datasource = LucidWorks::Datasource.create(
+        :collection => @collection,
+        :crawler => "lucid.aperture",
+        :type => LucidWorks::Datasource::TYPES[:FileSystemDataSource][:type],
+        :name => "datasource we are going to get a index of",
+        :path => "/fake_ds_to_get_index_of",
+        :crawl_depth => 2
+      )
+      @datasource.should be_valid
+
+      index = @datasource.build_index
+      index.should be_a(LucidWorks::Datasource::Index)
+      index.should be_persisted # special case - singletons are always considered persisted
+    end
+  end
+
+  describe "#empty!" do
+    before do
+      @collection = @server.collections.first
+      @datasource = LucidWorks::Datasource.create(
+        :collection => @collection,
+        :crawler => "lucid.aperture",
+        :type => LucidWorks::Datasource::TYPES[:FileSystemDataSource][:type],
+        :name => "datasource we are going to empty",
+        :path => "/fake_ds_to_empty",
+        :crawl_depth => 2
+      )
+      @datasource.should be_valid
+    end
+
+    it "should DELETE /api/collections/<collection_id>/index" do
+      RestClient.should_receive(:delete).with("#{@datasource.uri}/index", {})
+
+      @datasource.empty!
+    end
+
+  end
+end