dm-ldap-adapter 0.3.5 → 0.4.0.alpha2

data/spec/ldap_adapter_spec.rb

@@ -1,185 +1,160 @@
 $LOAD_PATH << File.dirname(__FILE__)
 require 'spec_helper'
 
-[
- :default,
- :ldap, 
- :memory
-].each do |adapter|
-
-  puts "#{DataMapper.repository(adapter).adapter.class.name}"
-  
-  describe "A #{DataMapper.repository(adapter).adapter.class.name}" do
-
-    before(:each) do
-      DataMapper.repository(adapter) do
-        @user1 = User.create(:login => "black", :name => 'Black', :age => 0) 
-        @user2 = User.create(:login => "brown", :name => 'Brown', :age => 25)
-        @user3 = User.create(:login => "blue", :name => 'Blue',  :age => nil)
-      end
-    end
-    
-    after(:each) do
-      DataMapper.repository(adapter) do
-        @user1.destroy
-        @user2.destroy
-        @user3.destroy
-      end
+describe DataMapper::Adapters::LdapAdapter do
+
+  before(:each) do
+    DataMapper.repository(:ldap) do
+      User.all.destroy!
+      @user1 = User.create(:login => "black", :name => 'Black', :age => 0)
+      @user2 = User.create(:login => "brown", :name => 'Brown', :age => 25)
+      @user3 = User.create(:login => "blue", :name => 'Blue',  :age => nil)
     end
+  end
 
-    it 'should create an uid' do
-      class User
-        # put the assert here
-        dn_prefix { |user| user.id.should_not == nil; "uid=#{user.login}"}
-      end
+  it 'should create an uid' do
+    class User
+      # put the assert here
+      dn_prefix { |user| user.id.should_not == nil; "uid=#{user.login}"}
+    end
 
-      DataMapper.repository(adapter) do
-        id = @user1.id
-        @user1.destroy
-        @user1 = User.create(:login => "black", :name => 'Black', :age => 0)
-        @user1.id.should_not == id
-      end
+    DataMapper.repository(:ldap) do
+      id = @user1.id
+      @user1.destroy
+      @user1 = User.create(:login => "black", :name => 'Black', :age => 0)
+      @user1.id.should_not == id
     end
+  end
 
-    it 'should successfully save an object' do
-      DataMapper.repository(adapter) do
-        @user1.new_record?.should be_false
-        User.first(:login => @user1.login).new_record?.should be_false
-      end
+  it 'should successfully save an object' do
+    DataMapper.repository(:ldap) do
+      @user1.new?.should be_false
+      User.first(:login => @user1.login).new?.should be_false
     end
+  end
 
-    it 'should raise an error when trying to create an entity with already used key' do
-      DataMapper.repository(adapter) do
-       #p User.first(:login => "black")
-       lambda { User.create(:login => "black", :name => 'Black', :age => 0) }.should raise_error
+  it 'should raise an error when trying to create an entity with already used key' do
+    DataMapper.repository(:ldap) do
+      #p User.first(:login => "black")
+      lambda { User.create(:login => "black", :name => 'Black', :age => 0) }.should raise_error
       #p User.all
-      end
     end
+  end
 
-    it 'should be able to get all the objects' do
-      DataMapper.repository(adapter) do
-        User.all(:login.like => "b%").should == [@user1, @user2, @user3]
-      end
+  it 'should be able to get all the objects' do
+    DataMapper.repository(:ldap) do
+      User.all(:login.like => "b%").should == [@user1, @user2, @user3]
+    end
+  end
+
+  it 'should be able to search with empty result' do
+    DataMapper.repository(:ldap) do
+      User.all(:name => "blablublo").should == []
     end
+  end
 
-    it 'should be able to search for objects with equal value' do
-      DataMapper.repository(adapter) do
-        User.all(:name => "Brown").should == [@user2]
-        User.all(:age => 25).should == [@user2]
-      end
+  it 'should be able to search for objects with equal value' do
+    DataMapper.repository(:ldap) do
+      User.all(:name => "Brown").should == [@user2]
+      User.all(:age => 25).should == [@user2]
     end
+  end
 
-    it 'should be able to search for objects included in an array of values' do
-      DataMapper.repository(adapter) do
-        User.all(:age => [ 25, 50, 75, 100 ]).should == [@user2]
-      end
+  it 'should be able to search for objects included in an array of values' do
+    DataMapper.repository(:ldap) do
+      User.all(:age => [ 25, 50, 75, 100 ]).should == [@user2]
     end
