goz 0.0.2 → 0.0.3

data/test/{test_goz_cache_hash_store.rb → test_hash_store_cash.rb}

@@ -4,15 +4,17 @@ require 'simplecov'
 SimpleCov.start
 
 require 'goz/cache/hash_store'
-require 'test/unit'
+require 'goz/test_case'
 
 
-class TestGozCacheHashStore < Test::Unit::TestCase
+class TestHashStoreCache < Goz::TestCase
 
   def setup
+    super
     @cache = Goz::Cache::HashStore.new
   end
 
+
   def test_default_initialization
     assert_kind_of Goz::Cache::HashStore, @cache
   end

data/test/{test_goz_logger.rb → test_logger.rb}

@@ -4,19 +4,22 @@ require 'simplecov'
 SimpleCov.start
 
 require 'goz/logger'
+require 'goz/test_case'
 require 'logger'
 require 'stringio'
-require 'test/unit'
 
 
-class TestGozLogger < Test::Unit::TestCase
+class TestLogger < Goz::TestCase
 
   def setup
+    super
+
     @s      = StringIO.new
     @logger = Logger.new(@s)
     @tag    = self.class.name
   end
 
+
   def test_default_initialization
     blockable = false
     logger = Goz::Logger.new(@tag) do |logger|

data/test/test_members.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+require 'simplecov'
+SimpleCov.start
+
+require 'goz/group'
+require 'goz/test_case'
+require 'goz/user'
+
+
+class TestMembers < Goz::TestCase
+
+  def setup
+    super
+
+    @u1 = Goz::User.create( :email => 'u1', :login => 'u1', :identifier => 'u1', :name => 'u1' )
+    @u2 = Goz::User.create( :email => 'u2', :login => 'u2', :identifier => 'u2', :name => 'u2' )
+    @g1 = Goz::Group.create( :display_name => 'g1', :identifier => 'g1', :name => 'g1' )
+    @g2 = Goz::Group.create( :display_name => 'g2', :identifier => 'g2', :name => 'g2' )
+  end
+
+
+  def test_no_members_or_memberships
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+    [ @u1, @u2 ].each do |u|
+      assert_not_nil  u.memberships
+      assert_kind_of  Array,    u.memberships
+      assert_equal    0,        u.memberships.size
+    end
+    [ @g1, @g2 ].each do |g|
+      assert_not_nil  g.members
+      assert_kind_of  Array,    g.members
+      assert_equal    0,        g.members.size
+    end
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+  end
+
+  def test_add_member_to_group
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+    @g1.add_member(@u1)
+    @g1.save
+    assert_equal  1,    @g1.members.size
+    assert_equal  0,    @g2.members.size
+    assert_equal  @u1,  @g1.members.first
+    assert_nil          @g2.members.first
+    assert_equal  1,    @u1.memberships.size
+    assert_equal  0,    @u2.memberships.size
+    assert_equal  @g1,  @u1.memberships.first
+    assert_nil          @u2.memberships.first
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:members].count
+      first = db[:members].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_add_membership_to_user
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+    @u1.add_membership(@g1)
+    @u1.save
+    assert_equal  1,    @g1.members.size
+    assert_equal  0,    @g2.members.size
+    assert_equal  @u1,  @g1.members.first
+    assert_nil          @g2.members.first
+    assert_equal  1,    @u1.memberships.size
+    assert_equal  0,    @u2.memberships.size
+    assert_equal  @g1,  @u1.memberships.first
+    assert_nil          @u2.memberships.first
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:members].count
+      first = db[:members].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_remove_member_from_group
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+    @g1.add_member(@u1)
+    @g1.add_member(@u2)
+    @g1.save
+    assert_equal  2,            @g1.members.size
+    assert_equal  [ @u1, @u2 ], @g1.members
+
+    @g1.remove_member(@u2)
+    @g1.save
+    assert_equal  1,        @g1.members.size
+    assert_equal  [ @u1 ],  @g1.members
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:members].count
+      first = db[:members].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_remove_membership_from_user
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+    @u1.add_membership(@g1)
+    @u1.add_membership(@g2)
+    @u1.save
+    assert_equal  2,            @u1.memberships.size
+    assert_equal  [ @g1, @g2 ], @u1.memberships
+
+    @u1.remove_membership(@g2)
+    @u1.save
+    assert_equal  1,        @u1.memberships.size
+    assert_equal  [ @g1 ],  @u1.memberships
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:members].count
+      first = db[:members].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_add_duplicate_member_to_group
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+    @g1.add_member(@u1)
+    @g1.save
+    assert_equal  1,        @g1.members.size
+    assert_equal  [ @u1 ],  @g1.members
+
+    assert_raise(Sequel::DatabaseError) { @g1.add_member(@u1) }
+    assert_equal  1,        @g1.members.size
+    assert_equal  [ @u1 ],  @g1.members
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:members].count
+      first = db[:members].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_add_duplicate_membership_to_user
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+    @u1.add_membership(@g1)
+    @u1.save
+    assert_equal  1,        @u1.memberships.size
+    assert_equal  [ @g1 ],  @u1.memberships
+
+    assert_raise(Sequel::DatabaseError) { @u1.add_membership(@g1) }
+    assert_equal  1,        @u1.memberships.size
+    assert_equal  [ @g1 ],  @u1.memberships
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:members].count
+      first = db[:members].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_delete_group
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+    @g1.add_member(@u1)
+    @g1.save
+    assert_equal  1,        @g1.members.size
+    assert_equal  [ @u1 ],  @g1.members
+
+    @g1.destroy
+    assert_nil  Goz::Group.find_by_name( @g1.name )
+
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+
+    assert_equal  [], @u1.memberships
+  end
+
+  def test_delete_user
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+    @u1.add_membership(@g1)
+    @u1.save
+    assert_equal  1,        @u1.memberships.size
+    assert_equal  [ @g1 ],  @u1.memberships
+
+    @u1.destroy
+    assert_nil  Goz::User.find_by_login( @u1.login )
+
+    Goz::Database.instance { |db| assert_equal  0, db[:members].count }
+
+    assert_equal  [], @g1.members
+  end
+
+end
+

