goz 0.0.2 → 0.0.3

data/test/test_event_type.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'simplecov'
+SimpleCov.start
+
+require 'goz/test_case'
+
+
+class TestEventType < Goz::TestCase
+
+  def setup
+    super
+
+    @names = %w( admin_add          admin_remove
+                 group_add          group_remove          group_sync
+                 group_service_add  group_service_remove  group_service_sync
+                 member_add         member_remove
+                 service_add        service_remove        service_sync
+                 user_add           user_remove           user_sync
+               )
+  end
+
+
+  def test_event_types
+    Goz::Database.instance { |db| assert_equal 16, db[:event_types].count }
+
+    Goz::EventType.order(:id).each_with_index do |event_type, idx|
+      assert_kind_of  Goz::EventType, event_type
+      assert_equal    @names[idx],    event_type.name
+    end
+  end
+
+  def test_event_types_hash
+    assert_equal 16, Goz::EventType::TYPES.size
+    @names.each_with_index do |name, idx|
+      assert_not_nil  Goz::EventType::TYPES[name]
+      assert_equal    Goz::EventType::TYPES[name], idx + 1
+
+      assert_not_nil  Goz::EventType.const_get( name.upcase.to_s )
+      assert_equal    Goz::EventType.const_get( name.upcase.to_s ), idx + 1
+
+      assert_equal    Goz::EventType::TYPES[name],  Goz::EventType.const_get( name.upcase.to_s )
+    end
+  end
+
+end
+

data/test/test_goz.rb

@@ -4,13 +4,18 @@ require 'simplecov'
 SimpleCov.start
 
 require 'goz'
-require 'test/unit'
+require 'goz/test_case'
 
 
-class TestGoz < Test::Unit::TestCase
+class TestGoz < Goz::TestCase
+
+  def setup
+    super
+  end
+
 
   def test_version
-    assert_equal  '0.0.2',  Goz::VERSION
+    assert_equal  '0.0.3',  Goz::VERSION
   end
 
 end

