bucket.test.php

<?php
require_once 'vendor/simpletest/simpletest/unit_tester.php';
if (realpath($_SERVER['PHP_SELF']) == __FILE__) {
  error_reporting(E_ALL | E_STRICT);
  require_once 'vendor/simpletest/simpletest/autorun.php';
}

require_once 'lib/bucket.inc.php';

class NoDependencies {}
class ExtendsNoDependencies extends NoDependencies {}

class SingleClassDependency {
  public $val;
  function __construct(NoDependencies $val) {
    $this->val = $val;
  }
}

class DefaultValue {
  public $val;
  function __construct($val = 42) {
    $this->val = $val;
  }
}

class UnTypedDependency {
  public $val;
  function __construct($val) {
    $this->val = $val;
  }
}

interface AnInterface {};

class ConcreteImplementation implements AnInterface {}

class DependsOnInterface {
  public $val;
  function __construct(AnInterface $val) {
    $this->val = $val;
  }
}

class TestFactory {
  public $invoked = false;
  function new_NoDependencies($container) {
    $this->invoked = true;
    return new NoDependencies();
  }
  function new_ConcreteImplementation($container) {
    $this->invoked = true;
    return new NoDependencies();
  }
}

class RequireUndefinedClass {
  function __construct(ClassThatDoesntExist $autoloaded) {}
}

class TriedToAutoloadException extends Exception {
  public $classname;
  function __construct($classname) {
    $this->classname = $classname;
    parent::__construct();
  }
}

class TestUnderscoreCallFactory {
  public $invoked = false;
  function __call($name, $args) {
    $this->invoked = true;
    return new StdClass();
  }
}

class TestOfBucketResolving extends UnitTestCase {
  function test_can_create_empty_container() {
    $bucket = new bucket_Container();
  }
  function test_can_create_class_with_no_dependencies() {
    $bucket = new bucket_Container();
    $this->assertIsA($bucket->create('NoDependencies'), 'NoDependencies');
  }
  function test_can_create_class_with_class_dependency() {
    $bucket = new bucket_Container();
    $o = $bucket->create('SingleClassDependency');
    $this->assertIsA($o, 'SingleClassDependency');
    $this->assertIsA($o->val, 'NoDependencies');
  }
  function test_can_create_class_with_default_value() {
    $bucket = new bucket_Container();
    $o = $bucket->create('DefaultValue');
    $this->assertIsA($o, 'DefaultValue');
    $this->assertEqual($o->val, 42);
  }
  function test_barks_on_untyped_dependency() {
    $bucket = new bucket_Container();
    try {
      $bucket->create('UnTypedDependency');
      $this->fail("Expected exception");
    } catch (bucket_CreationException $ex) {
      $this->pass("Exception caught");
    }
  }
  function test_barks_on_interface_dependency_when_unregistered() {
    $bucket = new bucket_Container();
    try {
      $bucket->create('DependsOnInterface');
      $this->fail("Expected exception");
    } catch (bucket_CreationException $ex) {
      $this->pass("Exception caught");
    }
  }
  function test_can_create_class_with_interface_dependency() {
    $bucket = new bucket_Container();
    $bucket->registerImplementation('AnInterface', 'ConcreteImplementation');
    $o = $bucket->create('DependsOnInterface');
    $this->assertIsA($o, 'DependsOnInterface');
    $this->assertIsA($o->val, 'ConcreteImplementation');
  }
  function test_can_set_different_implementation_for_concrete_class() {
    $bucket = new bucket_Container();
    $bucket->registerImplementation('NoDependencies', 'ExtendsNoDependencies');
    $o = $bucket->create('SingleClassDependency');
    $this->assertIsA($o, 'SingleClassDependency');
    $this->assertIsA($o->val, 'ExtendsNoDependencies');
  }
}

