/** * @test */ public function closeCallsDecoratedStream() { $inputStream = NewInstance::of(InputStream::class); $decoratedInputStream = $this->createDecoratedInputStream($inputStream); $decoratedInputStream->close(); verify($inputStream, 'close')->wasCalledOnce(); }
/** * @test */ public function closeClosesDecoratedOutputStream() { $outputStream = NewInstance::of(OutputStream::class); $encodingOutputStream = new EncodingOutputStream($outputStream, 'iso-8859-1'); $encodingOutputStream->close(); verify($outputStream, 'close')->wasCalledOnce(); }
/** * @test */ public function outputStreamGetsPrefix() { $outputStream = NewInstance::of(OutputStream::class); $this->streamFactory->mapCalls(['createOutputStream' => $outputStream]); assert($this->prefixedStreamFactory->createOutputStream('foo', ['bar' => 'baz']), isSameAs($outputStream)); verify($this->streamFactory, 'createOutputStream')->received('prefix/foo', ['bar' => 'baz']); }
/** * @test */ public function otherScopeIsUsedToCreateInstance() { $binder = new Binder(); $instance = new \stdClass(); $binder->bind(\stdClass::class)->to(\stdClass::class)->in(NewInstance::of(BindingScope::class)->mapCalls(['getInstance' => $instance])); assert($binder->getInjector()->getInstance(\stdClass::class), isSameAs($instance)); }
/** * set up test environment */ public function setUp() { $this->memory = ''; $socket = NewInstance::stub(Stream::class)->mapCalls(['write' => function (string $line) { $this->memory .= $line; return strlen($line); }]); $httpUri = NewInstance::stub(HttpUri::class)->mapCalls(['openSocket' => $socket, 'path' => '/foo/resource', 'hostname' => 'example.com', 'hasQueryString' => true, 'queryString' => 'foo=bar']); $this->httpConnection = new HttpConnection($httpUri); }
/** * set up test environment */ public function setUp() { $this->errorHandlers = new ErrorHandlers(); $this->errorHandler1 = NewInstance::of(ErrorHandler::class); $this->errorHandlers->addErrorHandler($this->errorHandler1); $this->errorHandler2 = NewInstance::of(ErrorHandler::class); $this->errorHandlers->addErrorHandler($this->errorHandler2); $this->errorHandler3 = NewInstance::of(ErrorHandler::class); $this->errorHandlers->addErrorHandler($this->errorHandler3); }
/** * @test */ public function injectWithProviderInstance() { $binder = new Binder(); $answer = new Answer(); $provider = NewInstance::of(InjectionProvider::class)->mapCalls(['get' => $answer]); $binder->bind(Answer::class)->toProvider($provider); $question = $binder->getInjector()->getInstance(AnotherQuestion::class); assert($question->getAnswer(), isSameAs($answer)); verify($provider, 'get')->received('answer'); }
/** * @test */ public function canNotRewindNonSeekableInputStream() { $inputStream = NewInstance::of(InputStream::class)->mapCalls(['readLine' => onConsecutiveCalls('foo', 'bar', 'baz', ''), 'eof' => onConsecutiveCalls(false, false, true, true)]); $lines = linesOf($inputStream); foreach ($lines as $lineNumber => $line) { // do nothing } $content = []; foreach (linesOf($inputStream) as $lineNumber => $line) { $content[$lineNumber] = $line; } assertEmptyArray($content); }
/** * creates instance to test * * @param string $queryString * @return HttpRequest */ private function createHttpRequest(string $queryString = null) : HttpRequest { $socket = NewInstance::stub(Stream::class)->mapCalls(['write' => function (string $line) { $this->memory .= $line; return strlen($line); }]); $uriCalls = ['openSocket' => $socket, 'path' => '/foo/resource', 'hostname' => 'example.com']; if (null !== $queryString) { $uriCalls['hasQueryString'] = true; $uriCalls['queryString'] = $queryString; } else { $uriCalls['hasQueryString'] = false; } return HttpRequest::create(NewInstance::stub(HttpUri::class)->mapCalls($uriCalls), new HeaderList(['X-Binford' => 6100])); }
/** * creates instance to test * * @return \stubbles\environments\exceptionhandler\DisplayExceptionHandler */ public function createExceptionHandler($sapi) { $displayExceptionHandler = NewInstance::of(DisplayException::class, ['/tmp', $sapi])->mapCalls(['header' => false, 'writeBody' => false]); return $displayExceptionHandler->disableLogging(); }
/** * set up test environment */ public function setUp() { $this->root = vfsStream::setup(); $this->exceptionHandler = NewInstance::of(AbstractExceptionHandler::class, [vfsStream::url('root')])->mapCalls(['header' => null, 'createResponseBody' => '', 'writeBody' => null]); }
/** * set up test environment */ public function setUp() { $this->injector = NewInstance::of(Injector::class); }
/** * creates mocked provider * * @param mixed $value * @return \stubbles\ioc\InjectionProvider */ private function createProviderForValue($value) : InjectionProvider { return NewInstance::of(InjectionProvider::class)->mapCalls(['get' => $value]); }
/** * @test * @since 3.4.0 */ public function bindsPropertiesWhenConfigFilePresent() { vfsStream::newFile('config/config.ini')->withContent("[config]\nstubbles.locale=\"de_DE\"\nstubbles.number.decimals=4\nstubbles.webapp.xml.serializeMode=true")->at($this->root); $binder = NewInstance::of(Binder::class); $runtime = new Runtime($this->environment); $runtime->configure($binder, $this->root->url()); verify($binder, 'bindProperties')->wasCalledOnce(); }
/** * @test * @since 5.4.0 */ public function setSessionAddsBindingForSessionAsSingleton() { $session = NewInstance::of(Session::class); assert($this->injector->setSession($session, Session::class)->getInstance(Session::class), isSameAs($session)); }
/** * @test * @since 8.0.0 */ public function castFromInputStreamReturnsInputStream() { $inputStream = NewInstance::of(InputStream::class); assert(FileInputStream::castFrom($inputStream), isSameAs($inputStream)); }
/** * @test * @since 7.0.0 */ public function openLocalResourceWithOtherUsesOther() { $myClass = NewInstance::classname(FileInputStream::class); assert($this->resourceLoader->open('lang/stubbles.ini', $myClass), isInstanceOf($myClass)); }
/** * @test */ public function usesPassedSessionScope() { $sessionScope = NewInstance::of(BindingScope::class); $bindingScopes = new BindingScopes(null, $sessionScope); assert($bindingScopes->session(), isSameAs($sessionScope)); }
/** * @test */ public function closeClosesDecoratedStream() { $inputStream = NewInstance::of(InputStream::class); $decodingInputStream = new DecodingInputStream($inputStream, 'iso-8859-1'); $decodingInputStream->close(); verify($inputStream, 'close')->wasCalledOnce(); }
/** * @test */ public function registerErrorHandlerWithInstanceReturnsGivenInstance() { $errorHandler = NewInstance::of(ErrorHandler::class); assert($this->environment->useErrorHandler($errorHandler)->registerErrorHandler('/tmp'), isSameAs($errorHandler)); }
/** * @test */ public function addInvalidProviderClassThrowsBindingException() { $providerClass = get_class(NewInstance::of(InjectionProvider::class)); $this->injector->mapCalls(['getInstance' => \stdClass::class]); $listBinding = $this->listBinding->withValueFromProvider($providerClass); expect(function () use($listBinding) { $listBinding->getInstance($this->injector, new \ReflectionClass(InjectionProvider::class)); })->throws(BindingException::class); }
/** * creates instance to test * * @return stubbles\environments\exceptionhandler\ProdModExceptionHandler */ public function createExceptionHandler($sapi) { $prodModeExceptionHandler = NewInstance::of(ProdModeExceptionHandler::class, [vfsStream::url('root'), $sapi])->mapCalls(['header' => false, 'writeBody' => false]); return $prodModeExceptionHandler->disableLogging(); }
/** * set up test enviroment */ public function setUp() { $this->session = NewInstance::of(Session::class); $this->sessionScope = new SessionBindingScope(); $this->provider = NewInstance::of(InjectionProvider::class); }
/** * @test * @group ioc_constantprovider * @since 1.6.0 */ public function constantViaInjectionProviderInstance() { $binder = new Binder(); $binder->bindConstant('answer')->toProvider(NewInstance::of(InjectionProvider::class)->mapCalls(['get' => 42])); $injector = $binder->getInjector(); assertTrue($injector->hasConstant('answer')); assert($injector->getConstant('answer'), equals(42)); $this->assertConstantInjection($binder->getInjector()); }
/** * @test * @since 8.0.0 */ public function appendCreatesNewCombinedSequenceFromInitialIteratorAggregate() { $iteratorAggregate = NewInstance::of(\IteratorAggregate::class)->mapCalls(['getIterator' => new \ArrayIterator([1, 2])]); assert(Sequence::of($iteratorAggregate)->append([3, 4]), Provides::values([1, 2, 3, 4])); }