goz 0.0.3 → 0.1.0

data/lib/goz/group/test_case.rb

@@ -0,0 +1,200 @@
+# encoding: utf-8
+
+require 'goz/test_case'
+
+
+module  Goz   # :nodoc:
+  class Group # :nodoc 
+
+    # 
+    # = Goz::Group::TestCase - Goz group test case.
+    #   
+    # == Author
+    #
+    # blair christensen. <mailto:blair.christensen@gmail.com>
+    #
+    # == Homepage
+    #
+    # https://github.com/blairc/goz/
+    #
+    class TestCase < Goz::TestCase
+
+      def setup
+        super
+        @klass ||= self.class
+        @skip = @klass == Goz::Group::TestCase
+      end
+
+      def skip?
+        @skip
+      end
+
+
+      def test_default_initialization
+        return if skip?
+
+        blockable = false
+        group      = @klass.new do |g|
+          assert_kind_of @klass, g
+          assert_nil     g.display_name
+          assert_nil     g.identifier
+          assert_nil     g.klass
+          assert_nil     g.name
+          assert_nil     g.created_at
+          assert_nil     g.modified_at
+          assert_nil     g.synchronized_at
+          blockable = true
+        end
+        assert          blockable,  'works as block'
+        assert_kind_of  Goz::Group, group
+        assert_kind_of  @klass,     group unless @klass == Goz::Group
+        assert_kind_of  @klass,     @klass.new
+        assert_nil      group.display_name
+        assert_nil      group.identifier
+        assert_nil      group.klass
+        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
+        return if skip?
+
+        assert_nil @klass.find_by_name @groups[:a][:name]
+      end
+
+      def test_find_by_name_for_group_that_does_exist
+        return if skip?
+        return if @klass == Goz::Group
+        fail("not implemented")
+      end
+
+      def test_create_with_invalid_parameters
+        return if skip?
+
+        assert_raise(RuntimeError, 'invalid display_name') { @klass.create(nil) }
+        assert_raise(RuntimeError, 'invalid display_name') {
+          @klass.create( :identifier => @groups[:a][:identifier],
+                         :klass      => @klass.name,
+                         :name       => @groups[:a][:name]
+                       )
+        }
+        assert_raise(RuntimeError, 'invalid display_name') {
+          @klass.create( :display_name => '',
+                         :identifier   => @groups[:a][:identifier],
+                         :klass        => @klass.name,
+                         :name         => @groups[:a][:name]
+                       )
+        }
+        assert_raise(RuntimeError, 'invalid identifier') {
+          @klass.create( :display_name => @groups[:a][:display_name],
+                         :klass        => @klass.name,
+                         :name         => @groups[:a][:name]
+                       )
+        }
+        assert_raise(RuntimeError, 'invalid identifier') {
+          @klass.create( :display_name => @groups[:a][:display_name],
+                         :identifier   => '',
+                         :klass        => @klass.name,
+                         :name         => @groups[:a][:name]
+                       )
+        }
+        assert_raise(RuntimeError, 'invalid klass') {
+          @klass.create( :display_name => @groups[:a][:display_name],
+                         :identifier   => @groups[:a][:identifier],
+                         :name         => @groups[:a][:name]
+                       )
+        }
+        assert_raise(RuntimeError, 'invalid klass') {
+          @klass.create( :display_name => @groups[:a][:display_name],
+                         :identifier   => @groups[:a][:identifier],
+                         :klass        => '',
+                         :name         => @groups[:a][:name]
+                       )
+        }
+        assert_raise(RuntimeError, 'invalid name') {
+          @klass.create( :display_name => @groups[:a][:display_name],
+                         :identifier   => @groups[:a][:identifier],
+                         :klass        => @klass.name
+                       )
+        }
+        assert_raise(RuntimeError, 'invalid name') {
+          @klass.create( :display_name => @groups[:a][:display_name],
+                         :identifier   => @groups[:a][:identifier],
+                         :klass        => @klass.name,
+                         :name         => ''
+                       )
+        }
+      end
+
+      def test_create
+        return if skip?
+
+        t = Time.now
+        g = @klass.create @groups[:a].merge( :klass => @klass.name )
+        assert_not_nil  g
+        assert_kind_of  @klass,                     g
+        assert_equal    @groups[:a][:display_name], g.display_name
+        assert_equal    @groups[:a][:identifier],   g.identifier
+        assert_equal    @klass.name,                g.klass
+        assert_equal    @groups[:a][:name],         g.name
+        assert_not_nil  g.created_at
+        assert          g.created_at >= t
+      end
+
+      def test_update
+        return if skip?
+
+        g = Goz::Group.create @groups[:a].merge( :klass => @klass.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_sync_with_provider
+       return if skip?
+       return if @klass == Goz::Group
+       fail("not implemented")
+      end
+
+      def test_sync_with_provider_no_admin_or_member_changes
+       return if skip?
+       return if @klass == Goz::Group
+       fail("not implemented")
+      end
+
+      def test_sync_with_provider_add_admin
+       return if skip?
+       return if @klass == Goz::Group
+       fail("not implemented")
+      end
+
+      def test_sync_with_provider_remove_admin
+       return if skip?
+       return if @klass == Goz::Group
+       fail("not implemented")
+      end
+
+      def test_sync_with_provider_add_member
+       return if skip?
+       return if @klass == Goz::Group
+       fail("not implemented")
+      end
+
+      def test_sync_with_provider_remove_member
+       return if skip?
+       return if @klass == Goz::Group
+       fail("not implemented")
+      end
+
+    end
+
+  end
+end
+

data/lib/goz/group_service.rb

@@ -2,8 +2,10 @@
 
 require 'goz/database'
 require 'goz/event'
+require 'goz/logger'
 require 'goz/group_service'
 
+
 module Goz # :nodoc:
  
   # 
@@ -19,20 +21,13 @@ module Goz # :nodoc:
   #
   class GroupService < Sequel::Model
 
+    TAG = self.name
+
     #
     # Synchronize group with external service.
     # 
     def sync(force = false)
-      if force || synchronized_at.nil? || synchronized_at < ( Time.now - ( 1 * 60 * 60 ) ) # XXX
-        # XXX Synchronize group from remote source (if necessary)
-        # XXX Synchronize admins
-        # XXX Synchronize members
-        self.synchronized_at = Time.now
-        self.save
-        Goz::Event.group_service_sync( Group[ self.group_id ], Service[ self.service_id ] )
-        return true
-      end
-      false
+      raise RuntimeError, 'XXX'
     end
 
   end

data/lib/goz/logger.rb

@@ -9,23 +9,7 @@ module Goz # :nodoc:
   #   
   # == Usage
   #
-  #   require 'goz/logger'
-  #
-  #   logger = Goz::Logger.new('MyApp') do |logger|
-  #     logger.debug('block initialization with default logger')
-  #   end
-  #
-  #   logger = Goz::Logger.new('MyApp')
-  #   logger.error('initialization with default logger')
-  #
-  #   logger = Goz::Logger.instance( 'MyApp', ::Logger.new($stdout) ) do |logger|
-  #     logger.fatal('instance initialization with custom logger')
-  #   end
-  #
-  #   logger = Goz::Logger.instance( 'MyApp', ::Logger.new($stdout) )
-  #   logger.info('instance initialization with custom logger')
-  #
-  #   logger.warn('warn example to cover all log severity levels')
+  # TODO
   #
   # == Author
   #
@@ -38,104 +22,89 @@ module Goz # :nodoc:
   class Logger
 
     #
-    # Default logfile to use.
+    # Default log device to use.
     #
-    DEFAULT_LOGFILE = $stdout
-
-    #
-    # Default logger to use.
-    #
-    DEFAULT_LOGGER  = ::Logger.new(DEFAULT_LOGFILE)
-
+    DEFAULT_LOGDEV = $stdout
 
-    @@loggers = {}
-
-
-    #
-    # Create (if necessary) and return Goz::Logger instance.
-    #
-    # Params:
-    # +tag+:: Tag log messages with this +String+.
-    # +logger+:: (optional) Any +::Logger+ compatible class. Defaults to +DEFAULT_LOGGER+.
-    #
-    def self.instance( tag, logger = DEFAULT_LOGGER )
-      key = [ tag, logger ]
-      unless @@loggers.key?(key)
-        @@loggers[key] = self.new(tag, logger)
-      end
-      yield @@loggers[key] if block_given?
-      @@loggers[key]
-    end
+    @@logger = nil
 
-    #
-    # Initialize Goz::Logger
-    #
-    # Params:
-    # +tag+:: Tag log messages with this +String+.
-    # +logger+:: (optional) Any +::Logger+ compatible class. Defaults to +DEFAULT_LOGGER+.
-    #
-    def initialize( tag, logger = DEFAULT_LOGGER )
-      @logger = logger
-      @tag    = tag
-      # TODO Make configurable?
-      @logger.formatter = proc do |severity, datetime, progname, msg|
-        "#{datetime} #{severity} #{tag}: #{msg}\n"
-      end
-      yield self if block_given?
-      self
-    end
 
     #
     # Send +debug+ log message.
     #
     # Params:
+    # +sender+:: +String+ sender of log message.
     # +message+:: +String+ message to send to logger.
     #
-    def debug(message)
-      @logger.debug message
+    def self.debug(sender, message)
+      self.instance.debug "#{sender} - #{message}"
     end
 
     #
     # Send +error+ log message.
     #
     # Params:
+    # +sender+:: +String+ sender of log message.
     # +message+:: +String+ message to send to logger.
     #
-    def error(message)
-      @logger.error message
+    def self.error(sender, message)
+      self.instance.error "#{sender} - #{message}"
     end
 
     #
     # Send +fatal+ log message.
     #
     # Params:
+    # +sender+:: +String+ sender of log message.
     # +message+:: +String+ message to send to logger.
     #
-    def fatal(message)
-      @logger.fatal message
+    def self.fatal(sender, message)
+      self.instance.fatal "#{sender} - #{message}"
     end
 
     #
     # Send info log message.
     #
     # Params:
+    # +sender+:: +String+ sender of log message.
     # +message+:: +String+ message to send to logger.
     #
-    def info(message)
-      @logger.info message
+    def self.info(sender, message)
+      self.instance.info "#{sender} - #{message}"
     end
 
     #
     # Send warn log message.
     #
     # Params:
+    # +sender+:: +String+ sender of log message.
     # +message+:: +String+ message to send to logger.
     #
-    def warn(message)
-      @logger.warn message
+    def self.warn(sender, message)
+      self.instance.warn "#{sender} - #{message}"
+    end
+
+
+    private
+
+    #
+    # Initialize logger.
+    #
+    # Params:
+    # +tag+:: Tag log messages with this +String+.
+    #
+    def self.instance( tag = 'goz', logdev = DEFAULT_LOGDEV )
+      if @@logger.nil?
+        @@logger = ::Logger.new logdev
+        @@logger.formatter = proc do |severity, datetime, progname, msg|
+          "#{datetime} #{severity} #{tag}: #{msg}\n"
+        end
+      end
+      yield @@logger if block_given?
+      @@logger
     end
 
-  end # class Logger
+  end
 
-end # module Goz
+end
 

data/lib/goz/service.rb

@@ -1,7 +1,10 @@
 # encoding: utf-8
 
+require 'active_support/inflector'
 require 'goz/database'
 require 'goz/event'
+require 'goz/group_service'
+require 'goz/logger'
 
 
 module Goz # :nodoc:
@@ -31,18 +34,11 @@ module Goz # :nodoc:
                   :right_key    => :group_id,
                   :join_table   => :group_services,
                   :class        => :'Goz::Group',
-                  :after_add    => proc { |s, g| Goz::Event.group_service_add(g, s) },
-                  :after_remove => proc { |s, g| Goz::Event.group_service_remove(g, s) }
+                  :after_add    => proc { |s, g| Goz::Group.after_add_service g, s    },
+                  :after_remove => proc { |s, g| Goz::Event.after_remove_service g, s }
 
-    #
-    # Initialize new (non-persistent) Goz::Event object
-    #
-    def initialize(*params)
-      super
-      yield self if block_given?
-      self
-    end
 
+    TAG = self.name
 
     #
     # Compare equality.
@@ -59,41 +55,65 @@ module Goz # :nodoc:
       end
     end
 
-    #
-    # Create Goz::Service or raise +RuntimeError+
-    #
-    def self.create( params = {} )
-      params = {} unless params.kind_of?(Hash)
-      [ :name, :klass ].each do |k|
-        raise( "invalid #{k.to_s}" ) if ( params[k].nil? || params[k].empty? )
+    # XXX
+    def configuration( configuration = {} )
+      klass_instance.configuration configuration
+    end
+
+    def klass_instance
+      unless @k
+        require self.klass.underscore
+        @k = self.klass.constantize
       end
-      super
+      return @k
+    end
+
+    # XXX
+    def create(g)
+      Goz::Logger.debug TAG, "#create( group.name=#{g.name} )"
+      klass_instance.create g
+    end
+
+    def destroy(g)
+      Goz::Logger.debug TAG, "#destroy( group.name=#{g.name} )"
+      klass_instance.destroy g
+    end
+
+    def to_s
+      "name=#{ self.name } klass=#{ self.klass }"
     end
 
     #
     # Find Goz::Service by name or return +nil+
     #
     def self.find_by_name(name)
-      self.find( :name => name )
+      Goz::Logger.debug TAG, "find_by_name( name=#{name} )"
+      self.find :name => name
     end
 
     #
     # Synchronize service with external data sources (if relevant).
     # 
-    def sync(force = false)
-      if force || synchronized_at.nil? || synchronized_at < ( Time.now - ( 1 * 60 * 60 ) ) # XXX
-        # XXX Synchronize service from remote source (if necessary)
-        # XXX Synchronize groups
-        # XXX Synchronize group admins
-        # XXX Synchronize group members
-        self.synchronized_at = Time.now
-        self.save
-        Goz::Event.service_sync(self)
+    def sync_group(g) # XXX
+      Goz::Logger.debug TAG, "#sync_group( group.name=#{g.name} )"
+      if klass_instance.sync_group g, self
+        self.synchronized_at = Time.now # TODO GroupService
+        self.save                       # TODO GroupService
+        Goz::Event.service_sync(self)   # TODO GroupService
         return true
       end
       false
     end
 
+    def sync(force = false)
+      Goz::Logger.debug TAG, "#sync( force=#{force} )"
+      self.groups.each { |g| self.klass_instance.sync_group g, self }
+      self.synchronized_at = Time.now
+      self.save
+      Goz::Event.service_sync self
+      return true
+    end
+
     #
     # Perform model valiations.
     #
@@ -131,7 +151,7 @@ module Goz # :nodoc:
       self.modified_at = Time.now
     end
 
-  end # class Service
+  end
 
-end # module Goz
+end