lucid_works 0.7.18 → 0.9.4

data/spec/lib/lucid_works/field_spec.rb

@@ -11,6 +11,32 @@ describe LucidWorks::Field do
     LucidWorks::Field.new(:parent => @collection).should be_a(LucidWorks::Base)
   end
 
+  describe "adjusting REST URLs" do
+    context "when include_dynamic is disabled" do
+      it "doesn't change the collection URL" do
+        LucidWorks::Field.collection_url(@collection).should == "http://localhost:8888/api/collections/collection1/fields"
+      end
+
+      it "doesn't change the member URL" do
+        LucidWorks::Field.member_url(@collection, 5).should == "http://localhost:8888/api/collections/collection1/fields/5"
+      end
+    end
+
+    context "when include_dynamic is enabled" do
+      before do
+        LucidWorks::Field.include_dynamic = true
+      end
+      
+      it "changes the collection URL" do
+        LucidWorks::Field.collection_url(@collection).should == "http://localhost:8888/api/collections/collection1/fields?include_dynamic=true"
+      end
+
+      it "changes the member URL" do
+        LucidWorks::Field.member_url(@collection, 5).should == "http://localhost:8888/api/collections/collection1/fields/5?include_dynamic=true"
+      end
+    end
+  end
+  
   describe "default attribute values" do
     context "for a new field" do
       subject { LucidWorks::Field.new(:parent => @collection) }
@@ -29,7 +55,7 @@ describe LucidWorks::Field do
         LucidWorks::Field.new(
           :parent => @collection, 
           :indexed => true, :facet => true, :synonym_expansion => true, :omit_tf => true, :short_field_boost => true, :search_by_default => false, :use_in_find_similar => false, :query_time_stopword_handling => false,
-          :stored => true, :include_in_results => true, :highlight => true
+          :stored => true, :include_in_results => true, :highlight => true, :field_type => 'string'
         ) 
       }
       
@@ -40,6 +66,7 @@ describe LucidWorks::Field do
         
         it { subject.facet.should be_false }
         it { subject.synonym_expansion.should be_false }
+        it { subject.omit_positions.should be_false }
         it { subject.omit_tf.should be_false }
         it { subject.short_field_boost.should == 'high' }
         it { subject.search_by_default.should be_false }
@@ -62,7 +89,7 @@ describe LucidWorks::Field do
     context "for a new field" do
       context :name do
         it "is required" do
-          field = LucidWorks::Field.new(:parent => @collection)
+          field = LucidWorks::Field.new(:field_type => 'string', :parent => @collection)
           field.should_not be_valid
           field.errors[:name].should == ["can't be blank"]
         end
@@ -73,54 +100,60 @@ describe LucidWorks::Field do
           field.errors[:name].should == ["must be unique"]
         end
       end
+      
+      it "requires a field type" do
+        field = LucidWorks::Field.new(:parent => @collection, :name => 'data_source')
+        field.should_not be_valid
+        field.errors[:field_type].should == ["can't be blank"]
+      end
 
       context :short_field_boost do
         it "cannot be set to 'none' for a non-indexed field" do
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => false, :short_field_boost => 'none').tap do |field|
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :indexed => false, :short_field_boost => 'none').tap do |field|
             field.should_not be_valid
             field.errors[:short_field_boost].should == ['cannot be set to "none" for a non-indexed field']
           end
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => true, :short_field_boost => true, :indexing_options => :document_only).should be_valid
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :indexed => true, :short_field_boost => true, :indexing_options => :document_only).should be_valid
         end
       end
 
       context :include_in_results do
         it "requires the field to be stored" do
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :stored => false, :include_in_results => true).tap do |field|
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :stored => false, :include_in_results => true).tap do |field|
             field.should_not be_valid
             field.errors[:include_in_results].should == ["a field must be stored to be included in results"]
           end
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :stored => true, :include_in_results => true, :indexing_options => :document_only).should be_valid
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :stored => true, :include_in_results => true, :indexing_options => :document_only).should be_valid
         end
       end
 
       context :highlight do
         it "requires the field to be stored" do
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :stored => false, :highlight => true).tap do |field|
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :stored => false, :highlight => true).tap do |field|
             field.should_not be_valid
             field.errors[:highlight].should == ["a field must be stored to be highlighted"]
           end
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :stored => true, :highlighted => true).should be_valid
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :stored => true, :highlighted => true).should be_valid
         end
       end
 
       context :facet do
         it "requires the field to be indexed" do
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => false, :facet => true).tap do |field|
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :indexed => false, :facet => true).tap do |field|
             field.should_not be_valid
             field.errors[:facet].should == ["a field must be indexed to be facetable"]
           end
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => true, :facet => true, :indexing_options => :document_only).should be_valid
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :indexed => true, :facet => true, :indexing_options => :document_only).should be_valid
         end
       end
 
       context :use_in_find_similar do
         it "requires the field to be indexed" do
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => false, :use_in_find_similar => true).tap do |field|
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :indexed => false, :use_in_find_similar => true).tap do |field|
             field.should_not be_valid
             field.errors[:use_in_find_similar].should == ["a field must be indexed for it to be used for find-similar"]
           end
