PHP TestHandler::getRecords方法代碼示例

 /**
  * 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());
 }