ldap_adapter_spec.rb in dm-ldap-adapter-0.4.0.alpha2

- old
+ new
@@ -1,245 +1,232 @@
 $LOAD_PATH << File.dirname(__FILE__)
 require 'spec_helper'
 
-[
- :default,
- :ldap, 
- :memory
-].each do |adapter|
+describe DataMapper::Adapters::LdapAdapter do
 
-  puts "#{DataMapper.repository(adapter).adapter.class.name}"
-  
-  describe "A #{DataMapper.repository(adapter).adapter.class.name}" 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
 
-    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
+  it 'should create an uid' do
+    class User
+      # put the assert here
+      dn_prefix { |user| user.id.should_not == nil; "uid=#{user.login}"}
     end
-    
-    after(:each) do
-      DataMapper.repository(adapter) do
-        @user1.destroy
-        @user2.destroy
-        @user3.destroy
-      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
-
-      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 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 with empty result' do
+    DataMapper.repository(:ldap) do
+      User.all(:name => "blablublo").should == []
     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 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 a range of values' do
-    #  User.all(:age => 25..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 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 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(: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
+  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 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 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
         User.get(@user1.id).age.should be_nil
         @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
+  if DataMapper.repository(:ldap).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
-
-      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
+
+\