RubyGems - goz - Versions diffs - 0.0.3 → 0.1.0 - Mend

goz 0.0.3 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

data/.gitignore +1 -0
data/HISTORY.rdoc +6 -0
data/README.rdoc +2 -17
data/TODO.md +16 -0
data/goz.gemspec +5 -1
data/lib/goz.rb +9 -25
data/lib/goz/database.rb +10 -0
data/lib/goz/database/migrations.rb +15 -9
data/lib/goz/event.rb +78 -16
data/lib/goz/event_type.rb +4 -4
data/lib/goz/group.rb +121 -44
data/lib/goz/group/base.rb +115 -0
data/lib/goz/group/etc_group.rb +113 -0
data/lib/goz/group/grouper.rb +153 -0
data/lib/goz/group/grouper/stemmed_groups.rb +140 -0
data/lib/goz/group/test_case.rb +200 -0
data/lib/goz/group_service.rb +5 -10
data/lib/goz/logger.rb +41 -72
data/lib/goz/service.rb +50 -30
data/lib/goz/service/base.rb +43 -0
data/lib/goz/service/fake_service.rb +81 -0
data/lib/goz/test_case.rb +26 -14
data/lib/goz/user.rb +98 -37
data/lib/goz/user/base.rb +81 -0
data/lib/goz/user/etc_passwd.rb +56 -0
data/lib/goz/user/ldap.rb +112 -0
data/lib/goz/user/test_case.rb +55 -0
data/lib/goz/version.rb +1 -1
metadata +89 -45
data/lib/goz/cache.rb +0 -136
data/lib/goz/cache/hash_store.rb +0 -75
data/test/test_admins.rb +0 -189
data/test/test_cache.rb +0 -90
data/test/test_event.rb +0 -576
data/test/test_event_type.rb +0 -47
data/test/test_goz.rb +0 -22
data/test/test_group.rb +0 -180
data/test/test_group_services.rb +0 -241
data/test/test_hash_store_cash.rb +0 -42
data/test/test_logger.rb +0 -93
data/test/test_members.rb +0 -189
data/test/test_service.rb +0 -150
data/test/test_user.rb +0 -205

data/test/test_event.rb DELETED Viewed

