lucid_works 0.6.29 → 0.7.1

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

@@ -12,7 +12,7 @@ describe LucidWorks::Datasource::Status do
 
     STATES.each do |actual_state|
       describe "when state is #{actual_state}," do
-        before { @status.crawlState = actual_state.upcase }
+        before { @status.crawl_state = actual_state.upcase }
 
         (STATES - ['stopped']).each do |testing_state|
           predicate = "#{testing_state}?"
@@ -41,7 +41,7 @@ describe LucidWorks::Datasource::Status do
     }
     truth_table.each do |state, expected_result|
       describe "when state is #{state}" do
-        before { @status.crawlState = state }
+        before { @status.crawl_state = state }
         if expected_result
           it { should be_stopped }
         else
@@ -60,7 +60,7 @@ describe LucidWorks::Datasource::Status do
     }
     truth_table.each do |state, expected_result|
       describe "when state is #{state}" do
-        before { @status.crawlState = state }
+        before { @status.crawl_state = state }
         if expected_result
           it { should be_post_processing }
         else
@@ -71,12 +71,12 @@ describe LucidWorks::Datasource::Status do
   end
 
   describe "#doc_count" do
-    it "should sum numUpdated, numNew and numUnchanged" do
+    it "should sum num_updated, num_new and num_unchanged" do
       status = LucidWorks::Datasource::Status.new(
         :parent => @server,
-        :numUpdated   => 11,
-        :numNew       => 22,
-        :numUnchanged => 33
+        :num_updated   => 11,
+        :num_new       => 22,
+        :num_unchanged => 33
       )
       status.doc_count.should == 66
     end

data/spec/lib/lucid_works/datasource_spec.rb

@@ -133,7 +133,7 @@ describe LucidWorks::Datasource do
             :crawler => LucidWorks::Datasource::CRAWLERS['file'],
             :type => 'file',
             :name => "datasource we are going to update",
-            :path => "/fake_ds_to_be_updated",
+            :path => fixture_path("fake_file_ds_to_be_updated"),
             :crawl_depth => 2
           )
           @datasource.should be_persisted
@@ -155,7 +155,7 @@ describe LucidWorks::Datasource do
             :crawler => LucidWorks::Datasource::CRAWLERS['file'],
             :type => 'file',
             :name => "datasource we are going to delete",
-            :path => "/fake_ds_to_be_deleted",
+            :path => fixture_path("fake_file_ds_to_be_deleted"),
             :crawl_depth => 2
           )
           @datasource.should be_persisted
@@ -180,7 +180,7 @@ describe LucidWorks::Datasource do
         :crawler => LucidWorks::Datasource::CRAWLERS['file'],
         :type => 'file',
         :name => "datasource we are going to get a status of",
-        :path => "/fake_ds_to_get_status_of",
+        :path => fixture_path("fake_file_ds_to_get_status_of"),
         :crawl_depth => 2
       )
       @datasource.should be_persisted
@@ -192,7 +192,7 @@ describe LucidWorks::Datasource do
       @status.should be_valid
     end
 
-    %w{ crawlState numUnchanged }.each do |attr|
+    %w{ crawl_state num_unchanged }.each do |attr|
       it "should have a value for #{attr}" do
         @status.send(attr.to_sym).should_not be_nil
       end
@@ -206,9 +206,10 @@ describe LucidWorks::Datasource do
         :crawler => LucidWorks::Datasource::CRAWLERS['file'],
         :type => 'file',
         :name => "datasource we are going to get a schedule of",
-        :path => "/fake_ds_to_get_schedule_of",
+        :path => fixture_path("fake_file_ds_to_get_schedule_of"),
         :crawl_depth => 2
       )
+
       @datasource.should be_persisted
 
       schedule = @datasource.schedule
@@ -228,7 +229,7 @@ describe LucidWorks::Datasource do
         :crawler => LucidWorks::Datasource::CRAWLERS['file'],
         :type => 'file',
         :name => "datasource we are going to get a index of",
-        :path => "/fake_ds_to_get_index_of",
+        :path => fixture_path("fake_file_ds_to_get_index_of"),
         :crawl_depth => 2
       )
       @datasource.should be_valid
@@ -246,7 +247,7 @@ describe LucidWorks::Datasource do
         :crawler => LucidWorks::Datasource::CRAWLERS['file'],
         :type => 'file',
         :name => "datasource we are going to mess with job of",
-        :path => "/fake_ds_to_mess_with_job_of",
+        :path => fixture_path("fake_file_ds_to_mess_with_job_of"),
         :crawl_depth => 2
       )
       @datasource.should be_valid