data/test/test_service.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+
+require 'simplecov'
+SimpleCov.start
+
+require 'goz/service'
+require 'goz/test_case'
+
+
+class TestService < Goz::TestCase
+
+  def setup
+    super
+  end
+
+
+  def test_no_services
+    Goz::Database.instance { |db| assert_equal  0, db[:services].count }
+  end
+
+  def test_default_initialization
+    blockable = false
+    service    = Goz::Service.new do |s|
+      assert_kind_of  Goz::Service, s
+      assert_nil      s.name
+      assert_nil      s.klass
+      assert_nil      s.created_at
+      assert_nil      s.modified_at
+      assert_nil      s.synchronized_at
+      blockable = true
+    end
+    assert          blockable,  'works as block'
+    assert_kind_of  Goz::Service, service
+    assert_kind_of  Goz::Service, Goz::Service.new
+    assert_nil      service.name
+    assert_nil      service.klass
+    assert_nil      service.created_at
+    assert_nil      service.modified_at
+    assert_nil      service.synchronized_at
+  end
+
+  def test_find_by_name_for_service_that_does_not_exist
+    assert_nil Goz::Service.find_by_name( @services[:a][:name] )
+  end
+
+  def test_create_with_invalid_parameters
+    assert_raise(RuntimeError, 'invalid name') { Goz::Service.create(nil) }
+    assert_raise(RuntimeError, 'invalid name') {
+      Goz::Service.create( :klass => @services[:a][:klass] )
+    }
+    assert_raise(RuntimeError, 'invalid name') {
+      Goz::Service.create( :name  => '',
+                           :klass => @services[:a][:klass]
+                         )
+    }
+    assert_raise(RuntimeError, 'invalid klass') {
+      Goz::Service.create( :name  => @services[:a][:name] )
+    }
+    assert_raise(RuntimeError, 'invalid klass') {
+      Goz::Service.create( :name  => @services[:a][:name],
+                           :klass => nil
+                         )
+    }
+    assert_raise(RuntimeError, 'invalid klass') {
+      Goz::Service.create( :name  => @services[:a][:name],
+                           :klass => ''
+                         )
+    }
+  end
+
+  def test_create
+    t = Time.now
+    s = Goz::Service.create @services[:a]
+    assert_not_nil  s
+    assert_kind_of  Goz::Service,           s
+    assert_equal    @services[:a][:name],   s.name
+    assert_equal    @services[:a][:klass],  s.klass
+    assert_not_nil  s.created_at
+    assert          s.created_at >= t
+  end
+
+  def test_update
+    s = Goz::Service.create @services[:a]
+    s.name = s.name.reverse
+    s.save
+
+    assert_not_nil  s.modified_at
+    assert_kind_of  Time, s.modified_at
+    assert          s.modified_at > s.created_at
+    assert_nil      s.synchronized_at
+  end
+
+  def test_equality
+    s1 = Goz::Service.create @services[:a]
+    assert_not_nil  s1
+
+    s2  = Goz::Service.find_by_name( s1.name )
+    assert_not_nil  s2
+    assert_equal    s1, s2
+
+    s3 = Goz::Service.create @services[:b]
+
+    assert_not_nil    s3
+    assert_not_equal  s1, s3
+    assert_not_equal  s2, s3
+  end
+
+  def test_find_by_name_and_persistence
+    assert_nil Goz::Service.find_by_name @services[:a][:name]
+
+    s1 = Goz::Service.create @services[:a]
+    assert_not_nil s1
+
+    s2 = Goz::Service.find_by_name s1.name
+    assert_not_nil  s2
+    assert_kind_of  Goz::Service, s2
+    assert_equal    s1,           s2
+  end
+
+  def test_sync
+    s = Goz::Service.create @services[:a]
+    assert_nil s.synchronized_at
+
+    t = Time.now
+    assert          s.sync
+
+    assert_not_nil  s.modified_at
+    assert          s.modified_at > t
+    assert_not_nil  s.synchronized_at
+    assert          s.synchronized_at > t
+
+    t = Time.now
+    assert          !s.sync
+
+    assert_not_nil  s.modified_at
+    assert          s.modified_at < t
+    assert_not_nil  s.synchronized_at
+    assert          s.synchronized_at < t
+
+    t = Time.now
+    assert          s.sync(true)
+
+    assert_not_nil  s.modified_at
+    assert          s.modified_at > t
+    assert_not_nil  s.synchronized_at
+    assert          s.synchronized_at > t
+  end
+
+end
+

