s2container 0.8.0

data/test/seasar/container/test_aspect-info-def.rb

@@ -0,0 +1,85 @@
+require 'seasar/container/s2application-context'
+
+module Seasar
+  module Container
+    class TC_AspectInfoDef < Test::Unit::TestCase
+      def setup
+      end
+
+      def teardown
+      end
+
+      def test_match_regexp
+        cd = ComponentDef.new(A, 'abc')
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => /ab/, :pointcut => nil)
+        assert(info.applicable?(cd))
+
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => /A/, :pointcut => nil)
+        assert(info.applicable?(cd))
+
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => /cde/, :pointcut => nil)
+        assert(!info.applicable?(cd))
+
+        cd = ComponentDef.new(A)
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => /ab/, :pointcut => nil)
+        assert(!info.applicable?(cd))
+      end
+
+      def test_match_class
+        cd = ComponentDef.new(A)
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => A, :pointcut => nil)
+        assert(info.applicable?(cd))
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => B, :pointcut => nil)
+        assert(!info.applicable?(cd))
+
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => A, :pointcut => nil)
+        cd = ComponentDef.new(B)
+        assert(!info.applicable?(cd))
+        cd = ComponentDef.new(A)
+        assert(info.applicable?(cd))
+        cd = ComponentDef.new(C)
+        assert(!info.applicable?(cd))
+      end
+
+      def test_match_module
+        cd = ComponentDef.new(D::A)
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => D, :pointcut => nil)
+        assert(info.applicable?(cd))
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => A, :pointcut => nil)
+        assert(!info.applicable?(cd))
+      end
+
+      def test_match_string
+        cd = ComponentDef.new(A, 'abc')
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => 'abc', :pointcut => nil)
+        assert(info.applicable?(cd))
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => 'c', :pointcut => nil)
+        assert(!info.applicable?(cd))
+
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => A, :pointcut => nil)
+        assert(info.applicable?(cd))
+      end
+
+      def test_match_symbol
+        cd = ComponentDef.new(A, :abc)
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => :abc, :pointcut => nil)
+        assert(info.applicable?(cd))
+        info = AspectInfoDef.new(:interceptor => 'trace', :pattern => :c, :pointcut => nil)
+        assert(!info.applicable?(cd))
+      end
+
+      class A
+      end
+
+      class B < A
+      end
+
+      class C
+      end
+
+      module D
+        class A; end
+      end
+    end
+  end
+end

data/test/seasar/container/test_component-def.rb

@@ -0,0 +1,91 @@
+require 'seasar/container/component-def'
+
+module Seasar
+  module Container
+    class TC_ComponentDef < Test::Unit::TestCase
+      def setup
+      end
+
+      def teardown
+      end
+
+      def test_instantiate
+        cd = Seasar::Container::ComponentDef.new(A, "a")
+        assert_equal(A,   cd.component_class)
+        assert_equal("a", cd.component_name)
+
+        cd = Seasar::Container::ComponentDef.new(A)
+        assert_equal(A,   cd.component_class)
+        assert_equal(:a, cd.component_name)
+      end
+      
+      def test_get_component_deployer
+        cd = Seasar::Container::ComponentDef.new(A, "a")
+        assert_equal(Seasar::Container::Deployer::SingletonComponentDeployer,
+                     cd.get_component_deployer.class)
+      end
+
+      def test_get_concreate_class
+        cd = Seasar::Container::ComponentDef.new(A, "a")
+        assert_equal(A, cd.get_concreate_class)
+      end
+
+      def test_get_component_deployer
+        begin
+          cd = Seasar::Container::ComponentDef.new(A, :a)
+        rescue => e
+          assert(e.instance_of?(TypeError))
+          assert_equal("component name must be String or nil.", e.message)
+        end
+      end
+
+      def test_onetime_proc
+        cd = Seasar::Container::ComponentDef.new(B, "b")
+        cd.onetime_proc = lambda {
+          b = B.new
+          b.name = "abc"
+          b
+        }
+        assert(cd.component.instance_of?(B))
+        assert_equal("abc", cd.component.name)
+      end
+
+      def test_proc_block
+        cd = Seasar::Container::ComponentDef.new(Proc, "b") {
+          next A.new
+        }
+        component = cd.get_component
+        assert(component.instance_of?(Proc))
+        assert(component.call.instance_of?(A))
+      end
+
+      def test_constructor_block
+        cd = Seasar::Container::ComponentDef.new(B, "b") {
+          next B.new
+        }
+        component = cd.get_component
+        assert(component.instance_of?(B))
+
+        cd = Seasar::Container::ComponentDef.new(B, "b") {
+          next A.new
+        }
+        begin
+          component = cd.get_component
+        rescue TypeError => e
+          assert(e.message.match(/^invalid instance found./))
+        end
+      end
+
+      class A
+      end
+
+      class B
+        def initialize
+          @name = "xyz"
+        end
+        attr_accessor :name
+      end
+      
+    end
+  end
+end