@@ -1,576 +0,0 @@
-# encoding: utf-8
-require 'simplecov'
-SimpleCov.start
-require 'goz/event'
-require 'goz/test_case'
-require 'goz/user'
-class TestEvent < Goz::TestCase
-  def setup
-    super
-  end
-  def test_no_events
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-  end
-  def test_group_add
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    t = Time.now
-    g = Goz::Group.create( @groups[:a] )
-    Goz::Database.instance do |db|
-      assert_equal  1,  db[:events].count
-      first = db[:events].first
-      assert_not_nil  first
-      assert_not_nil  first[:event_type_id]
-      assert_equal    Goz::EventType::GROUP_ADD,  first[:event_type_id]
-      assert_not_nil  first[:created_at]
-      assert          first[:created_at] > t
-      assert_not_nil  first[:group_id]
-      assert_equal    g.id,                       first[:group_id]
-      assert_nil      first[:service_id]
-      assert_nil      first[:user_id]
-    end
-  end
-  def test_group_remove
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    t = Time.now
-    g.destroy
-    Goz::Database.instance do |db|
-      assert_equal  2,  db[:events].order(:id).count
-      last = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::GROUP_REMOVE, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                         last[:group_id]
-      assert_nil      last[:service_id]
-      assert_nil      last[:user_id]
-    end
-  end
-  def test_group_sync
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    t = Time.now
-    g = Goz::Group.create( @groups[:a] )
-    g.sync(true)
-    Goz::Database.instance do |db|
-      assert_equal  2,  db[:events].count
-      last = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::GROUP_SYNC, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                       last[:group_id]
-      assert_nil      last[:service_id]
-      assert_nil      last[:user_id]
-    end
-  end
-  def test_group_service_sync
-    #skip("TODO")
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    g.sync(true)
-    Goz::Database.instance { |db| assert_equal 2, db[:events].count }
-    t = Time.now
-    s = Goz::Service.create( @services[:a] )
-    g.add_service(s)
-    g.sync(true)
-    Goz::Database.instance do |db|
-      assert_equal  6,  db[:events].count
-      last = db[:events].order(:id).all[-2]
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::GROUP_SERVICE_SYNC, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                               last[:group_id]
-      assert_not_nil  last[:service_id]
-      assert_equal    s.id,                               last[:service_id]
-      assert_nil      last[:user_id]
-    end
-  end
-  def test_service_add
-    Goz::Database.instance { |db| assert_equal  0, db[:services].count }
-    t = Time.now
-    s = Goz::Service.create( @services[:a] )
-    Goz::Database.instance do |db|
-      assert_equal  1,  db[:services].count
-      first = db[:events].first
-      assert_not_nil  first
-      assert_not_nil  first[:event_type_id]
-      assert_equal    Goz::EventType::SERVICE_ADD,  first[:event_type_id]
-      assert_not_nil  first[:created_at]
-      assert          first[:created_at] > t
-      assert_nil      first[:group_id]
-      assert_not_nil  first[:service_id]
-      assert_equal    s.id,                         first[:service_id]
-      assert_nil      first[:user_id]
-    end
-  end
-  def test_service_remove
-    Goz::Database.instance { |db| assert_equal  0, db[:services].count }
-    s = Goz::Service.create( @services[:a] )
-    t = Time.now
-    s.destroy
-    Goz::Database.instance do |db|
-      assert_equal  2,  db[:events].order(:id).count
-      last = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::SERVICE_REMOVE, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_nil      last[:group_id]
-      assert_not_nil  last[:service_id]
-      assert_equal    s.id,                           last[:service_id]
-      assert_nil      last[:user_id]
-    end
-  end
-  def test_service_sync
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    t = Time.now
-    s = Goz::Service.create( @services[:a] )
-    s.sync(true)
-    Goz::Database.instance do |db|
-      assert_equal  2,  db[:events].count
-      last = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::SERVICE_SYNC, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_nil      last[:group_id]
-      assert_not_nil  last[:service_id]
-      assert_equal    s.id,                         last[:service_id]
-      assert_nil      last[:user_id]
-    end
-  end
-  def test_user_add
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    t = Time.now
-    u = Goz::User.create( @users[:a] )
-    Goz::Database.instance do |db|
-      assert_equal  1,  db[:events].count
-      first = db[:events].first
-      assert_not_nil  first
-      assert_not_nil  first[:event_type_id]
-      assert_equal    Goz::EventType::USER_ADD, first[:event_type_id]
-      assert_not_nil  first[:created_at]
-      assert          first[:created_at] > t
-      assert_nil      first[:group_id]
-      assert_nil      first[:service_id]
-      assert_not_nil  first[:user_id]
-      assert_equal    u.id,                     first[:user_id]
-    end
-  end
-  def test_user_sync
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    t = Time.now
-    u = Goz::User.create( @users[:a] )
-    u.sync(true)
-    Goz::Database.instance do |db|
-      assert_equal  2,  db[:events].count
-      last = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::USER_SYNC,  last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_nil      last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                       last[:user_id]
-    end
-  end
-  def test_user_remove
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    u = Goz::User.create( @users[:a] )
-    t = Time.now
-    u.destroy
-    Goz::Database.instance do |db|
-      assert_equal  2,  db[:events].order(:id).count
-      last = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::USER_REMOVE,  last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_nil      last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                         last[:user_id]
-    end
-  end
-  def test_add_admin_to_group
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    u = Goz::User.create( @users[:a] )
-    t = Time.now
-    g.add_admin(u)
-    g.save
-    Goz::Database.instance do |db|
-      assert_equal  3,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::ADMIN_ADD,  last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                       last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                       last[:user_id]
-    end
-  end
-  def test_add_group_to_admin
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    u = Goz::User.create( @users[:a] )
-    t = Time.now
-    u.add_group(g)
-    u.save
-    Goz::Database.instance do |db|
-      assert_equal  3,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::ADMIN_ADD,  last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                       last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                       last[:user_id]
-    end
-  end
-  def test_remove_admin_from_group
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    u = Goz::User.create( @users[:a] )
-    g.add_admin(u)
-    g.save
-    t = Time.now
-    g.remove_admin(u)
-    g.save
-    Goz::Database.instance do |db|
-      assert_equal  4,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::ADMIN_REMOVE, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                         last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                         last[:user_id]
-    end
-  end
-  def test_remove_group_from_admin
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    u = Goz::User.create( @users[:a] )
-    u.add_group(g)
-    u.save
-    t = Time.now
-    u.remove_group(g)
-    u.save
-    Goz::Database.instance do |db|
-      assert_equal  4,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::ADMIN_REMOVE, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                         last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                         last[:user_id]
-    end
-  end
-  def test_add_group_to_member
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    u = Goz::User.create( @users[:a] )
-    t = Time.now
-    u.add_membership(g)
-    u.save
-    Goz::Database.instance do |db|
-      assert_equal  3,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::MEMBER_ADD, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                       last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                       last[:user_id]
-    end
-  end
-  def test_add_member_to_group
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    u = Goz::User.create( @users[:a] )
-    t = Time.now
-    g.add_member(u)
-    g.save
-    Goz::Database.instance do |db|
-      assert_equal  3,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::MEMBER_ADD, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                       last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                       last[:user_id]
-    end
-  end
-  def test_remove_group_from_member
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    u = Goz::User.create( @users[:a] )
-    u.add_membership(g)
-    u.save
-    t = Time.now
-    u.remove_membership(g)
-    u.save
-    Goz::Database.instance do |db|
-      assert_equal  4,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::MEMBER_REMOVE,  last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                           last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                           last[:user_id]
-    end
-  end
-  def test_remove_member_from_group
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    u = Goz::User.create( @users[:a] )
-    g.add_member(u)
-    g.save
-    t = Time.now
-    g.remove_member(u)
-    g.save
-    Goz::Database.instance do |db|
-      assert_equal  4,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::MEMBER_REMOVE,  last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                           last[:group_id]
-      assert_nil      last[:service_id]
-      assert_not_nil  last[:user_id]
-      assert_equal    u.id,                           last[:user_id]
-    end
-  end
-  def test_add_group_to_service
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    s = Goz::Service.create( @services[:a] )
-    t = Time.now
-    s.add_group(g)
-    s.save
-    Goz::Database.instance do |db|
-      assert_equal  3,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::GROUP_SERVICE_ADD,  last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                       last[:group_id]
-      assert_not_nil  last[:service_id]
-      assert_equal    s.id,                       last[:service_id]
-      assert_nil      last[:user_id]
-    end
-  end
-  def test_add_service_to_group
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    s = Goz::Service.create( @services[:a] )
-    t = Time.now
-    g.add_service(s)
-    g.save
-    Goz::Database.instance do |db|
-      assert_equal  3,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::GROUP_SERVICE_ADD,  last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                       last[:group_id]
-      assert_not_nil  last[:service_id]
-      assert_equal    s.id,                       last[:service_id]
-      assert_nil      last[:user_id]
-    end
-  end
-  def test_remove_group_from_service
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    s = Goz::Service.create( @services[:a] )
-    s.add_group(g)
-    s.save
-    t = Time.now
-    s.remove_group(g)
-    s.save
-    Goz::Database.instance do |db|
-      assert_equal  4,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::GROUP_SERVICE_REMOVE, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                                 last[:group_id]
-      assert_not_nil  last[:service_id]
-      assert_equal    s.id,                                 last[:service_id]
-      assert_nil      last[:user_id]
-    end
-  end
-  def test_remove_service_from_group
-    Goz::Database.instance { |db| assert_equal  0, db[:events].count }
-    g = Goz::Group.create( @groups[:a] )
-    s = Goz::Service.create( @services[:a] )
-    g.add_service(s)
-    g.save
-    t = Time.now
-    g.remove_service(s)
-    g.save
-    Goz::Database.instance do |db|
-      assert_equal  4,  db[:events].count
-      last  = db[:events].order(:id).last
-      assert_not_nil  last
-      assert_not_nil  last[:event_type_id]
-      assert_equal    Goz::EventType::GROUP_SERVICE_REMOVE, last[:event_type_id]
-      assert_not_nil  last[:created_at]
-      assert          last[:created_at] > t
-      assert_not_nil  last[:group_id]
-      assert_equal    g.id,                                 last[:group_id]
-      assert_not_nil  last[:service_id]
-      assert_equal    s.id,                                 last[:service_id]
-      assert_nil      last[:user_id]
-    end
-  end
-end