data/test/test_user.rb

@@ -0,0 +1,205 @@
+# encoding: utf-8
+
+require 'simplecov'
+SimpleCov.start
+
+require 'goz/test_case'
+require 'goz/user'
+
+
+class TestUser < Goz::TestCase
+
+  def setup
+    super
+
+    @email      = 'foo@example.org'                   # XXX
+    @login      = 'foo'                               # XXX
+    @identifier = 'd3b07384d113edec49eaa6238ad5ff00'  # XXX
+    @name       = 'Foo User'                          # XXX
+  end
+
+
+  def test_default_initialization
+    blockable = false
+    user      = Goz::User.new do |user|
+      assert_kind_of  Goz::User, user
+      assert_nil      user.email
+      assert_nil      user.login
+      assert_nil      user.identifier
+      assert_nil      user.name
+      assert_nil      user.created_at
+      assert_nil      user.modified_at
+      assert_nil      user.modified_at
+      blockable = true
+    end
+    assert          blockable,  'works as block'
+    assert_kind_of  Goz::User,  user
+    assert_kind_of  Goz::User,  Goz::User.new
+    assert_nil      user.email
+    assert_nil      user.login
+    assert_nil      user.identifier
+    assert_nil      user.name
+    assert_nil      user.created_at
+    assert_nil      user.modified_at
+    assert_nil      user.modified_at
+  end
+
+  def test_find_by_login_for_user_that_does_not_exist
+    assert_nil Goz::User.find_by_login @users[:a][:login]
+  end
+
+  def test_create_with_invalid_parameters
+    assert_raise(RuntimeError, 'invalid email') { Goz::User.create(nil) }
+    assert_raise(RuntimeError, 'invalid email') {
+      Goz::User.create( :identifier => @identifier,
+                        :login      => @login,
+                        :name       => @name
+                      )
+    }
+    assert_raise(RuntimeError, 'invalid email') {
+      Goz::User.create( :email      => '',
+                        :identifier => @identifier,
+                        :login      => @login,
+                        :name       => @name
+                      )
+    }
+    assert_raise(RuntimeError, 'invalid identifier') {
+      Goz::User.create( :email      => @email,
+                        :login      => @login,
+                        :name       => @name
+                      )
+    }
+    assert_raise(RuntimeError, 'invalid identifier') {
+      Goz::User.create( :email      => @email,
+                        :identifier => '',
+                        :login      => @login,
+                        :name       => @name
+                      )
+    }
+    assert_raise(RuntimeError, 'invalid login') {
+      Goz::User.create( :email      => @email,
+                        :identifier => @identifier,
+                        :name       => @name
+                      )
+    }
+    assert_raise(RuntimeError, 'invalid login') {
+      Goz::User.create( :email      => @email,
+                        :identifier => @identifier,
+                        :login      => '',
+                        :name       => @name
+                      )
+    }
+    assert_raise(RuntimeError, 'invalid name') {
+      Goz::User.create( :email      => @email,
+                        :identifier => @identifier,
+                        :login      => @login
+                      )
+    }
+    assert_raise(RuntimeError, 'invalid name') {
+      Goz::User.create( :email      => @email,
+                        :identifier => @identifier,
+                        :login      => @login,
+                        :name       => ''
+                      )
+    }
+  end
+
+  def test_create
+    t = Time.now
+    u = Goz::User.create( :email      => @email,
+                          :identifier => @identifier,
+                          :login      => @login,
+                          :name       => @name
+                        )
+    assert_not_nil  u
+    assert_kind_of  Goz::User,    u
+    assert_equal    @email,       u.email
+    assert_equal    @identifier,  u.identifier
+    assert_equal    @login,       u.login
+    assert_equal    @name,        u.name
+    assert_not_nil  u.created_at
+    assert          u.created_at >= t
+  end
+
+  def test_update
+    u = Goz::User.create( :email      => @email,
+                          :identifier => @identifier,
+                          :login      => @login,
+                          :name       => @name
+                        )
+    u.name = u.name.reverse
+    u.save
+
+    assert_not_nil  u.modified_at
+    assert_kind_of  Time, u.modified_at
+    assert          u.modified_at > u.created_at
+
+    assert_nil u.synchronized_at
+  end
+
+  def test_equality
+    u1 = Goz::User.create( :email       => @email,
+                           :identifier  => @identifier,
+                           :login       => @login,
+                           :name        => @name
+                         )
+    assert_not_nil  u1
+
+    u2  = Goz::User.find_by_login( u1.login )
+    assert_not_nil  u2
+    assert_equal    u1, u2
+
+    u3 = Goz::User.create( :email       => @email.reverse,
+                           :identifier  => @identifier.reverse,
+                           :login       => @login.reverse,
+                           :name        => @name.reverse
+                         )
+    assert_not_nil    u3
+    assert_not_equal  u1, u3
+    assert_not_equal  u2, u3
+  end
+
+  def test_find_by_login_and_persistence
+    u1 = Goz::User.find_by_login(@login)
+    assert_nil  u1
+
+    u1 = Goz::User.create( :email      => @email,
+                           :identifier => @identifier,
+                           :login      => @login,
+                           :name       => @name
+                         )
+
+    u2 = Goz::User.find_by_login(@login)
+    assert_not_nil  u2
+    assert_kind_of  Goz::User,  u2
+    assert_equal    u1,         u2
+  end
+
+  def test_sync
+    u = Goz::User.create @users[:a]
+    assert_nil u.synchronized_at
+
+    t = Time.now
+    assert          u.sync
+    assert_not_nil  u.modified_at
+    assert          u.modified_at.to_f > t.to_f
+    assert_not_nil  u.synchronized_at
+    assert          u.synchronized_at.to_f > t.to_f
+
+    t = Time.now
+    assert          !u.sync
+    assert_not_nil  u.modified_at
+    assert          u.modified_at.to_f < t.to_f
+    assert_not_nil  u.synchronized_at
+    assert          u.synchronized_at.to_f < t.to_f
+
+    t = Time.now
+    assert          u.sync(true)
+    assert_not_nil  u.modified_at
+    assert          u.modified_at.to_f > t.to_f
+    assert_not_nil  u.synchronized_at
+    assert          u.synchronized_at.to_f > t.to_f
+  end
+
+end
+