@@ -302,7 +303,7 @@ describe LucidWorks::Datasource do
         :crawler => LucidWorks::Datasource::CRAWLERS['file'],
         :type => 'file',
         :name => "datasource we are going to get progress of",
-        :path => "/fake_ds_to_test_progress",
+        :path => fixture_path("fake_file_ds_to_test_progress"),
         :crawl_depth => 2
       )
       @datasource.should be_valid

data/spec/lib/lucid_works/field_spec.rb

@@ -124,7 +124,7 @@ describe LucidWorks::Field do
         end
       end
     end
-    
+
     context "for an existing field" do
       it "doesn't validate the name's uniqueness" do
         field = LucidWorks::Field.find('body', :parent => @collection)
@@ -132,7 +132,106 @@ describe LucidWorks::Field do
       end
     end
   end
-  
+
+  describe "#index_term_freq_and_pos" do
+
+    context "when indexed is false" do
+      before do
+        @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => false)
+      end
+
+      [
+        { :omit_tf => false, :omit_positions => false },
+        { :omit_tf => false, :omit_positions => true  },
+        { :omit_tf => true,  :omit_positions => false },
+        { :omit_tf => true,  :omit_positions => true  }
+      ].each do |settings|
+        it "should reuturn :document if omit_tf=#{settings[:omit_tf]} and omit_positions=#{settings[:omit_positions]}" do
+          settings.each { |k,v| @field.send("#{k}=", v) }
+          @field.index_term_freq_and_pos.should == :document_only
+        end
+      end
+    end
+
+    context "when indexed is true" do
+      before do
+        @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => true)
+      end
+
+      [
+        { :omit_tf => false, :omit_positions => false, :expected_result => :document_termfreq_termpos },
+        { :omit_tf => false, :omit_positions => true , :expected_result => :document_termfreq },
+        { :omit_tf => true,  :omit_positions => false, :expected_result => :document_only },
+        { :omit_tf => true,  :omit_positions => true , :expected_result => :document_only }
+      ].each do |data|
+        it "should return #{data[:expected_result]} if omit_tf=#{data[:omit_tf]} and omit_positions=#{data[:omit_positions]}" do
+          @field.omit_tf = data[:omit_tf]
+          @field.omit_positions = data[:omit_positions]
+          @field.index_term_freq_and_pos.should == data[:expected_result]
+        end
+      end
+    end
+  end
+
+  describe "#index_term_freq_and_pos=" do
+
+    INDEX_TERM_FREQ_AND_POS_TRUTH_TABLE = [
+      { :omit_tf => false, :omit_positions => false, :index_term_freq_and_pos => :document_termfreq_termpos },
+      { :omit_tf => false, :omit_positions => true , :index_term_freq_and_pos => :document_termfreq },
+      { :omit_tf => true,  :omit_positions => true , :index_term_freq_and_pos => :document_only }
+    ]
+
+    context "when indexed is true" do
+      before do
+        @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => true)
+      end
+
+      INDEX_TERM_FREQ_AND_POS_TRUTH_TABLE.each do |data|
+        it "should set omit_tf=#{data[:omit_tf]} and omit_positions=#{data[:omit_positions]} when given #{data[:index_term_freq_and_pos]}" do
+          #                       Set to opposite so we can see change
+          @field.omit_tf        = !data[:omit_tf]
+          @field.omit_positions = !data[:omit_positions]
+
+          @field.index_term_freq_and_pos = data[:index_term_freq_and_pos]
+          
+          @field.omit_positions.should == data[:omit_positions]
+          @field.omit_tf.should        == data[:omit_tf]
+        end
+      end
+
+      context "given anything else" do
+        it "should raise an error" do
+          lambda {
+            @field.index_term_freq_and_pos = :documents_and_bananas
+          }.should raise_error
+        end
+      end
+    end
+
+    context "when indexed is false" do
+      before do
+        @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => false)
+      end
+
+      INDEX_TERM_FREQ_AND_POS_TRUTH_TABLE.each do |data|
+        it "should set omit_tf=true and omit_positions=true when given #{data[:index_term_freq_and_pos]}" do
+          #                       Set to opposite so we can see change
+          @field.omit_tf        = false
+          @field.omit_positions = false
+
+          @field.index_term_freq_and_pos = data[:index_term_freq_and_pos]
+
+          @field.omit_positions.should == true
+          @field.omit_tf.should        == true
+        end
+      end
+
+      it "should set omit_tf=true and omit_positions=true" do
+
+      end
+    end
+  end
+
   describe "CRUD" do
     describe "find" do
       it "should retrieve a field" do