class TestOfBucketContainer extends UnitTestCase {
  function test_get_creates_new_object() {
    $bucket = new bucket_Container();
    $this->assertIsA($bucket->get('NoDependencies'), 'NoDependencies');
  }
  function test_get_returns_same_instance_on_subsequent_calls() {
    $bucket = new bucket_Container();
    $this->assertSame(
      $bucket->get('NoDependencies'),
      $bucket->get('NoDependencies'));
  }
}

class TestOfBucketFactory extends UnitTestCase {
  function test_container_delegates_to_factory_method() {
    $factory = new TestFactory();
    $bucket = new bucket_Container($factory);
    $this->assertIsA($bucket->get('NoDependencies'), 'NoDependencies');
    $this->assertTrue($factory->invoked);
  }
  function test_container_can_return_different_implementation() {
    $bucket = new bucket_Container(new TestFactory());
    $this->assertIsA($bucket->get('ConcreteImplementation'), 'NoDependencies');
  }
  function test_container_delegates_to_factory_callback() {
    $factory = new TestFactory();
    $factory->new_defaultvalue = create_function('', 'return new StdClass();');
    // For PHP 5.3+
    // $factory->new_defaultvalue = function($container) {
    //   return new StdClass();
    // }
    $bucket = new bucket_Container($factory);
    $this->assertIsA($bucket->get('DefaultValue'), 'StdClass');
  }
  function test_callback_takes_precedence_over_method() {
    $factory = new TestFactory();
    $factory->new_nodependencies = create_function('', 'return new StdClass();');
    // For PHP 5.3+
    // $factory->new_nodependencies = function($container) {
    //   return new StdClass();
    // }
    $bucket = new bucket_Container($factory);
    $this->assertIsA($bucket->get('NoDependencies'), 'StdClass');
  }
  function test_container_can_take_array_of_callbacks_as_argument() {
    $bucket = new bucket_Container(
      array(
        'DefaultValue' => create_function('', 'return new StdClass();')
      )
    );
    // For PHP 5.3+
    // $bucket = new bucket_Container(
    //   array(
    //     'DefaultValue' => function($container) {
    //       return new StdClass();
    //     }
    //   )
    // );
    $this->assertIsA($bucket->get('DefaultValue'), 'StdClass');
  }
  function test_underscore_call_is_callable() {
    $factory = new TestUnderscoreCallFactory();
    $bucket = new bucket_Container($factory);
    $this->assertIsA($bucket->get('StdClass'), 'StdClass');
    $this->assertTrue($factory->invoked);
  }
}

class TestOfBucketScope extends UnitTestCase {
  function test_a_child_scope_uses_parent_factory() {
    $factory = new TestFactory();
    $bucket = new bucket_Container($factory);
    $scope = $bucket->makeChildContainer();
    $this->assertIsA($scope->get('NoDependencies'), 'NoDependencies');
    $this->assertTrue($factory->invoked);
  }
  function test_get_on_a_child_scope_returns_same_instance_on_subsequent_calls() {
    $factory = new TestFactory();
    $bucket = new bucket_Container($factory);
    $scope = $bucket->makeChildContainer();
    $this->assertSame(
      $scope->get('NoDependencies'),
      $scope->get('NoDependencies'));
  }
  function test_get_on_a_child_scope_returns_parent_state() {
    $factory = new TestFactory();
    $bucket = new bucket_Container($factory);
    $scope = $bucket->makeChildContainer();
    $o = $bucket->get('NoDependencies');
    $this->assertSame(
      $o,
      $scope->get('NoDependencies'));
  }
  function test_parent_scope_doesnt_see_child_state() {
    $factory = new TestFactory();
    $bucket = new bucket_Container($factory);
    $scope = $bucket->makeChildContainer();
    $o = $scope->get('NoDependencies');
    $this->assertFalse($o === $bucket->get('NoDependencies'));
  }
  function test_setting_an_instance_and_getting_it_should_return_same_instance() {
    $bucket = new bucket_Container();
    $obj = new StdClass();
    $bucket->set($obj);
    $this->assertSame($bucket->get('StdClass'), $obj);
  }
}