data/test/test_group.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+require 'simplecov'
+SimpleCov.start
+
+require 'goz/group'
+require 'goz/test_case'
+
+
+class TestGroup < Goz::TestCase
+
+  def setup
+    super
+
+    @display_name = 'Foo : Bar'                         # XXX
+    @identifier   = 'd3b07384d113edec49eaa6238ad5ff00'  # XXX
+    @name         = 'foo:bar'                           # XXX
+  end
+
+
+  def test_default_initialization
+    blockable = false
+    group      = Goz::Group.new do |group|
+      assert_kind_of  Goz::Group, group
+      assert_nil      group.display_name
+      assert_nil      group.identifier
+      assert_nil      group.name
+      assert_nil      group.created_at
+      assert_nil      group.modified_at
+      assert_nil      group.synchronized_at
+      blockable = true
+    end
+    assert          blockable,  'works as block'
+    assert_kind_of  Goz::Group,  group
+    assert_kind_of  Goz::Group,  Goz::Group.new
+    assert_nil      group.display_name
+    assert_nil      group.identifier
+    assert_nil      group.name
+    assert_nil      group.created_at
+    assert_nil      group.modified_at
+    assert_nil      group.synchronized_at
+  end
+
+  def test_find_by_name_for_group_that_does_not_exist
+    assert_nil Goz::Group.find_by_name @groups[:a][:name]
+  end
+
+  def test_create_with_invalid_parameters
+    assert_raise(RuntimeError, 'invalid display_name') { Goz::Group.create(nil) }
+    assert_raise(RuntimeError, 'invalid display_name') {
+      Goz::Group.create( :identifier  => @identifier,
+                         :name        => @name
+                       )
+    }
+    assert_raise(RuntimeError, 'invalid display_name') {
+      Goz::Group.create( :display_name  => '',
+                         :identifier    => @identifier,
+                         :name          => @name
+                       )
+    }
+    assert_raise(RuntimeError, 'invalid identifier') {
+      Goz::Group.create( :display_name  => @display_name,
+                         :name          => @name
+                       )
+    }
+    assert_raise(RuntimeError, 'invalid identifier') {
+      Goz::Group.create( :display_name  => @display_name,
+                         :identifier    => '',
+                         :name          => @name
+                       )
+    }
+    assert_raise(RuntimeError, 'invalid name') {
+      Goz::Group.create( :display_name  => @display_name,
+                         :identifier    => @identifier
+                       )
+    }
+    assert_raise(RuntimeError, 'invalid name') {
+      Goz::Group.create( :display_name  => @display_name,
+                         :identifier    => @identifier,
+                         :name          => ''
+                       )
+    }
+  end
+
+  def test_create
+    t = Time.now
+    g = Goz::Group.create( :display_name  => @display_name,
+                           :identifier    => @identifier,
+                           :name          => @name
+                         )
+    assert_not_nil  g
+    assert_kind_of  Goz::Group,     g
+    assert_equal    @display_name,  g.display_name
+    assert_equal    @identifier,    g.identifier
+    assert_equal    @name,          g.name
+    assert_not_nil  g.created_at
+    assert          g.created_at >= t
+  end
+
+  def test_update
+    g = Goz::Group.create( :display_name  => @display_name,
+                           :identifier    => @identifier,
+                           :name          => @name
+                         )
+    g.name = g.name.reverse
+    g.save
+
+    assert_not_nil  g.modified_at
+    assert_kind_of  Time, g.modified_at
+    assert          g.modified_at > g.created_at
+ 
+    assert_nil g.synchronized_at
+  end
+
+  def test_equality
+    g1 = Goz::Group.create( :display_name => @display_name,
+                            :identifier   => @identifier,
+                            :name         => @name
+                          )
+    assert_not_nil  g1
+
+    g2  = Goz::Group.find_by_name( g1.name )
+    assert_not_nil  g2
+    assert_equal    g1, g2
+
+    g3 = Goz::Group.create( :display_name => @display_name.reverse,
+                            :identifier   => @identifier.reverse,
+                            :name         => @name.reverse
+                          )
+    assert_not_nil    g3
+    assert_not_equal  g1, g3
+    assert_not_equal  g2, g3
+  end
+
+  def test_find_by_name_and_persistence
+    g1 = Goz::Group.find_by_name(@name)
+    assert_nil  g1
+
+    g1 = Goz::Group.create( :display_name => @display_name,
+                            :identifier   => @identifier,
+                            :name         => @name
+                          )
+
+    g2 = Goz::Group.find_by_name(@name)
+    assert_not_nil  g2
+    assert_kind_of  Goz::Group, g2
+    assert_equal    g1,         g2
+  end
+
+  def test_sync
+    g = Goz::Group.create @groups[:a]
+    assert_nil g.synchronized_at
+
+    t = Time.now
+    assert          g.sync
+
+    assert_not_nil  g.modified_at
+    assert          g.modified_at > t
+    assert_not_nil  g.synchronized_at
+    assert          g.synchronized_at > t
+
+    t = Time.now
+    assert          !g.sync
+
+    assert_not_nil  g.modified_at
+    assert          g.modified_at < t
+    assert_not_nil  g.synchronized_at
+    assert          g.synchronized_at < t
+
+    t = Time.now
+    assert          g.sync(true)
+
+    assert_not_nil  g.modified_at
+    assert          g.modified_at > t
+    assert_not_nil  g.synchronized_at
+    assert          g.synchronized_at > t
+  end
+
+end
+

data/test/test_group_services.rb