+  end
 
-    #it 'should be able to search for objects included in a range of values' do
-    #  User.all(:age => 25..100).should == [@user2]
-    #end
+  #it 'should be able to search for objects included in a range of values' do
+  #  User.all(:age => 25..100).should == [@user2]
+  #end
 
-    it 'should be able to search for objects with nil value' do
-      DataMapper.repository(adapter) do
-        User.all(:age => nil, :name.like => "B%").should == [@user3]
-      end
+  it 'should be able to search for objects with nil value' do
+    DataMapper.repository(:ldap) do
+      User.all(:age => nil, :name.like => "B%").should == [@user3]
     end
+  end
 
-    if adapter != :default
-      it 'should be able to search for objects with not equal value' do
-        DataMapper.repository(adapter) do
-          User.all(:age.not => 25, :name.like => "B%").should == [@user1, @user3]
-        end
-      end
-      
-      it 'should be able to search for objects not included in an array of values' do
-        DataMapper.repository(adapter) do
-          User.all(:age.not => [ 25, 50, 75, 100 ], :name.like => "B%").should == [@user1, @user3]
-        end
-      end
-    else
-      puts
-      puts "NOTE"
-      puts "=================================================="
-      puts
-      puts "sqlite3 handles NULL different from values, i.e."
-      puts "select * from users where name = 'sd';"
-      puts "and"
-      puts "select * from users where name != 'sd';"
-      puts "gives the same result when all names are NULL !!!"
-      puts
-      puts "=================================================="
-      puts
-    end
-
-    it 'should be able to search for objects with not equal value' do
-      DataMapper.repository(adapter) do
-        User.all(:age.not => nil, :name.like => "B%").should == [@user1, @user2]
-      end
+  it 'should be able to search for objects with not equal value' do
+    DataMapper.repository(:ldap) do
+      User.all(:age.not => 25, :name.like => "B%").should == [@user1, @user3]
+    end
+  end
+
+  it 'should be able to search for objects not included in an array of values' do
+    DataMapper.repository(:ldap) do
+      User.all(:age.not => [ 25, 50, 75, 100 ], :name.like => "B%").should == [@user1, @user3]
     end
+  end
 
-    it 'should search objects with or conditions' do
-      if adapter == :ldap
-        DataMapper.repository(adapter) do
-          User.all(:age.not => nil, :conditions => ["name='Black' or name='Blue'"]).should == [@user1]
-          User.all(:age.not => nil, :conditions => ["name='Black' or name='Brown'"]).should == [@user1, @user2]
-          User.all(:age => nil, :conditions => ["name='Black' or name='Brown'"]).should == []
-          User.all(:age => nil, :conditions => ["name='Black' or name='Brown' or name='Blue'"]).should == [@user3]
-          User.all(:conditions => ["name='Black' or name='Brown' or name='Blue'"]).should == [@user1, @user2, @user3]
-          User.all(:conditions => ["name='Black'"]).should == [@user1]
-          User.all(:conditions => ["name like 'Bl%'"]).should == [@user1, @user3]
-          User.all(:conditions => ["name like 'B%'"]).should == [@user1, @user2, @user3]
-          User.all(:conditions => ["name like 'X%X_X'"]).should == []
-User.all(:conditions => ["name like 'Bla%' or name like 'Br%'"]).should == [@user1, @user2]
-        end
-      end
+  it 'should be able to search for objects with not equal value' do
+    DataMapper.repository(:ldap) do
+      User.all(:age.not => nil, :name.like => "B%").should == [@user1, @user2]
     end
+  end
 
+  it 'should search objects with or conditions' do
+    DataMapper.repository(:ldap) do
+      User.all(:age.not => nil, :conditions => ["name='Black' or name='Blue'"]).should == [@user1]
+      User.all(:age.not => nil, :conditions => ["name='Black' or name='Brown'"]).should == [@user1, @user2]
+      User.all(:age => nil, :conditions => ["name='Black' or name='Brown'"]).should == []
+      User.all(:age => nil, :conditions => ["name='Black' or name='Brown' or name='Blue'"]).should == [@user3]
+      User.all(:conditions => ["name='Black' or name='Brown' or name='Blue'"]).should == [@user1, @user2, @user3]
+      User.all(:conditions => ["name='Black'"]).should == [@user1]
+      User.all(:conditions => ["name like 'Bl%'"]).should == [@user1, @user3]
+      User.all(:conditions => ["name like 'B%'"]).should == [@user1, @user2, @user3]
+      User.all(:conditions => ["name like 'X%X_X'"]).should == []
+      User.all(:conditions => ["name like 'Bla%' or name like 'Br%'"]).should == [@user1, @user2]
+    end
+  end
 
