goz 0.0.2 → 0.0.3

data/lib/goz/version.rb

@@ -5,7 +5,7 @@ module Goz
   #
   # Goz version
   #
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 
 end
 

data/test/test_admins.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+require 'simplecov'
+SimpleCov.start
+
+require 'goz/group'
+require 'goz/test_case'
+require 'goz/user'
+
+
+class TestAdmins < 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_admins_or_groups
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+    [ @u1, @u2 ].each do |u|
+      assert_not_nil  u.groups
+      assert_kind_of  Array,    u.groups
+      assert_equal    0,        u.groups.size
+    end
+    [ @g1, @g2 ].each do |g|
+      assert_not_nil  g.admins
+      assert_kind_of  Array,    g.admins
+      assert_equal    0,        g.admins.size
+    end
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+  end
+
+  def test_add_admin_to_group
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+    @g1.add_admin(@u1)
+    @g1.save
+    assert_equal  1,    @g1.admins.size
+    assert_equal  0,    @g2.admins.size
+    assert_equal  @u1,  @g1.admins.first
+    assert_nil          @g2.admins.first
+    assert_equal  1,    @u1.groups.size
+    assert_equal  0,    @u2.groups.size
+    assert_equal  @g1,  @u1.groups.first
+    assert_nil          @u2.groups.first
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:admins].count
+      first = db[:admins].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_add_group_to_admin
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+    @u1.add_group(@g1)
+    @u1.save
+    assert_equal  1,    @g1.admins.size
+    assert_equal  0,    @g2.admins.size
+    assert_equal  @u1,  @g1.admins.first
+    assert_nil          @g2.admins.first
+    assert_equal  1,    @u1.groups.size
+    assert_equal  0,    @u2.groups.size
+    assert_equal  @g1,  @u1.groups.first
+    assert_nil          @u2.groups.first
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:admins].count
+      first = db[:admins].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_remove_admin_from_group
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+    @g1.add_admin(@u1)
+    @g1.add_admin(@u2)
+    @g1.save
+    assert_equal  2,            @g1.admins.size
+    assert_equal  [ @u1, @u2 ], @g1.admins
+
+    @g1.remove_admin(@u2)
+    @g1.save
+    assert_equal  1,        @g1.admins.size
+    assert_equal  [ @u1 ],  @g1.admins
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:admins].count
+      first = db[:admins].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_remove_group_from_admin
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+    @u1.add_group(@g1)
+    @u1.add_group(@g2)
+    @u1.save
+    assert_equal  2,            @u1.groups.size
+    assert_equal  [ @g1, @g2 ], @u1.groups
+
+    @u1.remove_group(@g2)
+    @u1.save
+    assert_equal  1,        @u1.groups.size
+    assert_equal  [ @g1 ],  @u1.groups
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:admins].count
+      first = db[:admins].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_add_duplicate_admin_to_group
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+    @g1.add_admin(@u1)
+    @g1.save
+    assert_equal  1,        @g1.admins.size
+    assert_equal  [ @u1 ],  @g1.admins
+
+    assert_raise(Sequel::DatabaseError) { @g1.add_admin(@u1) }
+    assert_equal  1,        @g1.admins.size
+    assert_equal  [ @u1 ],  @g1.admins
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:admins].count
+      first = db[:admins].first
+      assert_equal  @g1.id, first[:group_id]
+      assert_equal  @u1.id, first[:user_id]
+    end
+  end
+
+  def test_add_duplicate_group_to_admin
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+    @u1.add_group(@g1)
+    @u1.save
+    assert_equal  1,        @u1.groups.size
+    assert_equal  [ @g1 ],  @u1.groups
+
+    assert_raise(Sequel::DatabaseError) { @u1.add_group(@g1) }
+    assert_equal  1,        @u1.groups.size
+    assert_equal  [ @g1 ],  @u1.groups
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:admins].count
+      first = db[:admins].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[:admins].count }
+    @g1.add_admin(@u1)
+    @g1.save
+    assert_equal  1,        @g1.admins.size
+    assert_equal  [ @u1 ],  @g1.admins
+
+    @g1.destroy
+    assert_nil  Goz::Group.find_by_name( @g1.name )
+
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+
+    assert_equal  [], @u1.groups
+  end
+
+  def test_delete_user
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+    @u1.add_group(@g1)
+    @u1.save
+    assert_equal  1,        @u1.groups.size
+    assert_equal  [ @g1 ],  @u1.groups
+
+    @u1.destroy
+    assert_nil  Goz::User.find_by_login( @u1.login )
+
+    Goz::Database.instance { |db| assert_equal  0, db[:admins].count }
+
+    assert_equal  [], @g1.admins
+  end
+
+end
+

data/test/{test_goz_cache.rb → test_cache.rb}

@@ -4,15 +4,17 @@ require 'simplecov'
 SimpleCov.start
 
 require 'goz/cache'
-require 'test/unit'
+require 'goz/test_case'
 
 
-class TestGozCache < Test::Unit::TestCase
+class TestCache < Goz::TestCase
 
   def setup
+    super
     @cache = Goz::Cache.new
   end
 
+
   def test_default_initialization
     blockable = false
     cache     = Goz::Cache.new do |cache|

data/test/test_event.rb

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