goz 0.0.3 → 0.1.0

data/test/test_hash_store_cash.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require 'simplecov'
-SimpleCov.start
-
-require 'goz/cache/hash_store'
-require 'goz/test_case'
-
-
-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
-
-  def test_caching
-    key, value = :foo, :bar
-
-    assert_equal  false,  @cache.exist?(key)
-    assert_equal  false,  @cache.delete(key)
-
-    assert_equal  value,  @cache.write(key, value)
-    assert_equal  value,  @cache.read(key)
-    assert_equal  true,   @cache.exist?(key)
-    assert_equal  true,   @cache.delete(key)
-    assert_equal  false,  @cache.exist?(key)
-    assert_equal  nil,    @cache.read(key)
-
-    assert_equal  value,  @cache.write(key, value)
-    assert_equal  true,   @cache.exist?(key)
-    assert_equal  true,   @cache.clear
-    assert_equal  false,  @cache.exist?(key)
-  end
-
-end
-

data/test/test_logger.rb

@@ -1,93 +0,0 @@
-# encoding: utf-8
-
-require 'simplecov'
-SimpleCov.start
-
-require 'goz/logger'
-require 'goz/test_case'
-require 'logger'
-require 'stringio'
-
-
-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|
-      assert_kind_of  Goz::Logger, logger
-      blockable = true
-    end
-    assert         blockable,   'works as block'
-    assert_kind_of Goz::Logger, logger
-    assert_kind_of Goz::Logger, Goz::Logger.new(@tag)
-  end
-
-  def test_initialization
-    blockable = false
-    logger = Goz::Logger.new(@tag, @logger) do |logger|
-      assert_kind_of  Goz::Logger, logger
-      blockable = true
-    end
-    assert         blockable,   'works as block'
-    assert_kind_of Goz::Logger, logger
-    assert_kind_of Goz::Logger, Goz::Logger.new(@tag, @logger)
-  end
-
-  def test_default_instance
-    blockable = false
-    logger = Goz::Logger.instance(@tag) do |logger|
-      assert_kind_of  Goz::Logger, logger
-      blockable = true
-    end
-    assert            blockable,    'works as block'
-    assert_kind_of    Goz::Logger,  logger
-    assert_kind_of    Goz::Logger,  Goz::Logger.instance(@tag)
-    assert_equal      logger,       Goz::Logger.instance(@tag)
-    assert_not_equal  logger,       Goz::Logger.instance('foo')
-  end
-
-  def test_instance
-    blockable = false
-    logger = Goz::Logger.instance(@tag, @logger) do |logger|
-      assert_kind_of  Goz::Logger, logger
-      blockable = true
-    end
-    assert            blockable,    'works as block'
-    assert_kind_of    Goz::Logger,  logger
-    assert_kind_of    Goz::Logger,  Goz::Logger.instance(@tag, @logger)
-    assert_equal      logger,       Goz::Logger.instance(@tag, @logger)
-    assert_not_equal  logger,       Goz::Logger.instance('foo')
-  end
-
-  def test_logging_within_block
-    [ :debug, :error, :fatal, :info, :warn ].each do |severity|
-      Goz::Logger.new(@tag, @logger) do |logger|
-        logger.send severity, "this is a #{ severity.to_s } message"
-        @s.rewind
-        rx = %r{^\d{4}\-\d{2}\-\d{2} \d{2}:\d{2}:\d{2} [+-]\d+ #{ severity.to_s.upcase } #{ @tag }: this is a #{ severity.to_s } message$}
-        assert_match rx, @s.readlines.last.chomp
-      end
-    end
-  end
-
-  def test_logging_outside_of_block
-    [ :debug, :error, :fatal, :info, :warn ].each do |severity|
-      logger = Goz::Logger.new(@tag, @logger)
-      logger.send severity, "this is a #{ severity.to_s } message"
-      @s.rewind
-      rx = %r{^\d{4}\-\d{2}\-\d{2} \d{2}:\d{2}:\d{2} [+-]\d+ #{ severity.to_s.upcase } #{ @tag }: this is a #{ severity.to_s } message$}
-      assert_match rx, @s.readlines.join.chomp
-    end
-  end
-
-end
-

data/test/test_members.rb

@@ -1,189 +0,0 @@
-# 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

@@ -1,150 +0,0 @@
-# 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
-