data/test/seasar/container/test_component-info-def.rb

@@ -0,0 +1,88 @@
+require 'seasar/container/s2application-context'
+
+module Seasar
+  module Container
+    class TC_ComponentInfoDef < Test::Unit::TestCase
+      def setup
+      end
+
+      def teardown
+      end
+
+      def test_accessor
+        info = ComponentInfoDef.new(:class => A, :name => "abc")
+        assert_equal("abc", info["@component_name"])
+        assert_equal("abc", info[:@component_name])
+      end
+
+      def test_match_regexp
+        info = ComponentInfoDef.new(:class => A, :name => "abc")
+        assert(info.match(/ab/))
+        assert(!info.match(/bcd/))
+        assert(info.match(/A/))
+        assert(info.match(/Seasar/))
+        assert(!info.match(/seasar/))
+
+        info = ComponentInfoDef.new(:class => A)
+        assert(!info.match(/abc/))
+      end
+
+      def test_match_class
+        info = ComponentInfoDef.new(:class => A, :name => "abc")
+        assert(info.match(A))
+        assert(!info.match(B))
+        assert(!info.match(C))
+
+        info = ComponentInfoDef.new(:class => B, :name => "abc")
+        assert(!info.match(A))
+        assert(info.match(B))
+        assert(!info.match(C))
+      end
+
+      def test_match_module
+        info = ComponentInfoDef.new(:class => D::A, :name => "abc")
+        assert(info.match(D))
+        assert(!info.match(A))
+      end
+
+      def test_match_string
+        info = ComponentInfoDef.new(:class => A, :name => "abc")
+        assert(info.match("abc"))
+        assert(!info.match("bcd"))
+
+        info = ComponentInfoDef.new(:class => A)
+        assert(!info.match("abc"))
+        assert(info.match(A))
+      end
+
+      def test_match_symbol
+        info = ComponentInfoDef.new(:class => A, :name => :abc)
+        assert(info.match(:abc))
+        assert(!info.match(:bcd))
+
+        info = ComponentInfoDef.new(:class => A)
+        assert(!info.match(:abc))
+      end
+
+      def test_auto_namespace
+        ComponentInfoDef.auto_namespace = true
+        info = ComponentInfoDef.new(:class => A)
+        assert('Seasar::Container::TC_ComponentInfoDef', info.namespace)
+        ComponentInfoDef.auto_namespace = false
+      end
+
+      class A
+      end
+
+      class B < A
+      end
+
+      class C
+      end
+
+      module D
+        class A; end
+      end
+    end
+  end
+end

data/test/seasar/container/test_s2application-context.rb

