Removed old test files for Zend/Cloud/Infrastructure

zendframework · Jan 10, 2012 · f52f94e · f52f94e
commit f52f94e
Show file tree

Hide file tree

Showing 11 changed files with 206 additions and 68 deletions.
diff --git a/src/Configuration.php b/src/Configuration.php
@@ -47,8 +47,10 @@ public function configureDefinition(Di $di, $definition)
             switch ($definitionType) {
                 case 'compiler':
                     // @todo
+                    break;
                 case 'runtime':
                     // @todo
+                    break;
                 case 'class':
                     foreach ($definitionData as $className => $classData) {
                         $classDefinitions = $di->definitions()->getDefinitionsByType('Zend\Di\Definition\ClassDefinition');

diff --git a/src/Definition/Builder/InjectionMethod.php b/src/Definition/Builder/InjectionMethod.php
@@ -20,13 +20,13 @@ public function getName()
         return $this->name;
     }
 
-    public function addParameter($name, $class = null, $position = self::PARAMETER_POSTION_NEXT)
+    public function addParameter($name, $class = null, $isRequired = null)
     {
-        if ($position == self::PARAMETER_POSTION_NEXT) {
-            $this->parameters[$name] = $class;
-        } else {
-            throw new \Exception('Implementation for parameter placement is incomplete');
-        }
+        $this->parameters[] = array(
+            $name,
+            $class,
+            ($isRequired == null) ? true : false
+        );
         return $this;
     }
 

diff --git a/src/Definition/BuilderDefinition.php b/src/Definition/BuilderDefinition.php
@@ -218,7 +218,11 @@ public function getMethodParameters($class, $method)
         if (!$method instanceof Builder\InjectionMethod) {
             throw new Exception\RuntimeException('Cannot find method object for method ' . $method . ' in this builder definition.');
         }
-        return $method->getParameters();
+        $methodParameters = array();
+        foreach ($method->getParameters() as $name => $info) {
+            $methodParameters[$class->getName() . '::' . $method->getName() . ':' . $name] = $info;
+        }
+        return $methodParameters;
     }
 
 

diff --git a/src/Definition/ClassDefinition.php b/src/Definition/ClassDefinition.php
@@ -6,7 +6,7 @@ class ClassDefinition implements Definition, PartialMarker
 {
 
     protected $class = null;
-    protected $supertypes = null;
+    protected $supertypes = array();
     protected $instantiator = null;
     protected $methods = array();
     protected $methodParameters = array();

diff --git a/src/Definition/RuntimeDefinition.php b/src/Definition/RuntimeDefinition.php
@@ -225,6 +225,19 @@ protected function processClass($class)
             }
         }
 
+        $rTarget = $rClass;
+        $supertypes = array();
+        do {
+            $supertypes = array_merge($supertypes, $rTarget->getInterfaceNames());
+            if (!($rTargetParent = $rTarget->getParentClass())) {
+                break;
+            }
+            $supertypes[] = $rTargetParent->getName();
+            $rTarget = $rTargetParent;
+        } while (true);
+
+        $def['supertypes'] = $supertypes;
+
         if ($def['instantiator'] == null) {
             if ($rClass->isInstantiable()) {
                 $def['instantiator'] = '__construct';

diff --git a/src/DefinitionList.php b/src/DefinitionList.php
@@ -95,13 +95,13 @@ public function hasClass($class)
 
     public function getClassSupertypes($class)
     {
-        $superTypes = array();
+        $supertypes = array();
         /** @var $definition Definition\Definition */
         foreach ($this as $definition) {
-            $superTypes = array_merge($definition->getClassSupertypes($class), $superTypes);
+            $supertypes = array_merge($supertypes, $definition->getClassSupertypes($class));
         }
         // @todo remove duplicates?
-        return $superTypes;
+        return $supertypes;
     }
 
     public function getInstantiator($class)

diff --git a/src/Di.php b/src/Di.php
diff --git a/test/Definition/BuilderDefinitionTest.php b/test/Definition/BuilderDefinitionTest.php
@@ -36,7 +36,10 @@ public function testBuilderCanBuildClassWithMethods()
         $this->assertTrue($definition->hasMethods('Foo'));
         $this->assertTrue($definition->hasMethod('Foo', 'injectBar'));
         $this->assertContains('injectBar', $definition->getMethods('Foo'));
-        $this->assertEquals(array('bar' => 'Bar'), $definition->getMethodParameters('Foo', 'injectBar'));
+        $this->assertEquals(
+            array('Foo::injectBar:0' => array('bar', 'Bar', true)),
+            $definition->getMethodParameters('Foo', 'injectBar')
+        );
     }
 
     public function testBuilderCanBuildFromArray()
@@ -52,23 +55,26 @@ public function testBuilderCanBuildFromArray()
         $this->assertTrue($definition->hasClass('My\DbAdapter'));
         $this->assertEquals('__construct', $definition->getInstantiator('My\DbAdapter'));
         $this->assertEquals(
-            array('username' => null, 'password' => null),
+            array(
+                'My\DbAdapter::__construct:0' => array('username', null, true),
+                'My\DbAdapter::__construct:1' => array('password', null, true)
+            ),
             $definition->getMethodParameters('My\DbAdapter', '__construct')
-            );
+        );
 
         $this->assertTrue($definition->hasClass('My\Mapper'));
         $this->assertEquals('__construct', $definition->getInstantiator('My\Mapper'));
         $this->assertEquals(
-            array('dbAdapter' => 'My\DbAdapter'),
+            array('My\Mapper::__construct:0' => array('dbAdapter', 'My\DbAdapter', true)),
             $definition->getMethodParameters('My\Mapper', '__construct')
-            );
+        );
 
         $this->assertTrue($definition->hasClass('My\Repository'));
         $this->assertEquals('__construct', $definition->getInstantiator('My\Repository'));
         $this->assertEquals(
-            array('mapper' => 'My\Mapper'),
+            array('My\Repository::__construct:0' => array('mapper', 'My\Mapper', true)),
             $definition->getMethodParameters('My\Repository', '__construct')
-            );
+        );
 
     }
 