-    #     it 'should be able to search for objects not included in a range of values' do
-    #       User.all(:age.not => 25..100).should == [@user1, @user3]
-    #     end
 
-    #    it 'should be able to search for objects with not nil value' do
-    #      User.all(:age.not => 25, :name.like => "B%").should == [@user1, @user2]
-    #    end
+  #     it 'should be able to search for objects not included in a range of values' do
+  #       User.all(:age.not => 25..100).should == [@user1, @user3]
+  #     end
 
-    it 'should be able to search for objects that match value' do
-      DataMapper.repository(adapter) do
-        User.all(:name.like => 'Bl%').should == [@user1, @user3]
-      end
+  #    it 'should be able to search for objects with not nil value' do
+  #      User.all(:age.not => 25, :name.like => "B%").should == [@user1, @user2]
+  #    end
+
+  it 'should be able to search for objects that match value' do
+    DataMapper.repository(:ldap) do
+      User.all(:name.like => 'Bl%').should == [@user1, @user3]
     end
+  end
 
-    #it 'should be able to search for objects with value greater than' do
-    #  User.all(:age.gt => 0).should == [@user2]
-    #end
+  #it 'should be able to search for objects with value greater than' do
+  #  User.all(:age.gt => 0).should == [@user2]
+  #end
 
-    #it 'should be able to search for objects with value greater than or equal to' do
-    #  User.all(:age.gte => 0).should == [@user1, @user2]
-    #end
+  #it 'should be able to search for objects with value greater than or equal to' do
+  #  User.all(:age.gte => 0).should == [@user1, @user2]
+  #end
 
-    #it 'should be able to search for objects with value less than' do
-    #  User.all(:age.lt => 1).should == [@user1]
-    #end
+  #it 'should be able to search for objects with value less than' do
+  #  User.all(:age.lt => 1).should == [@user1]
+  #end
 
-    #it 'should be able to search for objects with value less than or equal to' do
-    #  User.all(:age.lte => 0).should == [@user1]
-    #end
+  #it 'should be able to search for objects with value less than or equal to' do
+  #  User.all(:age.lte => 0).should == [@user1]
+  #end
 
-    it 'should be able to update an object' do
-      DataMapper.repository(adapter) do
-        @user1 = User.get(@user1.id)
-        @user1.age = 10
-        @user1.save
-        User.get(@user1.id).age.should == 10
-        @user1.age = 70
-        @user1.save
-        User.get(@user1.id).age.should == 70
-      end
+  it 'should be able to update an object' do
+    DataMapper.repository(:ldap) do
+      @user1 = User.get(@user1.id)
+      @user1.age = 10
+      @user1.save
+      User.get(@user1.id).age.should == 10
+      @user1.age = 70
+      @user1.save
+      User.get(@user1.id).age.should == 70
     end
+  end
 
-    it 'should be able to update an object with nil' do
-      DataMapper.repository(adapter) do
+  it 'should be able to update an object with nil' do
+    DataMapper.repository(:ldap) do
+      begin
         @user1 = User.get(@user1.id)
         @user1.age = nil
         @user1.save