-          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => true, :use_in_find_similar => true, :indexing_options => :document_only).should be_valid
+          LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :indexed => true, :use_in_find_similar => true, :indexing_options => :document_only).should be_valid
         end
       end
     end
@@ -134,7 +167,7 @@ describe LucidWorks::Field do
   end
 
   describe "indexing options" do
-    INDEXING_OPTIONS_TRUTH_TABLE = [
+    FIELD_INDEXING_OPTIONS_TRUTH_TABLE = [
       { :indexed => true,  :indexing_options => :document_termfreq_termpos, :omit_tf => false, :omit_positions => false },
       { :indexed => true,  :indexing_options => :document_termfreq,         :omit_tf => false, :omit_positions => true },
       { :indexed => true,  :indexing_options => :document_only,             :omit_tf => true,  :omit_positions => true },
@@ -180,11 +213,11 @@ describe LucidWorks::Field do
     describe "getter" do
       context "when indexed is false" do
         before do
-          @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => false)
+          @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :indexed => false)
         end
 
         describe "it should always return :document_termfreq_termpos" do
-          INDEXING_OPTIONS_TRUTH_TABLE.select{ |x| x[:indexed] == 'false'}.each do |settings|
+          FIELD_INDEXING_OPTIONS_TRUTH_TABLE.select{ |x| x[:indexed] == 'false'}.each do |settings|
             it "should return :document_termfreq_termpos if omit_tf=#{settings[:omit_tf]} and omit_positions=#{settings[:omit_positions]}" do
               settings.each { |k,v| @field.send("#{k}=", v) }
               @field.indexing_options.should == :document_termfreq_termpos
@@ -196,10 +229,10 @@ describe LucidWorks::Field do
 
       context "when indexed is true" do
         before do
-          @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :indexed => true)
+          @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string', :indexed => true)
         end
 
-        INDEXING_OPTIONS_TRUTH_TABLE.select { |x| x[:indexed] == true }.each do |data|
+        FIELD_INDEXING_OPTIONS_TRUTH_TABLE.select { |x| x[:indexed] == true }.each do |data|
           it "should return #{data[:indexing_options]} 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]
@@ -207,15 +240,14 @@ describe LucidWorks::Field do
           end
         end
       end
-
     end
 
     describe "setter" do
       before do
-        @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field')
+        @field = LucidWorks::Field.new(:parent => @collection, :name => 'my_field', :field_type => 'string')
       end
 
-      INDEXING_OPTIONS_TRUTH_TABLE.each do |data|
+      FIELD_INDEXING_OPTIONS_TRUTH_TABLE.each do |data|
 
         context "when indexed is set to #{data[:indexed]} BEFORE indexing options is set to #{data[:indexing_options]}" do
           before do
@@ -277,7 +309,6 @@ describe LucidWorks::Field do
       it "should retrieve a field" do
         field = LucidWorks::Field.find('body', :parent => @collection)
         field.should be_a(LucidWorks::Field)
-        field.should respond_to(:field_type)
       end
     end
   end

data/spec/lib/lucid_works/fieldtype_spec.rb