@@ -94,8 +100,14 @@ public function testCanCreateInjectionMethodsAndPopulateFromFluentInterface()
         $this->assertTrue($builder->hasMethod('Foo', 'setBar'));
         $this->assertTrue($builder->hasMethod('Foo', 'setConfig'));
 
-        $this->assertEquals(array('bar' => 'Bar'), $builder->getMethodParameters('Foo', 'setBar'));
-        $this->assertEquals(array('config' => null), $builder->getMethodParameters('Foo', 'setConfig'));
+        $this->assertEquals(
+            array('Foo::setBar:0' => array('bar', 'Bar', true)),
+            $builder->getMethodParameters('Foo', 'setBar')
+        );
+        $this->assertEquals(
+            array('Foo::setConfig:0' => array('config', null, true)),
+            $builder->getMethodParameters('Foo', 'setConfig')
+        );
     }
 
     public function testBuilderCanSpecifyClassToUseWithCreateClass()

diff --git a/test/DiTest.php b/test/DiTest.php
@@ -281,6 +281,11 @@ public function testNewInstanceWillResolveConstructorInjectionDependenciesWithMo
     public function testGetWillResolveSetterInjectionDependencies()
     {
         $di = new Di();
+        // for setter injection, the dependency is not required, thus it must be forced
+        $di->instanceManager()->setParameters(
+            'ZendTest\Di\TestAsset\SetterInjection\B',
+            array('a' => new TestAsset\SetterInjection\A)
+        );
         $b = $di->get('ZendTest\Di\TestAsset\SetterInjection\B');
         $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\B', $b);
         $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\A', $b->a);
@@ -292,6 +297,12 @@ public function testGetWillResolveSetterInjectionDependencies()
     public function testGetWillResolveSetterInjectionDependenciesAndInstanceAreTheSame()
     {
         $di = new Di();
+        // for setter injection, the dependency is not required, thus it must be forced
+        $di->instanceManager()->setParameters(
+            'ZendTest\Di\TestAsset\SetterInjection\B',
+            array('a' => $a = new TestAsset\SetterInjection\A)
+        );
+
         $b = $di->get('ZendTest\Di\TestAsset\SetterInjection\B');
         $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\B', $b);
         $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\A', $b->a);
@@ -301,7 +312,8 @@ public function testGetWillResolveSetterInjectionDependenciesAndInstanceAreTheSa
         $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\A', $b2->a);
 
         $this->assertSame($b, $b2);
-        $this->assertSame($b->a, $b2->a);
+        $this->assertSame($b->a, $a);
+        $this->assertSame($b2->a, $a);
     }
 
     /**
@@ -310,6 +322,12 @@ public function testGetWillResolveSetterInjectionDependenciesAndInstanceAreTheSa
     public function testNewInstanceWillResolveSetterInjectionDependencies()
     {
         $di = new Di();
+        // for setter injection, the dependency is not required, thus it must be forced
+        $di->instanceManager()->setParameters(
+            'ZendTest\Di\TestAsset\SetterInjection\B',
+            array('a' => new TestAsset\SetterInjection\A)
+        );
+
         $b = $di->newInstance('ZendTest\Di\TestAsset\SetterInjection\B');
         $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\B', $b);
         $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\A', $b->a);
@@ -442,7 +460,7 @@ public function testInjectionInstancesCanBeInjectedMultipleTimes()
         );
     }
 
-    public function testInjectionCanHandleDisambiguation()
+    public function testInjectionCanHandleDisambiguationViaPositions()
     {
         $definitionList = new DefinitionList(array(
             $classdef = new Definition\ClassDefinition('ZendTest\Di\TestAsset\InjectionClasses\A'),
@@ -468,6 +486,32 @@ public function testInjectionCanHandleDisambiguation()
         $this->assertEquals('twice', $a->bs[1]->id);
     }
 
+    public function testInjectionCanHandleDisambiguationViaNames()
+    {
+        $definitionList = new DefinitionList(array(
+            $classdef = new Definition\ClassDefinition('ZendTest\Di\TestAsset\InjectionClasses\A'),
+            new Definition\RuntimeDefinition()
+        ));
+        $classdef->addMethod('injectBOnce');
+        $classdef->addMethod('injectBTwice');
+        $classdef->addMethodParameter('injectBOnce', 'b', array('required' => true, 'type' => 'ZendTest\Di\TestAsset\InjectionClasses\B'));
+        $classdef->addMethodParameter('injectBTwice', 'b', array('required' => true, 'type' => 'ZendTest\Di\TestAsset\InjectionClasses\B'));
+
+        $di = new Di($definitionList);
+        $di->instanceManager()->setInjections(
+            'ZendTest\Di\TestAsset\InjectionClasses\A',
+            array(
+                'ZendTest\Di\TestAsset\InjectionClasses\A::injectBOnce:b' => new \ZendTest\Di\TestAsset\InjectionClasses\B('once'),
+                'ZendTest\Di\TestAsset\InjectionClasses\A::injectBTwice:b' => new \ZendTest\Di\TestAsset\InjectionClasses\B('twice')
+            )
+        );
+        $a = $di->newInstance('ZendTest\Di\TestAsset\InjectionClasses\A');
+        $this->assertInstanceOf('ZendTest\Di\TestAsset\InjectionClasses\B', $a->bs[0]);
+        $this->assertEquals('once', $a->bs[0]->id);
+        $this->assertInstanceOf('ZendTest\Di\TestAsset\InjectionClasses\B', $a->bs[1]);
+        $this->assertEquals('twice', $a->bs[1]->id);
+    }
+
     public function testInjectionCanHandleMultipleInjectionsWithMultipleArguments()
     {
         $definitionList = new DefinitionList(array(
@@ -511,5 +555,40 @@ public function testInjectionCanHandleMultipleInjectionsWithMultipleArguments()
         $this->assertInstanceOf('ZendTest\Di\TestAsset\InjectionClasses\C', $a->bs[1]);
         $this->assertEquals('bs-id-for-c', $a->bs[1]->id);
     }
+
+    /**
+     * @group SetterInjection
+     * @group SupertypeResolution
+     */
+    public function testInjectionForSetterInjectionWillConsultSupertypeDefinitions()
+    {
+        $di = new Di();
+        // for setter injection, the dependency is not required, thus it must be forced
+        $di->instanceManager()->setParameters(
+            'ZendTest\Di\TestAsset\SetterInjection\C',
+            array('a' => new TestAsset\SetterInjection\A)
+        );
+        $c = $di->get('ZendTest\Di\TestAsset\SetterInjection\C');
+        $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\C', $c);
+        $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\A', $c->a);
+    }
+
+    /**
+     * @group SetterInjection
+     * @group SupertypeResolution
+     */
+    public function testInjectionForSetterInjectionWillConsultSupertypeDefinitionInClassDefinition()
+    {
+        $di = new Di();
+
+        // for setter injection, the dependency is not required, thus it must be forced
+        $classDef = new Definition\ClassDefinition('ZendTest\Di\TestAsset\SetterInjection\B');
+        $classDef->addMethod('setA', true);
+        $di->definitions()->addDefinition($classDef, false); // top of stack b/c Runtime is already there
+
+        $c = $di->get('ZendTest\Di\TestAsset\SetterInjection\C');
+        $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\C', $c);
+        $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\A', $c->a);
+    }
 
 }
diff --git a/test/TestAsset/SetterInjection/B.php b/test/TestAsset/SetterInjection/B.php
@@ -5,7 +5,7 @@
 class B
 {
     public $a = null;
-    public function __construct(A $a)
+    public function setA(A $a)
     {
         $this->a = $a;
     }

diff --git a/test/TestAsset/SetterInjection/C.php b/test/TestAsset/SetterInjection/C.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ZendTest\Di\TestAsset\SetterInjection;
+
+class C extends B
+{
+}