@@ -187,59 +162,71 @@ User.all(:conditions => ["name like 'Bla%' or name like 'Br%'"]).should == [@use
         @user1.age = 70
         @user1.save
         User.get(@user1.id).age.should == 70
+      rescue => e
+        puts e
+        puts e.backtrace.join "\n\t"
+        raise e
       end
     end
+  end
 
-    it 'should be able to destroy an object' do
-      DataMapper.repository(adapter) do
-        size = User.all.size
-        @user1.destroy
-        User.all.size.should == size - 1
-      end
+  it 'should be able to destroy an object' do
+    DataMapper.repository(:ldap) do
+      size = User.all.size
+      @user1.destroy
+      User.all.size.should == size - 1
     end
+  end
 
-    it 'should work with transactions' do
-      DataMapper.repository(adapter) do
+  it 'should work with transactions' do
+    DataMapper.repository(:ldap) do
+      begin
         User.transaction do
           user = User.get(@user3.id)
           user.name = "B new"
           user.save
           User.get(@user3.id).name.should == 'B new'
         end
+      rescue => e
+        puts e
+        puts e.backtrace.join "\n\t"
+        raise e
       end
     end
+  end
 
-    if DataMapper.repository(adapter).adapter.respond_to? :open_ldap_connection
-
-      it 'should use one connection for several actions' do
-        DataMapper.repository(adapter) do
-          DataMapper.repository.adapter.open_ldap_connection do
-            hash = DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash
-            User.all
-            DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should == hash
-            user = User.get(@user3.id)
-            DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should == hash
-            user.name = "another name"
-            user.save
-            DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should == hash
-          end
-          DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should_not == hash
-        end
-      end
+  if DataMapper.repository(:ldap).adapter.respond_to? :open_ldap_connection
 
-      it 'should use new connection for each action' do
-        DataMapper.repository(adapter) do
+    it 'should use one connection for several actions' do
+      DataMapper.repository(:ldap) do
+        DataMapper.repository.adapter.open_ldap_connection do
           hash = DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash
           User.all
-
-          DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should_not == hash
+          DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should == hash
           user = User.get(@user3.id)
-          DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should_not == hash
-          user.name = "yet another name"
+          DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should == hash
+          user.name = "another name"
           user.save
-          DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should_not == hash
+          DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should == hash
         end
+        DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should_not == hash
+      end
+    end
+
+    it 'should use new connection for each action' do
+      DataMapper.repository(:ldap) do
+        hash = DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash
+        User.all
+
+        DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should_not == hash
+        user = User.get(@user3.id)
+        DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should_not == hash
+        user.name = "yet another name"
+        user.save
+        DataMapper.repository.adapter.instance_variable_get(:@ldap_connection).current.hash.should_not == hash
       end
     end
   end
 end
+
+\

data/spec/multi_repository_spec.rb

@@ -6,12 +6,29 @@ class Order
 
   property :id, Serial
 
-  repository(:ldap) do
-    belongs_to :user
+  belongs_to :user, :required => false, :repository => :ldap
+end
+
+class Order2
+  include DataMapper::Resource
+
+  def self.repository_name
+    :default
+  end
+
+  property :id, Serial
+
+  belongs_to :user, :required => false
+end
+
+class User
+  def self.repository_name
+    :ldap
   end
 end
 
 Order.auto_migrate!(:default)
+Order2.auto_migrate!(:default)
 
 describe DataMapper.repository(:ldap).adapter do
 
@@ -19,12 +36,16 @@ describe DataMapper.repository(:ldap).adapter do
 
     before do
       DataMapper.repository(:ldap) do
+        begin
+          User.all.destroy!
         @user = User.new(:login => "beige", :name => 'Beige')
         @user.password = "asd123"
         @user.save
+        rescue => e
+          puts e.backtrace.join("\n\t")
+          raise e
+        end
       end
-
-      @order = Order.create
     end
 
     after do
@@ -35,9 +56,24 @@ describe DataMapper.repository(:ldap).adapter do
     end
 
     it 'should create and load the association' do
+      @order = Order.create
       @order.user = @user
       @order.save
-      Order.get!(@order.id).user.should == @user
+      order = Order.get!(@order.id)
+      DataMapper.repository(:ldap) do
+        order.user.should == @user
+      end
+    end
+    it 'should create and load the association with fixed repositories' do
+      DataMapper.repository(:default) do
+        DataMapper.repository(:ldap) do
+          @order = Order2.create
+          @order.user = @user
+          @order.save
+          order = Order2.get!(@order.id)
+          order.user.should == @user
+        end
+      end
     end
   end
 end

data/spec/multi_value_attributes_spec.rb

@@ -1,14 +1,14 @@
 $LOAD_PATH << File.dirname(__FILE__)
 require 'spec_helper'
 
-class Contact
+class TestContact
   include DataMapper::Resource
 
   property :id,        Serial, :field => "uidnumber"
   property :login,     String, :field => "uid", :unique_index => true
-  property :hashed_password,  String, :field => "userpassword", :access => :private, :lazy => true
+  property :hashed_password,  String, :field => "userpassword", :lazy => true
   property :name,      String, :field => "cn"
-  property :mail,      LdapArray
+  property :mail,      ::Ldap::LdapArray
 
   dn_prefix { |contact| "uid=#{contact.login}"}
 
@@ -33,16 +33,15 @@ describe DataMapper.repository(:ldap).adapter.class do
 
     before :each do
       DataMapper.repository(:ldap) do
-        Contact.all(:login => "beige").destroy!
-        @contact =  Contact.new(:login => "beige", :name => 'Beige')
-        @contact.password = "asd123"
-        @contact.save
-      end
-    end
-
-    after :each do
-      DataMapper.repository(:ldap) do
-        @contact.destroy
+        begin
+          TestContact.all(:login.like => "b%").destroy!
+          @contact =  TestContact.new(:login => "beige", :name => 'Beige')
+          @contact.password = "asd123"
+          @contact.save
+        rescue => e
+          puts e.backtrace.join("\n\t")
+          raise e
+        end
       end
     end
 
@@ -50,24 +49,32 @@ describe DataMapper.repository(:ldap).adapter.class do
        DataMapper.repository(:ldap) do
         @contact.mail.should == []
 
-        @contact.mail << "email1"
+        @contact.mail = ["email1"]
         @contact.save
-        @contact = Contact.get!(@contact.id)
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.get!(@contact.id)
         @contact.mail.should == ["email1"]
-
         @contact.mail << "email2"
         @contact.save
-        @contact = Contact.get!(@contact.id)
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.get!(@contact.id)
         @contact.mail.should == ["email1", "email2"]
-
         @contact.mail.delete("email1")
         @contact.save
-        @contact = Contact.get!(@contact.id)
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.get!(@contact.id)
         @contact.mail.should == ["email2"]
 
-        @contact.mail.delete("email2")
+        mail = @contact.mail.dup
+        mail.delete("email2")
+        @contact.mail = mail
         @contact.save
-        @contact = Contact.get!(@contact.id)
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.get!(@contact.id)
         @contact.mail.should == []
       end
     end
@@ -76,35 +83,61 @@ describe DataMapper.repository(:ldap).adapter.class do
       DataMapper.repository(:ldap) do
         @contact.mail.should == []
 
-        @contact.mail << "email1"
+        @contact.mail = ["email1"]
         @contact.save
-        @contact = Contact.all.detect {|c| c.id = @contact.id}
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.all.detect {|c| c.id = @contact.id}
         @contact.mail.should == ["email1"]
 
-        @contact.mail << "email2"
+        @contact.mail = @contact.mail.dup << "email2"
         @contact.save
-        @contact = Contact.all.detect {|c| c.id = @contact.id}
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.all.detect {|c| c.id = @contact.id}
         @contact.mail.should == ["email1", "email2"]
 
-        @contact.mail.delete("email1")
+        mail = @contact.mail.dup
+        mail.delete("email1")
+        @contact.mail = mail
         @contact.save
-        @contact = Contact.all.detect {|c| c.id = @contact.id}
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.all.detect {|c| c.id = @contact.id}
         @contact.mail.should == ["email2"]
 
-        @contact.mail.delete("email2")
+        mail = @contact.mail.dup
+        mail.delete("email2")
+        @contact.mail = mail
         @contact.save
-        @contact = Contact.all.detect {|c| c.id = @contact.id}
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.all.detect {|c| c.id = @contact.id}
         @contact.mail.should == []
       end
     end
 
     it 'should allow to replace the LdapArray' do
       DataMapper.repository(:ldap) do
-        @contact = Contact.get(@contact.id)
+        @contact = TestContact.get(@contact.id)
         @contact.mail.should == []
         @contact.mail = ['foo', 'bar']
         @contact.save
-        @contact = Contact.get(@contact.id)
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.get(@contact.id)
+        @contact.mail.should == ['foo', 'bar']
+      end
+    end
+    it 'should create resource with the LdapArray' do
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.new(:login => "black", :name => 'Black')
+        @contact.password = "asd123"
+        @contact.mail = ['foo', 'bar']
+        @contact.save
+      end
+      DataMapper.repository(:ldap) do
+        @contact = TestContact.get(@contact.id)
         @contact.mail.should == ['foo', 'bar']
       end
     end