@@ -88,7 +88,6 @@ describe LucidWorks::Fieldtype do
           ft.attributes.should == {
             "_class"          => "solr.StrField",
             "name"            => "string",
-            "omitNorms"       => "true",
             "sortMissingLast" => "true"
           }
         end

data/spec/lib/lucid_works/request_handler_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe LucidWorks::RequestHandler do
+  let(:server) { connect_to_live_server.tap {|server| server.reset_collections! } }
+
+  subject { server.collections.first.request_handler('lucid') }
+
+  its(:name) { should == 'lucid' }
+
+  its(:default_params) { should include(qf: 'author text_all title^5.0', pf: 'author text_all title^5.0') }
+end

data/spec/lib/lucid_works/role_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe LucidWorks::Role do
+  before :all do
+    @server = connect_to_live_server
+    @server.reset_collections!
+    @collection = @server.collection('collection1')
+  end
+
+  it "should use the ORM" do
+    LucidWorks::Role.new(:parent => @collection).should be_a(LucidWorks::Base)
+  end
+  
+  context "view helper methods" do
+    before do
+      @role = LucidWorks::Role.new(:parent => @collection)
+    end
+  
+    context "list is empty" do
+      describe "#users_for_text_field" do
+        it "should return an empty string" do
+          users = []
+          @role.users = users
+          @role.users.should == users
+          @role.users_for_text_field.should == ""
+        end
+      end
+      
+      describe "#groups_for_text_field" do
+        it "should return an empty string" do
+          groups = []
+          @role.groups = groups
+          @role.groups.should == groups
+          @role.groups_for_text_field.should == ""
+        end
+      end
+      
+      describe "#filters_for_text_area" do
+        it "should return an empty string" do
+          filters = []
+          @role.filters = filters
+          @role.filters.should == filters
+          @role.filters_for_text_area.should == ""
+        end
+      end
+    end
+    
+    context "list is not empty" do
+      describe "#users_for_text_field" do
+        it "should return a comma-space joined string" do
+          users = ["John Smith", "bob"]
+          @role.users = users
+          @role.users.should == users
+          @role.users_for_text_field.should == "John Smith, bob"
+        end
+      end
+
+      describe "#groups_for_text_field" do
+        it "should return a comma-space joined string" do
+          groups = ["Domain Admins", "admins"]
+          @role.groups = groups
+          @role.groups.should == groups
+          @role.groups_for_text_field.should == "Domain Admins, admins"
+        end
+      end
+      
+      describe "#filters_for_text_area" do
+        it "should return an empty string" do
+          filters = ["rails", "telecommute*"]
+          @role.filters = filters
+          @role.filters.should == filters
+          @role.filters_for_text_area.should == "rails\ntelecommute*"
+        end
+      end
+    end
+  end
+end

data/spec/lib/lucid_works/server/crawlers_status_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe LucidWorks::Server::CrawlersStatus do
+  let(:server) { LucidWorks::Server.new('http://1.1.1.1:8888') }
+
+  it "adjusts the member URL" do
+    LucidWorks::Server::CrawlersStatus.member_url(server).should == "http://1.1.1.1:8888/api/crawlers/status"
+  end
+
+  context "with an OK status" do
+    subject { LucidWorks::Server::CrawlersStatus.new(:parent => server, :status => 'OK') }
+
+    it { should be_ok }
+  end
+
+  context "with a non-OK status" do
+    subject { LucidWorks::Server::CrawlersStatus.new(:parent => server, :status => 'WARNING') }
+
+    it { should_not be_ok }
+  end
+end

data/spec/lib/lucid_works/server_spec.rb

@@ -1,30 +1,30 @@
 require 'spec_helper'
 
 describe LucidWorks::Server do
-  before do
-    @fake_server_uri = "http://fakehost.com:8888"
+  describe "exposing attributes" do    
+    let(:server_uri) { "http://joe:xyz@fakehost.com:8888" }
+    
+    subject { server = LucidWorks::Server.new(server_uri) }
+    
+    its(:server_uri) { should == server_uri }
+    its(:uri) { should == server_uri + "/api" } # TODO: 'uri' is a confusing name
+    its(:api_uri) { should == server_uri + "/api" }
+    its(:solr_uri) { should == server_uri + "/solr" }
+    its(:logs_uri) { should == server_uri + "/logs" }
+    its(:host) { should == "fakehost.com" }
+    its(:protocol) { should == "http://" }
+    its(:port) { should == 8888 }
+    its(:user) { should == "joe" }
+    its(:password) { should == "xyz" }
   end
 
