goz 0.0.3 → 0.1.0

data/test/test_event_type.rb

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

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-require 'simplecov'
-SimpleCov.start
-
-require 'goz'
-require 'goz/test_case'
-
-
-class TestGoz < Goz::TestCase
-
-  def setup
-    super
-  end
-
-
-  def test_version
-    assert_equal  '0.0.3',  Goz::VERSION
-  end
-
-end
-

data/test/test_group.rb

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

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