data/spec/lib/lucid_works/fieldtype_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe LucidWorks::Fieldtype do
+
+  before :all do
+    @server = connect_to_live_server
+    @server.reset_collections!
+  end
+
+  describe "CRUD" do
+    before :all do
+      @collection = @server.collections.create(:name => 'collection_for_testing_fieldtypes')
+    end
+
+    def fieldtype_count
+      @collection.fieldtypes!.size
+    end
+
+    describe ".create" do
+      context "with invalid parameters" do
+        before do
+          @parameters = {
+            :collection => @collection,
+            :name => "",
+            :_class => 'solr.StrField'
+          }
+        end
+    
+        it "should not create a fieldtype, and add errors for the invalid parameters" do
+          t = nil
+          lambda {
+            t = LucidWorks::Fieldtype.create(@parameters)
+          }.should_not change(self, :fieldtype_count)
+          t.errors[:name].should_not be_empty
+        end
+      end
+    
+      context "with valid parameters" do
+        before do
+          @parameters = {
+            :collection => @collection,
+            :name       => 'foobar',
+            :_class     => 'solr.StrField'
+          }
+        end
+
+        it "should create a fieldtype" do
+          lambda {
+            t = LucidWorks::Fieldtype.create(@parameters)
+            t.should be_a(LucidWorks::Fieldtype)
+            t.should be_persisted
+          }.should change(self, :fieldtype_count).by(1)
+        end
+      end
+
+      context "with a bunch of new parameters (not listed in the schema)" do
+        before do
+          @parameters = {
+            :collection => @collection,
+            :name            => 'new_fieldtype_with_random_attrs',
+            :_class          => 'solr.StrField',
+            :indexed         => 'true',
+            :omitNorms       => 'false',
+            :sortMissingLast => 'true'
+          }
+        end
+
+        it "should create a fieldtype" do
+          lambda {
+            t = LucidWorks::Fieldtype.create(@parameters)
+            t.should be_a(LucidWorks::Fieldtype)
+            t.should be_persisted
+          }.should change(self, :fieldtype_count).by(1)
+
+          t = LucidWorks::Fieldtype.find('new_fieldtype_with_random_attrs', :collection => @collection)
+          t.indexed.should == 'true'
+          t.omitNorms.should == 'false'
+          t.sortMissingLast.should == 'true'
+        end
+      end
+    end
+
+    describe ".find" do
+      context "for an existing fieldtype" do
+        it "should retrieve the fieldtype" do
+          ft = LucidWorks::Fieldtype.find('string', :collection => @collection)
+          ft.should be_persisted
+          ft.attributes.should == {
+            "_class"          => "solr.StrField",
+            "name"            => "string",
+            "omitNorms"       => "true",
+            "sortMissingLast" => "true"
+          }
+        end
+      end
+    end
+
+    context "for an existing fieldtype" do
+      before do
+        LucidWorks::Fieldtype.schema.reset!
+        @fieldtype = LucidWorks::Fieldtype.create(
+          :collection => @collection,
+          :name => "fieldtype_we_are_going_to_update",
+          :_class => 'solr.StrField',
+          :indexed => 'false'
+        )
+        @fieldtype.should be_persisted
+      end
+
+      after do
+        @fieldtype.destroy
+      end
+
+      describe "#save" do
+        it "should update the fieldtype" do
+          @fieldtype.indexed = "true"
+          @fieldtype.save
+          reloaded_ft = LucidWorks::Fieldtype.find(@fieldtype.name, :collection => @collection)
+          reloaded_ft.indexed.should == "true"
+        end
+      end
+
+      describe "#update_attributes" do
+        it "should add any attributes it does not recognize to the schema before saving" do
+          LucidWorks::Fieldtype.schema.should_not have_attribute(:stored)
+          @fieldtype.update_attributes(:stored => true)
+          LucidWorks::Fieldtype.schema.should have_attribute(:stored)
+          reloaded_ft = LucidWorks::Fieldtype.find(@fieldtype.name, :collection => @collection)
+          reloaded_ft.stored.should == "true"
+        end
+      end   
+    end
+
+    describe "#destroy" do
+      context "for an existing fieldtype" do
+        before do
+          @fieldtype = LucidWorks::Fieldtype.create(
+            :collection => @collection,
+            :name => "fieldtype_we_are_going_to_delete",
+            :_class => 'solr.StrField'
+          )
+          @fieldtype.should be_persisted
+        end
+
+        it "should delete the fieldtype" do
+          lambda {
+            @fieldtype.destroy
+          }.should change(self, :fieldtype_count).by(-1)
+          lambda {
+            LucidWorks::Fieldtype.find(@fieldtype.name, :collection => @collection)
+          }.should raise_error(RestClient::ResourceNotFound)
+        end
+      end
+    end
+  end
+end

