/**
* Get all the logger entries.
*
* @return array
*/
public function getLoggerStrings()
{
$records = $this->testLogger->getRecords();
$return = [];
foreach ($records as $record) {
$return[] = $record['message'];
}
return $return;
}
public function testNon2XXResponsesGetLoggedAsWarning()
{
$testHandler = new TestHandler();
$logger = new Logger('test', [$testHandler]);
$response = $this->performTestRequest($logger, new Request('GET', 'http://example.com'), new Response(300));
$this->assertEquals(300, $response->getStatusCode());
$this->assertCount(2, $testHandler->getRecords());
$this->assertEquals('HTTP response 300', $testHandler->getRecords()[1]['message']);
$this->assertEquals('WARNING', $testHandler->getRecords()[1]['level_name']);
}
public function testHandleError()
{
$logger = new Logger('test', array($handler = new TestHandler()));
$errHandler = new ErrorHandler($logger);
$errHandler->registerErrorHandler(array(E_USER_NOTICE => Logger::EMERGENCY), false);
trigger_error('Foo', E_USER_ERROR);
$this->assertCount(1, $handler->getRecords());
$this->assertTrue($handler->hasErrorRecords());
trigger_error('Foo', E_USER_NOTICE);
$this->assertCount(2, $handler->getRecords());
$this->assertTrue($handler->hasEmergencyRecords());
}
/**
* @dataProvider methodProvider
*/
public function testHandler($method, $level)
{
$handler = new TestHandler();
$record = $this->getRecord($level, 'test' . $method);
$this->assertFalse($handler->{'has' . $method}($record), 'has' . $method);
$this->assertFalse($handler->{'has' . $method . 'ThatContains'}('test'), 'has' . $method . 'ThatContains');
$this->assertFalse($handler->{'has' . $method . 'ThatPasses'}(function ($rec) {
return true;
}), 'has' . $method . 'ThatPasses');
$this->assertFalse($handler->{'has' . $method . 'ThatMatches'}('/test\\w+/'));
$this->assertFalse($handler->{'has' . $method . 'Records'}(), 'has' . $method . 'Records');
$handler->handle($record);
$this->assertFalse($handler->{'has' . $method}('bar'), 'has' . $method);
$this->assertTrue($handler->{'has' . $method}($record), 'has' . $method);
$this->assertTrue($handler->{'has' . $method}('test' . $method), 'has' . $method);
$this->assertTrue($handler->{'has' . $method . 'ThatContains'}('test'), 'has' . $method . 'ThatContains');
$this->assertTrue($handler->{'has' . $method . 'ThatPasses'}(function ($rec) {
return true;
}), 'has' . $method . 'ThatPasses');
$this->assertTrue($handler->{'has' . $method . 'ThatMatches'}('/test\\w+/'));
$this->assertTrue($handler->{'has' . $method . 'Records'}(), 'has' . $method . 'Records');
$records = $handler->getRecords();
unset($records[0]['formatted']);
$this->assertEquals(array($record), $records);
}
/**
* @covers Monolog\Handler\AbstractProcessingHandler::processRecord
*/
public function testProcessRecord()
{
$handler = new TestHandler();
$handler->pushProcessor(new WebProcessor(array('REQUEST_URI' => '', 'REQUEST_METHOD' => '', 'REMOTE_ADDR' => '')));
$handler->handle($this->getRecord());
list($record) = $handler->getRecords();
$this->assertEquals(3, count($record['extra']));
}
public function testExpiration()
{
$startTime = microtime(true);
$this->manager->aquire("my_key");
$duration = microtime(true) - $startTime;
$this->assertTrue($duration < 2);
$loggerRecordList = $this->loggerTestHandler->getRecords();
$this->assertEquals(0, count($loggerRecordList));
$this->manager->aquire("my_key");
$duration2 = microtime(true) - $startTime;
$this->assertTrue($duration2 > 4);
$loggerRecordList = $this->loggerTestHandler->getRecords();
$this->assertEquals(1, count($loggerRecordList));
$record = $loggerRecordList[0];
$message = $record["message"];
$this->assertEquals(1, preg_match('/Dead lock detected.+\\/Tests\\/Manager\\/ManagerTest\\.php\\(\\d+\\)/', $message));
}
protected function outputLog()
{
if ($this->option('debug')) {
$this->info('Log:');
foreach ($this->logHandler->getRecords() as $record) {
$this->line(str_replace(PHP_EOL, '', $record['formatted']));
}
}
}
public function testKernelException()
{
$request = Request::create('/syrup/run', 'POST');
$request->headers->set('X-StorageApi-Token', SYRUP_SAPI_TEST_TOKEN);
$message = uniqid();
$event = new GetResponseForExceptionEvent(self::$kernel, $request, HttpKernelInterface::MASTER_REQUEST, new UserException($message));
$this->listener->onKernelException($event);
$records = $this->testLogHandler->getRecords();
$this->assertCount(1, $records);
$record = array_pop($records);
$this->assertArrayHasKey('priority', $record);
$this->assertEquals('ERROR', $record['priority']);
$this->assertArrayHasKey('exception', $record);
$this->assertArrayHasKey('class', $record['exception']);
$this->assertEquals('Keboola\\Syrup\\Exception\\UserException', $record['exception']['class']);
$response = $event->getResponse();
$this->assertEquals(400, $response->getStatusCode());
$jsonResponse = json_decode($response->getContent(), true);
$this->assertArrayHasKey('status', $jsonResponse);
$this->assertEquals('error', $jsonResponse['status']);
$this->assertArrayHasKey('code', $jsonResponse);
$this->assertEquals(400, $jsonResponse['code']);
$this->assertArrayHasKey('exceptionId', $jsonResponse);
$this->assertArrayHasKey('runId', $jsonResponse);
$message = uniqid();
$event = new GetResponseForExceptionEvent(self::$kernel, $request, HttpKernelInterface::MASTER_REQUEST, new ClientException($message));
$this->listener->onKernelException($event);
$records = $this->testLogHandler->getRecords();
$this->assertCount(2, $records);
$record = array_pop($records);
$this->assertArrayHasKey('priority', $record);
$this->assertEquals('CRITICAL', $record['priority']);
$this->assertArrayHasKey('exception', $record);
$this->assertArrayHasKey('class', $record['exception']);
$this->assertEquals('Keboola\\StorageApi\\ClientException', $record['exception']['class']);
$response = $event->getResponse();
$this->assertEquals(500, $response->getStatusCode());
$jsonResponse = json_decode($response->getContent(), true);
$this->assertArrayHasKey('status', $jsonResponse);
$this->assertEquals('error', $jsonResponse['status']);
$this->assertArrayHasKey('code', $jsonResponse);
$this->assertEquals(500, $jsonResponse['code']);
$this->assertArrayHasKey('exceptionId', $jsonResponse);
$this->assertArrayHasKey('runId', $jsonResponse);
$exception = new UserException(uniqid());
$exception->setData(['d1' => uniqid(), 'd2' => uniqid()]);
$event = new GetResponseForExceptionEvent(self::$kernel, $request, HttpKernelInterface::MASTER_REQUEST, $exception);
$this->listener->onKernelException($event);
$records = $this->testLogHandler->getRecords();
$this->assertCount(3, $records);
$record = array_pop($records);
$this->assertArrayHasKey('context', $record);
$this->assertArrayHasKey('data', $record['context']);
$this->assertArrayHasKey('d1', $record['context']['data']);
$this->assertArrayHasKey('d2', $record['context']['data']);
}
public function testWarn()
{
$context = array("foo" => "bar");
Simple::warn("hello", $context);
$this->assertTrue($this->handler->hasWarningRecords());
foreach ($this->handler->getRecords() as $record) {
$this->assertEquals("hello", $record['message']);
$this->assertEquals("WARNING", $record['level_name']);
$this->assertEquals($context, $record['context']);
}
}
public function testHandleBuffers()
{
$test = new TestHandler();
$handler = new BufferHandler($test);
$handler->handle($this->getRecord(Logger::DEBUG));
$handler->handle($this->getRecord(Logger::INFO));
$this->assertFalse($test->hasDebugRecords());
$this->assertFalse($test->hasInfoRecords());
$handler->close();
$this->assertTrue($test->hasInfoRecords());
$this->assertTrue(count($test->getRecords()) === 2);
}
public function testHandle()
{
$testHandler = new TestHandler();
$handler = new SamplingHandler($testHandler, 2);
for ($i = 0; $i < 10000; $i++) {
$handler->handle($this->getRecord());
}
$count = count($testHandler->getRecords());
// $count should be half of 10k, so between 4k and 6k
$this->assertLessThan(6000, $count);
$this->assertGreaterThan(4000, $count);
}
/**
* @covers Monolog\Handler\GroupHandler::handle
*/
public function testHandleUsesProcessors()
{
$test = new TestHandler();
$handler = new GroupHandler(array($test));
$handler->pushProcessor(function ($record) {
$record['extra']['foo'] = true;
return $record;
});
$handler->handle($this->getRecord(Logger::WARNING));
$this->assertTrue($test->hasWarningRecords());
$records = $test->getRecords();
$this->assertTrue($records[0]['extra']['foo']);
}
/**
* @covers Monolog\Handler\BufferHandler::handle
*/
public function testHandleBufferLimitWithFlushOnOverflow()
{
$test = new TestHandler();
$handler = new BufferHandler($test, 3, Logger::DEBUG, true, true);
// send two records
$handler->handle($this->getRecord(Logger::DEBUG));
$handler->handle($this->getRecord(Logger::DEBUG));
$handler->handle($this->getRecord(Logger::DEBUG));
$this->assertFalse($test->hasDebugRecords());
$this->assertCount(0, $test->getRecords());
// overflow
$handler->handle($this->getRecord(Logger::INFO));
$this->assertTrue($test->hasDebugRecords());
$this->assertCount(3, $test->getRecords());
// should buffer again
$handler->handle($this->getRecord(Logger::WARNING));
$this->assertCount(3, $test->getRecords());
$handler->close();
$this->assertCount(5, $test->getRecords());
$this->assertTrue($test->hasWarningRecords());
$this->assertTrue($test->hasInfoRecords());
}
public function testHandleWithCallback()
{
$test = new TestHandler();
$handler = new FingersCrossedHandler(function ($record, $handler) use($test) {
return $test;
});
$handler->handle($this->getRecord(Logger::DEBUG));
$handler->handle($this->getRecord(Logger::INFO));
$this->assertFalse($test->hasDebugRecords());
$this->assertFalse($test->hasInfoRecords());
$handler->handle($this->getRecord(Logger::WARNING));
$this->assertTrue($test->hasInfoRecords());
$this->assertTrue(count($test->getRecords()) === 3);
}
public function testHandleAnother()
{
$test = new TestHandler();
$handler = new BubbleHandler($test, new \Bubble\CatchBubble(\Bubble\CatchBubble::TIMEOUT));
$this->assertTrue($handler instanceof AbstractHandler);
$debug = $this->getRecord(Logger::DEBUG, 'one message');
$handler->handle($debug);
$secondSame = $debug;
$secondSame['message'] = 'another message';
$secondSame['datetime'] = clone $debug['datetime'];
$secondSame['datetime']->add(new \DateInterval('PT1S'));
$handler->handle($secondSame);
$this->assertCount(2, $test->getRecords());
}
/**
* @dataProvider methodProvider
*/
public function testHandler($method, $level)
{
$handler = new TestHandler();
$record = $this->getRecord($level, 'test' . $method);
$this->assertFalse($handler->{'has' . $method}($record));
$this->assertFalse($handler->{'has' . $method . 'Records'}());
$handler->handle($record);
$this->assertFalse($handler->{'has' . $method}('bar'));
$this->assertTrue($handler->{'has' . $method}($record));
$this->assertTrue($handler->{'has' . $method}('test' . $method));
$this->assertTrue($handler->{'has' . $method . 'Records'}());
$records = $handler->getRecords();
unset($records[0]['formatted']);
$this->assertEquals(array($record), $records);
}
public function testInvokeProxiesToLogger()
{
$ex = new \RuntimeException('foo');
$test = new TestHandler();
$request = ServerRequestFactory::fromGlobals();
$response = new Response();
$logger = new Logger('default', [$test]);
$error = new ResponseCache($logger);
$response = $error($ex, $request, $response, function ($request, $response) {
$response->getBody()->write('complete');
return $response;
});
$this->assertSame('complete', $response->getBody()->__toString());
$this->assertCount(1, $test->getRecords());
}
/**
* Test how unhandled exception is handled (use parse error as an example).
*/
public function testParseErrorLogsAnError()
{
$this->error_handler->setReThrowException(false);
$this->assertFalse($this->error_handler->getReThrowException());
$this->assertEquals(ErrorHandlerInterface::THROW_EXCEPTION, $this->error_handler->getHowToHandleError(E_PARSE));
$this->assertCount(0, $this->log_handler->getRecords());
try {
eval('<?php not good');
$this->fail('Code above should throw a parse error');
} catch (\ParseError $e) {
$this->error_handler->handleException($e);
}
$this->assertCount(1, $this->log_handler->getRecords());
$this->assertEquals('Unhandled exception: {message}', $this->log_handler->getRecords()[0]['message']);
$this->assertEquals(Logger::CRITICAL, $this->log_handler->getRecords()[0]['level']);
$this->assertContains('syntax error', $this->log_handler->getRecords()[0]['context']['message']);
$this->assertInstanceOf(Throwable::class, $this->log_handler->getRecords()[0]['context']['exception']);
}
public function testLoggingFailed()
{
$queue = $this->createQueue();
if (!$queue instanceof LoggingQueueInterface) {
$this->markTestSkipped('Queue of type ' . get_class($queue) . ' does not log actions.');
return;
}
$transport = new NoOpTransport(NoOpTransport::FAILED);
$handler = new TestHandler();
$logger = new Logger('test', array($handler));
$queue->setLogger($logger);
$message = new TestMessage();
$queue->enqueue($message);
$queue->execute($transport);
$records = $handler->getRecords();
// the logger has to be at least one record
$this->assertTrue(count($records) > 0);
// the logger has to be at least one debug record (=> successful transport)
$this->assertTrue(array_reduce($records, function (&$result, $record) {
return $result || $record['level'] == Logger::ERROR;
}, false));
}
/**
* @covers Monolog\Handler\WhatFailureGroupHandler::handle
*/
public function testHandleException()
{
$test = new TestHandler();
$exception = new ExceptionTestHandler();
$handler = new WhatFailureGroupHandler(array($exception, $test, $exception));
$handler->pushProcessor(function ($record) {
$record['extra']['foo'] = true;
return $record;
});
$handler->handle($this->getRecord(Logger::WARNING));
$this->assertTrue($test->hasWarningRecords());
$records = $test->getRecords();
$this->assertTrue($records[0]['extra']['foo']);
}
/**
* @covers Monolog\Handler\AbstractHandler::handleBatch
*/
public function testHandleBatch()
{
$handler = new TestHandler();
$handler->handleBatch(array($this->getRecord(), $this->getRecord()));
$this->assertEquals(2, count($handler->getRecords()));
}
public function testGet()
{
$this->client->get('http://google.com');
$loggedCurl = $this->loggerHandler->getRecords()[0]['message'];
$this->assertContains('curl', $loggedCurl);
}