@@ -0,0 +1,290 @@
+require 'seasar/container/s2application-context'
+
+module Seasar
+  module Container
+    class TC_S2ApplicationContext < Test::Unit::TestCase
+      def setup
+      end
+
+      def teardown
+      end
+
+      def test_get
+        s2app.init
+        assert_equal(A, s2app.get(A).class)
+        assert_equal(A, s2app.get('a').class)
+        assert_equal(A, s2app.get('foo.a2', 'foo').class)
+        assert_equal(A, s2app.get('foo.bar.a3', 'foo').class)
+        assert_equal(A, s2app.get('a3', 'foo.bar').class)
+        assert_equal(A, s2app.get('a4', 'foo.bar.huga').class)
+        assert_equal(s2app.get('foo.bar.huga'), s2app.get('foo.bar.huga'))
+
+        s2app.init
+        assert_equal(A, s2app[A].class)
+      end
+
+      def test_get_by_symbol
+        s2app.init
+        assert_equal(J, s2app[J].class)
+        assert_equal(J, s2app[:j].class)
+      end
+
+      def test_di
+        s2app.init
+        s2app.register_aspect(:pattern => /b/, :interceptor => Seasar::Aop::Interceptor::TraceInterceptor.new)
+        s2app.get(C).b.foo
+      end
+
+      def test_aspect
+        s2app.register_aspect(:pattern => /b/, :interceptor => Seasar::Aop::Interceptor::TraceInterceptor.new)
+        s2app.get('b').foo
+
+        s2app.init
+        s2app.aspect(:pattern => /b/) {|invocation|
+          puts "before : foo"
+          invocation.proceed
+          puts "after  : foo"
+        }
+        s2app.get('b').foo
+      end
+
+      def test_singleton
+        s2app.init
+        assert(s2app.get(C) == s2app.get(C))
+      end
+
+      def test_prototype
+        s2app.init
+        assert(s2app.get(D) != s2app.get(D))
+      end
+
+      def test_di_none
+        s2app.init
+        assert_equal(s2app.get(E).b, B)
+      end
+
+      def test_zzznamespaced_component
+        s2app.init
+        assert_equal(F, s2app.get(F).class)
+        assert_equal(F, s2app.get(F, 'namespace_f').class)
+        assert_equal(F, s2app.get('namespace_f.f').class)
+      end
+
+      def test_proc_component
+        s2app.init
+        g = s2app[G]
+        assert_equal(G, g.class)
+        assert_equal(10, g.val)
+      end
+
+      def test_onetime_proc
+        s2app.init
+        g = s2app.get(G) {
+          G.new(20)
+        }
+        assert_equal(G, g.class)
+        assert_equal(20, g.val)
+        g = s2app[G]
+        assert_equal(G, g.class)
+        assert_equal(10, g.val)
+      end
+
+      def test_include
+        s2app.init
+        s2app.include(H)
+        container = s2app.create
+        assert(container.has_component_def(H))
+        assert(!container.has_component_def(B))
+      end
+
+      def test_exclude
+        s2app.init
+        s2app.include('hi')
+        container = s2app.create
+        assert(container.has_component_def(H))
+        assert(container.has_component_def(I))
+
+        s2app.init
+        s2app.exclude(I)
+        container = s2app.create
+        assert(container.has_component_def(H))
+        assert(!container.has_component_def(I))
+
+        s2app.init
+        s2app.include('hi')
+        s2app.exclude(I)
+        container = s2app.create
+        assert(container.has_component_def(H))
+        assert(!container.has_component_def(I))
+        assert(!container.has_component_def(B))
+      end
+
+      def test_s2comp
+        begin
+          s2comp
+        rescue => e
+          assert(e.instance_of?(TypeError))
+          assert_equal("class not specified.", e.message)
+        end
+      end
+
+      def test_aspect_error
+        begin
+          s2app.aspect({})
+        rescue => e
+          assert(e.instance_of?(ArgumentError))
+          assert_equal("interceptor not specified.", e.message)
+        end
+      end
+
+      def test_select_by_include
+        s2app.init
+        s2app.include(J)
+        s2app.include(J)
+        s2app.include(J)
+        s2app.include(I)
+        s2app.include(I)
+        s2app.include(I)
+        infos = s2app.select_component_info_by_include(s2app.component_infos)
+        assert_equal(2, infos.size)
+      end
+
+      def test_selectors
+        s2app.init
+        s2app.select {|infos|
+          infos.select {|info| info.component_class == H}
+        }
+        s2app.select {|infos|
+          assert_equal(2, infos.size)
+          infos.select {|info| info.component_name == "h"}
+        }
+        container = s2app.create {|infos|
+          assert_equal(1, infos.size)
+          next infos
+        }
+
+        assert(container.has_component_def(H))
+        assert(!container.has_component_def(B))
+      end
+
+      def test_di_accessor
+        s2app.init
+        assert(s2app.get(K).l.is_a?(L))
+      end
+
+      def test_select_component_info_by_namespace
+        infos = []
+        infos << ComponentInfoDef.new(:namespace => 'a.b.c')
+        infos << ComponentInfoDef.new(:namespace => 'a.b.d')
+        infos << ComponentInfoDef.new(:namespace => 'a.e.f')
+        infos << ComponentInfoDef.new(:namespace => 'x.y.z')
+        assert(2, s2app.select_component_info_by_namespace(infos, %w[a.b]).size)
+        assert(1, s2app.select_component_info_by_namespace(infos, %w[a.e]).size)
+        assert(3, s2app.select_component_info_by_namespace(infos, %w[a]).size)
+        assert(3, s2app.select_component_info_by_namespace(infos, %w[a.b a.e]).size)
+        assert(2, s2app.select_component_info_by_namespace(infos, %w[a.e x.y]).size)
+      end
+
+      def test_create_singleton
+        s2app.init
+        c1 = s2app.create_singleton(%w[a.b a.c])
+        c2 = s2app.create_singleton(%w[a.c a.b])
+        assert(c1 == c2)
+      end
+
+      def test_snapshot
+        s2app.init
+        assert(!s2app.snapshot?)
+        app = s2app.snapshot
+        assert(app.snapshot?)
+        assert_equal(s2app.component_infos, app.component_infos)
+        assert_equal(s2app.aspect_infos, app.aspect_infos)
+        assert_raise(RuntimeError) {app.register('test')}
+        assert_raise(RuntimeError) {app.register_aspect('test')}
+      end
+
+=begin
+      def test_z_reload
+        s2app.init(:force => true)
+        load File.join(File.dirname(__FILE__), 's2app_load_sample.rb')
+        assert_equal(2, s2app.component_infos.size)
+        load File.join(File.dirname(__FILE__), 's2app_load_sample.rb')
+        assert_equal(2, s2app.component_infos.size)
+        exit
+      end
+=end
+      class A
+        s2component :name => 'a'
+        s2component :name => 'a2', :namespace => 'foo'
+        s2component :name => 'a3', :namespace => 'foo.bar'
+        s2component :name => 'a4', :namespace => 'foo.bar.huga'
+        def foo
+          puts "foo called."
+        end
+      end
+
+      class B
+        s2comp :name => 'b'
+        def foo
+          puts "foo called."
+        end
+      end
+
+      class C
+        s2component
+        def initialize
+          @b = B
+        end
+        attr_accessor :b
+      end
+
+      class D
+        s2component :instance => :prototype
+      end
+
+      class E
+        s2component :autobinding => :none
+        def initialize
+          @b = B
+        end
+        attr_accessor :b
+      end
+
+      class F
+        s2component :name => 'f', :namespace => 'namespace_f'
+      end
+
+      class G
+        s2component(:instance => :prototype) {
+          G.new(10)
+        }
+        def initialize(val)
+          @val = val
+        end
+        attr_accessor :val
+      end
+
+      class H
+        s2component :name => 'h'
+        s2component :name => 'hi'
+      end
+
+      class I
+        s2component :name => 'hi'
+      end
+
+      class J
+        s2component :name => :j
+      end
+
+      class K
+        s2component
+        attr_accessor :l
+      end
+
+      class L
+        s2component :name => :l
+      end
+    end
+  end
+end