-  describe ".new" do
-    it "should require a URL" do
-      lambda {
-        LucidWorks::Server.new
-      }.should raise_error(ArgumentError)
-    end
-
-    it "should remember the server URL" do
-      server = LucidWorks::Server.new(@fake_server_uri)
-      server.uri.should == @fake_server_uri + "/api"
-    end
-  end
-
-  context "server" do
-    before { @server = LucidWorks::Server.new(@fake_server_uri) }
+  describe "associations" do
+    let(:server) { LucidWorks::Server.new('http://host.example.com:8000') }
 
     describe "#collection" do
       it "should call Collection.find and pass the server" do
-        LucidWorks::Collection.should_receive(:find).with('foo', :parent => @server)
-        @server.collection('foo')
+        LucidWorks::Collection.should_receive(:find).with('foo', :parent => server)
+        server.collection('foo')
       end
     end
 
@@ -32,11 +32,112 @@ describe LucidWorks::Server do
       it "should create a HasMany association proxy for the specified class" do
         mock_proxy = double('has_many proxy', :find => nil)
         LucidWorks::Associations::HasMany.should_receive(:new).
-          with(@server, LucidWorks::Collection, {}).
+          with(server, LucidWorks::Collection, {}).
           and_return(mock_proxy)
-        
-        @server.collections
+        server.collections
+      end
+    end
+  end
+  
+  describe "helpers" do
+    let(:server) { connect_to_live_server }
+
+    describe "#datasource_types" do
+      before(:each) do
+        RestClient.should_receive(:get).with("#{server.server_uri}/api/crawlers").and_return <<-EOF
+          [
+            {
+              "name" : "lucid.aperture", 
+              "datasource_types" : [
+                {
+                  "props": [], 
+                  "type" : "file", 
+                  "category" : "FileSystem"
+                },
+                {
+                  "props": [], 
+                  "type" : "web", 
+                  "category" : "Web"
+                }
+              ]
+            },
+            {
+              "name" : "lucid.fs", 
+              "datasource_types" : [
+                {
+                  "props": [], 
+                  "type" : "file", 
+                  "category" : "FileSystem"
+                }
+              ]
+            }
+          ]
+        EOF
+      end
+
+      it "returns a flat list of datasource types" do
+        server.datasource_types.should have(3).items
+        dt = server.datasource_types.first
+        dt.should be_a(LucidWorks::DatasourceType)
+        dt.type.should == "file"
+        dt.crawler.name.should == "lucid.aperture"
+      end
+    end
+
+    describe "#datasource_type" do
+      before(:each) do
+        RestClient.should_receive(:get).with("#{server.server_uri}/api/crawlers").and_return <<-EOF
+          [
+            {
+              "name" : "lucid.aperture", 
+              "datasource_types" : [
+                {
+                  "props": [], 
+                  "type" : "file", 
+                  "category" : "FileSystem"
+                }
+              ]
+            },
+            {
+              "name" : "lucid.fs", 
+              "datasource_types" : [
+                {
+                  "props": [], 
+                  "type" : "file", 
+                  "category" : "FileSystem"
+                }
+              ]
+            }
+          ]
+        EOF
+      end
+
+      it "finds the datasource type matching the provided type name and crawler name" do
+        dt = server.datasource_type('file', 'lucid.fs')
+        dt.should be_a(LucidWorks::DatasourceType)
+        dt.type.should == "file"
+        dt.crawler.name.should == "lucid.fs"
+      end
+    end
+  end
+  
+  describe "#clustered" do
+    subject { LucidWorks::Server.new('http://host.example.com:8000') }
+    
+    context "with ZooKeeper" do
+      before(:each) do
+        RestClient.stub(:get).with('http://host.example.com:8000/solr/zookeeper') { '{"some":"json"}' }
+      end
+      
+      it { should be_clustered }
+    end
+
+    context "without ZooKeeper" do
+      before(:each) do
+        RestClient.stub(:get).with('http://host.example.com:8000/solr/zookeeper').and_raise RestClient::ResourceNotFound
       end