@@ -0,0 +1,241 @@
+# encoding: utf-8
+
+require 'simplecov'
+SimpleCov.start
+
+require 'goz/group'
+require 'goz/group_service'
+require 'goz/test_case'
+require 'goz/service'
+
+
+class TestGroupService < Goz::TestCase
+
+  def setup
+    super
+  end
+
+
+  def test_no_group_services
+    Goz::Database.instance { |db| assert_equal 0, db[:group_services].count }
+    [ :a, :b ].each do |sym|
+      g = Goz::Group.create @groups[sym]
+      assert_not_nil  g.services
+      assert_kind_of  Array,      g.services
+      assert_equal    0,          g.services.size
+
+      s = Goz::Service.create @services[sym]
+      assert_not_nil  s.groups
+      assert_kind_of  Array,      s.groups
+      assert_equal    0,          s.groups.size
+    end
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+  end
+
+  def test_add_group_to_service
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+
+    g = Goz::Group.create( @groups[:a] )
+    s = Goz::Service.create( @services[:a] )
+
+    s.add_group(g)
+    s.save
+
+    assert_equal  1,  g.services.size 
+    assert_equal  s,  g.services.first
+    assert_equal  1,  s.groups.size
+    assert_equal  g,  s.groups.first
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:group_services].count
+      first = db[:group_services].first
+      assert_equal  g.id, first[:group_id]
+      assert_equal  s.id, first[:service_id]
+    end
+  end
+
+  def test_add_service_to_group
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+
+    g = Goz::Group.create( @groups[:a] )
+    s = Goz::Service.create( @services[:a] )
+
+    g.add_service(s)
+    g.save
+
+    assert_equal  1,  g.services.size 
+    assert_equal  s,  g.services.first
+    assert_equal  1,  s.groups.size
+    assert_equal  g,  s.groups.first
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:group_services].count
+      first = db[:group_services].first
+      assert_equal  g.id, first[:group_id]
+      assert_equal  s.id, first[:service_id]
+    end
+  end
+
+  def test_remove_group_from_service
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+
+    g = Goz::Group.create( @groups[:a] )
+    s = Goz::Service.create( @services[:a] )
+
+    s.add_group(g)
+    s.save
+
+    assert_equal  1,  g.services.size 
+    assert_equal  s,  g.services.first
+    assert_equal  1,  s.groups.size
+    assert_equal  g,  s.groups.first
+
+    s.remove_group(g)
+    s.save
+    assert_equal  0,  g.services.size 
+    assert_equal  0,  s.groups.size
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+  end
+
+  def test_remove_service_from_group
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+
+    g = Goz::Group.create( @groups[:a] )
+    s = Goz::Service.create( @services[:a] )
+
+    g.add_service(s)
+    g.save
+
+    assert_equal  1,  g.services.size 
+    assert_equal  s,  g.services.first
+    assert_equal  1,  s.groups.size
+    assert_equal  g,  s.groups.first
+
+    g.remove_service(s)
+    g.save
+    assert_equal  0,  g.services.size 
+    assert_equal  0,  s.groups.size
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+  end
+
+  def test_add_duplicate_group_to_service
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+
+    g = Goz::Group.create( @groups[:a] )
+    s = Goz::Service.create( @services[:a] )
+
+    s.add_group(g)
+    s.save
+
+    assert_equal  1,  g.services.size 
+    assert_equal  s,  g.services.first
+    assert_equal  1,  s.groups.size
+    assert_equal  g,  s.groups.first
+
+    assert_raise(Sequel::DatabaseError) { s.add_group(g) }
+    assert_equal  1,      s.groups.size
+    assert_equal  [ g ],  s.groups
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:group_services].count
+      first = db[:group_services].first
+      assert_equal  g.id, first[:group_id]
+      assert_equal  s.id, first[:service_id]
+    end
+  end
+
+  def test_add_duplicate_service_to_group
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+
+    g = Goz::Group.create( @groups[:a] )
+    s = Goz::Service.create( @services[:a] )
+
+    g.add_service(s)
+    g.save
+
+    assert_equal  1,  g.services.size 
+    assert_equal  s,  g.services.first
+    assert_equal  1,  s.groups.size
+    assert_equal  g,  s.groups.first
+
+    assert_raise(Sequel::DatabaseError) { g.add_service(s) }
+    assert_equal  1,      s.groups.size
+    assert_equal  [ g ],  s.groups
+
+    Goz::Database.instance do |db|
+      assert_equal  1,  db[:group_services].count
+      first = db[:group_services].first
+      assert_equal  g.id, first[:group_id]
+      assert_equal  s.id, first[:service_id]
+    end
+  end
+
+  def test_delete_group
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+    g = Goz::Group.create( @groups[:a] )
+    s = Goz::Service.create( @services[:a] )
+
+    g.add_service(s)
+    g.save
+
+    assert_equal  1,  g.services.size 
+    assert_equal  s,  g.services.first
+    assert_equal  1,  s.groups.size
+    assert_equal  g,  s.groups.first
+
+    g.destroy
+    assert_nil Goz::Group.find_by_name( g.name )
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+
+    s.reload
+    assert_equal [], s.groups
+  end
+
+  def test_delete_service
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+    g = Goz::Group.create( @groups[:a] )
+    s = Goz::Service.create( @services[:a] )
+
+    s.add_group(g)
+    s.save
+
+    assert_equal  1,  g.services.size 
+    assert_equal  s,  g.services.first
+    assert_equal  1,  s.groups.size
+    assert_equal  g,  s.groups.first
+
+    s.destroy
+    assert_nil Goz::Service.find_by_name( s.name )
+    Goz::Database.instance { |db| assert_equal  0, db[:group_services].count }
+
+    g.reload
+    assert_equal [], g.services
+  end
+
+  def test_sync
+    g  = Goz::Group.create @groups[:a]
+    s  = Goz::Service.create @services[:a]
+    g.add_service(s)
+    gs = Goz::GroupService.find( :group_id => g.id, :service_id => s.id )
+    assert_not_nil  gs
+    assert_nil      s.synchronized_at
+
+    t = Time.now
+    assert          gs.sync
+
+    assert_not_nil  gs.synchronized_at
+    assert          gs.synchronized_at > t
+
+    t = Time.now
+    assert          !gs.sync
+
+    assert_not_nil  gs.synchronized_at
+    assert          gs.synchronized_at < t
+
+    t = Time.now
+    assert          gs.sync(true)
+
+    assert_not_nil  gs.synchronized_at
+    assert          gs.synchronized_at > t
+  end
+
+end
+