data/spec/lib/lucid_works/schema/attribute_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe LucidWorks::Schema::Attribute do
+  before(:each) do
+    @mock_schema = double('Schema')
+  end
+
+  describe "#factory" do
+
+    context "when given a bad type" do
+      it "should raise an error" do
+        lambda {
+          Attribute.factory(@mock_schema, 'attrname', :invalid_attribute_type)
+        }.should raise_error
+      end
+    end
+
+    {
+      :string  => LucidWorks::Schema::StringAttribute,
+      :integer => LucidWorks::Schema::IntegerAttribute,
+      :boolean => LucidWorks::Schema::BooleanAttribute,
+      :iso8601 => LucidWorks::Schema::Iso8601Attribute,
+      :custom  => LucidWorks::Schema::CustomAttribute,
+    }.each do |attr_type, attr_class|
+      context "when given type #{attr_type}" do
+        it "should create an attribute of class #{attr_class.name}" do
+          attr = LucidWorks::Schema::Attribute.factory(@mock_schema, 'attrname', attr_type)
+          attr.should be_a(attr_class)
+        end
+      end
+    end
+
+    context "when given a name that cannot be represented as a ruby identifier" do
+      before do
+        @name = 'dash-dash' # - should get mapped to _
+      end
+
+      it "should map the name to something usable, and remember the old name" do
+        attr = LucidWorks::Schema::Attribute.factory @mock_schema, @name, :string
+        attr.name.should == :dash_dash
+        attr.type.should == :string
+        attr.instance_variable_get(:'@true_name').should == "dash-dash"
+      end
+    end
+
+    context "when given a name that is a reserved word" do
+      before do
+        @name = 'class'
+      end
+
+      it "should prefix the name with an underscore, and remember the old name" do
+        attr = LucidWorks::Schema::Attribute.factory @mock_schema, @name, :string
+        attr.name.should == :_class
+        attr.type.should == :string
+        attr.instance_variable_get(:'@true_name').should == "class"
+      end
+    end
+  end
+
+  describe "#encode_and_insert" do
+
+    it "should encode the attribute and insert it into the hash" do
+      attribute = LucidWorks::Schema::Attribute.factory(@mock_schema, 'attrname', :string)
+      hash = {}
+      attribute.encode_and_insert('foo', hash, false)
+      hash['attrname'].should == 'foo'
+    end
+    
+    context "for an attribute whose real name could not be represented as a ruby identifer" do
+      before do
+        @true_name = "dash-dash"
+      end
+
+      it "should use it's real name when inserting it into the hash" do
+        attribute = LucidWorks::Schema::Attribute.factory(@mock_schema, @true_name, :string)
+        attribute.name.should == :dash_dash
+        hash = {}
+        attribute.encode_and_insert('foo', hash, false)
+        hash[@true_name].should == 'foo'
+      end
+    end
+  end
+
+  describe "#human_value(value)" do
+    before :all do
+      # So we can test without actually needing ActionPack
+      class LucidWorks::Schema::IntegerAttribute
+        def number_with_delimiter(x)
+           x.to_s.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
+        end
+      end
+
+      class TrueClass
+        def to_yesno
+          self ? "yes" : "no"
+        end
+      end
+    end
+
+    context "for a boolean attribute" do
+      before do
+        @attribute = LucidWorks::Schema::Attribute.factory(@mock_schema, :booly, :boolean)
+      end
+
+      it "should to_yesno the attribute" do
+        @attribute.human_value(true).should == "yes"
+      end
+    end
+
+    context "for an integer attribute" do
+      before do
+        @attribute = LucidWorks::Schema::Attribute.factory(@mock_schema, :inty, :integer)
+      end
+
+      it "should number_with_delimeter the attribute" do
+        @attribute.human_value(12345678).should == "12,345,678"
+      end
+    end
+
+    context "for an attributed described as :string in the schema" do
+      before do
+        @attribute = LucidWorks::Schema::Attribute.factory(@mock_schema, :stringy, :string)
+      end
+
+      it "should just to_s the attribute" do
+        @attribute.human_value(true).should == "true"
+      end
+    end
+
+    #context "for an attribute described as :iso8601 in the schema" do
+    #  it "should convert it to localtime to_s(:short)" do
+    #    @widget.human_attribute_value(:when).should == "19 Mar 10:40"
+    #  end
+    #end
+  end
+end