+      
+      it { should_not be_clustered }
     end
   end
 end

data/spec/lib/lucid_works/{collection/synonym_spec.rb → synonym_spec.rb}

@@ -1,27 +1,23 @@
 require 'spec_helper'
 
 describe LucidWorks::Synonym do
-  before do
-    @server = connect_to_live_server.tap {|server| server.reset_collections! }
-    load_collection
-  end
+  let(:server) { connect_to_live_server.tap {|server| server.reset_collections! } }
   
-  def load_collection
-    @collection = @server.collection('collection1')
+  let(:collection) { server.collection('collection1') }
+
+  def reload_collection
+    __memoized[:collection] = server.collection('collection1')
   end
-  alias :reload_collection :load_collection
   
   describe "naming support" do
-    it "demodulizes names" do
-      LucidWorks::Synonym.model_name.singular.should == "synonym"
-      LucidWorks::Synonym.model_name.plural.should == "synonyms"
-      LucidWorks::Synonym.model_name.collection.should == "synonyms"
+    it "demodulizes the model's name" do
+      LucidWorks::Synonym.model_name.should == "Synonym"
     end
   end
   
   describe "conversion support" do
     it "can be converted to a key" do
-      synonym = LucidWorks::Synonym.new(:collection => @collection, :mapping => "car, auto")
+      synonym = LucidWorks::Synonym.new(:collection => collection, :mapping => "car, auto")
       synonym.save
       synonym.to_key.should == [8]
     end
@@ -49,11 +45,12 @@ describe LucidWorks::Synonym do
     
   describe :save do
     context "when valid" do
-      subject { LucidWorks::Synonym.new(:collection => @collection, :mapping => "car, auto") }
+      subject { LucidWorks::Synonym.new(:collection => collection, :mapping => "car, auto") }
       
       it "gets saved in the collection settings" do
         subject.save
-        reload_collection.settings.synonym_list.should include("car, auto")
+        reload_collection
+        collection.settings.synonym_list.should include("car, auto")
       end
       
       it "returns true" do
@@ -72,11 +69,12 @@ describe LucidWorks::Synonym do
     end
     
     context "when invalid" do
-      subject { LucidWorks::Synonym.new(:collection => @collection, :mapping => "car") }
+      subject { LucidWorks::Synonym.new(:collection => collection, :mapping => "car") }
   
       it "doesn't get saved in the collection settings" do
         subject.save
-        reload_collection.settings.synonym_list.should_not include("car")
+        reload_collection
+        collection.settings.synonym_list.should_not include("car")
       end
       
       it "returns false" do
@@ -105,17 +103,20 @@ describe LucidWorks::Synonym do
   
   describe :update_attributes do
     it "updates the collection settings" do
-      @collection.synonyms[0].update_attributes(:mapping => "lawyer, clown")
-      reload_collection.should have(8).synonyms
-      @collection.synonyms[0].mapping.should == "lawyer, clown"
+      first_default_synonym = collection.settings.synonym_list.first
+      LucidWorks::Synonym.new(:id => 0, :collection => collection, :mapping => first_default_synonym, :persisted => true).
+        update_attributes(:mapping => "lawyer, clown")
+      reload_collection
+      collection.settings.synonym_list.first.should == "lawyer, clown"
     end
   end
   
   describe :destroy do
     it "removes the mapping from the collection settings" do
-      @collection.synonyms[0].destroy
-      reload_collection.should have(7).synonyms
-      @collection.synonyms.should_not include("lawyer, attorney")
+      first_default_synonym = collection.settings.synonym_list.first
+      LucidWorks::Synonym.new(:id => 0, :collection => collection, :mapping => first_default_synonym, :persisted => true).destroy
+      reload_collection
+      collection.settings.synonym_list.should_not include(first_default_synonym)
     end
   end
 end

data/spec/lib/lucid_works/version_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe LucidWorks::Version do
+  
+  specify { LucidWorks::Version.singleton.should be_true }
+end