brmlab/brmbiolab_sklad
4
0
Fork 0
mirror of https://github.com/brmlab/brmbiolab_sklad.git synced 2025-06-12 07:03:59 +02:00
Code Issues Projects Releases Packages Wiki Activity

Initial commit

Browse source
This commit is contained in:
mareksebera 2014-09-10 20:20:58 +02:00
commit 3b93da31de
1004 changed files with 265840 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

747
lib/Cake/Test/Case/Log/CakeLogTest.php Normal file
View file

@ -0,0 +1,747 @@
<?php
/**
* CakeLogTest file
*
* CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice
*
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://book.cakephp.org/2.0/en/development/testing.html CakePHP(tm) Tests
* @package Cake.Test.Case.Log
* @since CakePHP(tm) v 1.2.0.5432
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('CakeLog', 'Log');
App::uses('FileLog', 'Log/Engine');
/**
* CakeLogTest class
*
* @package Cake.Test.Case.Log
*/
class CakeLogTest extends CakeTestCase {
/**
* Start test callback, clears all streams enabled.
*
* @return void
*/
public function setUp() {
parent::setUp();
$streams = CakeLog::configured();
foreach ($streams as $stream) {
CakeLog::drop($stream);
}
}
/**
* test importing loggers from app/libs and plugins.
*
* @return void
*/
public function testImportingLoggers() {
App::build(array(
'Lib' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Lib' . DS),
'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)
), App::RESET);
CakePlugin::load('TestPlugin');
$result = CakeLog::config('libtest', array(
'engine' => 'TestAppLog'
));
$this->assertTrue($result);
$this->assertEquals(CakeLog::configured(), array('libtest'));
$result = CakeLog::config('plugintest', array(
'engine' => 'TestPlugin.TestPluginLog'
));
$this->assertTrue($result);
$this->assertEquals(CakeLog::configured(), array('libtest', 'plugintest'));
CakeLog::write(LOG_INFO, 'TestPluginLog is not a BaseLog descendant');
App::build();
CakePlugin::unload();
}
/**
* test all the errors from failed logger imports
*
* @expectedException CakeLogException
* @return void
*/
public function testImportingLoggerFailure() {
CakeLog::config('fail', array());
}
/**
* test config() with valid key name
*
* @return void
*/
public function testValidKeyName() {
CakeLog::config('valid', array('engine' => 'File'));
$stream = CakeLog::stream('valid');
$this->assertInstanceOf('FileLog', $stream);
CakeLog::drop('valid');
}
/**
* test config() with valid key name including the deprecated Log suffix
*
* @return void
*/
public function testValidKeyNameLogSuffix() {
CakeLog::config('valid', array('engine' => 'FileLog'));
$stream = CakeLog::stream('valid');
$this->assertInstanceOf('FileLog', $stream);
CakeLog::drop('valid');
}
/**
* test config() with invalid key name
*
* @expectedException CakeLogException
* @return void
*/
public function testInvalidKeyName() {
CakeLog::config('1nv', array('engine' => 'File'));
}
/**
* test that loggers have to implement the correct interface.
*
* @expectedException CakeLogException
* @return void
*/
public function testNotImplementingInterface() {
CakeLog::config('fail', array('engine' => 'stdClass'));
}
/**
* Test that CakeLog does not auto create logs when no streams are there to listen.
*
* @return void
*/
public function testNoStreamListenting() {
if (file_exists(LOGS . 'error.log')) {
unlink(LOGS . 'error.log');
}
$res = CakeLog::write(LOG_WARNING, 'Test warning');
$this->assertFalse($res);
$this->assertFalse(file_exists(LOGS . 'error.log'));
$result = CakeLog::configured();
$this->assertEquals(array(), $result);
}
/**
* test configuring log streams
*
* @return void
*/
public function testConfig() {
CakeLog::config('file', array(
'engine' => 'File',
'path' => LOGS
));
$result = CakeLog::configured();
$this->assertEquals(array('file'), $result);
if (file_exists(LOGS . 'error.log')) {
unlink(LOGS . 'error.log');
}
CakeLog::write(LOG_WARNING, 'Test warning');
$this->assertTrue(file_exists(LOGS . 'error.log'));
$result = file_get_contents(LOGS . 'error.log');
$this->assertRegExp('/^2[0-9]{3}-[0-9]+-[0-9]+ [0-9]+:[0-9]+:[0-9]+ Warning: Test warning/', $result);
unlink(LOGS . 'error.log');
}
/**
* explicit tests for drop()
*
* @return void
*/
public function testDrop() {
CakeLog::config('file', array(
'engine' => 'File',
'path' => LOGS
));
$result = CakeLog::configured();
$this->assertEquals(array('file'), $result);
CakeLog::drop('file');
$result = CakeLog::configured();
$this->assertSame(array(), $result);
}
/**
* testLogFileWriting method
*
* @return void
*/
public function testLogFileWriting() {
CakeLog::config('file', array(
'engine' => 'File',
'path' => LOGS
));
if (file_exists(LOGS . 'error.log')) {
unlink(LOGS . 'error.log');
}
$result = CakeLog::write(LOG_WARNING, 'Test warning');
$this->assertTrue($result);
$this->assertTrue(file_exists(LOGS . 'error.log'));
unlink(LOGS . 'error.log');
CakeLog::write(LOG_WARNING, 'Test warning 1');
CakeLog::write(LOG_WARNING, 'Test warning 2');
$result = file_get_contents(LOGS . 'error.log');
$this->assertRegExp('/^2[0-9]{3}-[0-9]+-[0-9]+ [0-9]+:[0-9]+:[0-9]+ Warning: Test warning 1/', $result);
$this->assertRegExp('/2[0-9]{3}-[0-9]+-[0-9]+ [0-9]+:[0-9]+:[0-9]+ Warning: Test warning 2$/', $result);
unlink(LOGS . 'error.log');
}
/**
* test selective logging by level/type
*
* @return void
*/
public function testSelectiveLoggingByLevel() {
if (file_exists(LOGS . 'spam.log')) {
unlink(LOGS . 'spam.log');
}
if (file_exists(LOGS . 'eggs.log')) {
unlink(LOGS . 'eggs.log');
}
CakeLog::config('spam', array(
'engine' => 'File',
'types' => 'debug',
'file' => 'spam',
));
CakeLog::config('eggs', array(
'engine' => 'File',
'types' => array('eggs', 'debug', 'error', 'warning'),
'file' => 'eggs',
));
$testMessage = 'selective logging';
CakeLog::write(LOG_WARNING, $testMessage);
$this->assertTrue(file_exists(LOGS . 'eggs.log'));
$this->assertFalse(file_exists(LOGS . 'spam.log'));
CakeLog::write(LOG_DEBUG, $testMessage);
$this->assertTrue(file_exists(LOGS . 'spam.log'));
$contents = file_get_contents(LOGS . 'spam.log');
$this->assertContains('Debug: ' . $testMessage, $contents);
$contents = file_get_contents(LOGS . 'eggs.log');
$this->assertContains('Debug: ' . $testMessage, $contents);
if (file_exists(LOGS . 'spam.log')) {
unlink(LOGS . 'spam.log');
}
if (file_exists(LOGS . 'eggs.log')) {
unlink(LOGS . 'eggs.log');
}
}
/**
* test enable
*
* @expectedException CakeLogException
* @return void
*/
public function testStreamEnable() {
CakeLog::config('spam', array(
'engine' => 'File',
'file' => 'spam',
));
$this->assertTrue(CakeLog::enabled('spam'));
CakeLog::drop('spam');
CakeLog::enable('bogus_stream');
}
/**
* test disable
*
* @expectedException CakeLogException
* @return void
*/
public function testStreamDisable() {
CakeLog::config('spam', array(
'engine' => 'File',
'file' => 'spam',
));
$this->assertTrue(CakeLog::enabled('spam'));
CakeLog::disable('spam');
$this->assertFalse(CakeLog::enabled('spam'));
CakeLog::drop('spam');
CakeLog::enable('bogus_stream');
}
/**
* test enabled() invalid stream
*
* @expectedException CakeLogException
* @return void
*/
public function testStreamEnabledInvalid() {
CakeLog::enabled('bogus_stream');
}
/**
* test disable invalid stream
*
* @expectedException CakeLogException
* @return void
*/
public function testStreamDisableInvalid() {
CakeLog::disable('bogus_stream');
}
/**
* resets log config
*
* @return void
*/
protected function _resetLogConfig() {
CakeLog::config('debug', array(
'engine' => 'File',
'types' => array('notice', 'info', 'debug'),
'file' => 'debug',
));
CakeLog::config('error', array(
'engine' => 'File',
'types' => array('warning', 'error', 'critical', 'alert', 'emergency'),
'file' => 'error',
));
}
/**
* delete logs
*
* @return void
*/
protected function _deleteLogs() {
if (file_exists(LOGS . 'shops.log')) {
unlink(LOGS . 'shops.log');
}
if (file_exists(LOGS . 'error.log')) {
unlink(LOGS . 'error.log');
}
if (file_exists(LOGS . 'debug.log')) {
unlink(LOGS . 'debug.log');
}
if (file_exists(LOGS . 'bogus.log')) {
unlink(LOGS . 'bogus.log');
}
if (file_exists(LOGS . 'spam.log')) {
unlink(LOGS . 'spam.log');
}
if (file_exists(LOGS . 'eggs.log')) {
unlink(LOGS . 'eggs.log');
}
}
/**
* test backward compatible scoped logging
*
* @return void
*/
public function testScopedLoggingBC() {
$this->_resetLogConfig();
CakeLog::config('shops', array(
'engine' => 'File',
'types' => array('info', 'notice', 'warning'),
'scopes' => array('transactions', 'orders'),
'file' => 'shops',
));
$this->_deleteLogs();
CakeLog::write('info', 'info message');
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->assertTrue(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::write('transactions', 'transaction message');
$this->assertTrue(file_exists(LOGS . 'shops.log'));
$this->assertFalse(file_exists(LOGS . 'transactions.log'));
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::write('error', 'error message');
$this->assertTrue(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->assertFalse(file_exists(LOGS . 'shops.log'));
$this->_deleteLogs();
CakeLog::write('orders', 'order message');
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->assertFalse(file_exists(LOGS . 'orders.log'));
$this->assertTrue(file_exists(LOGS . 'shops.log'));
$this->_deleteLogs();
CakeLog::write('warning', 'warning message');
$this->assertTrue(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::drop('shops');
}
/**
* Test that scopes are exclusive and don't bleed.
*
* @return void
*/
public function testScopedLoggingExclusive() {
$this->_deleteLogs();
CakeLog::config('shops', array(
'engine' => 'File',
'types' => array('info', 'notice', 'warning'),
'scopes' => array('transactions', 'orders'),
'file' => 'shops.log',
));
CakeLog::config('eggs', array(
'engine' => 'File',
'types' => array('info', 'notice', 'warning'),
'scopes' => array('eggs'),
'file' => 'eggs.log',
));
CakeLog::write('info', 'transactions message', 'transactions');
$this->assertFalse(file_exists(LOGS . 'eggs.log'));
$this->assertTrue(file_exists(LOGS . 'shops.log'));
$this->_deleteLogs();
CakeLog::write('info', 'eggs message', 'eggs');
$this->assertTrue(file_exists(LOGS . 'eggs.log'));
$this->assertFalse(file_exists(LOGS . 'shops.log'));
}
/**
* test scoped logging
*
* @return void
*/
public function testScopedLogging() {
$this->_resetLogConfig();
$this->_deleteLogs();
CakeLog::config('string-scope', array(
'engine' => 'File',
'types' => array('info', 'notice', 'warning'),
'scopes' => 'string-scope',
'file' => 'string-scope.log'
));
CakeLog::write('info', 'info message', 'string-scope');
$this->assertTrue(file_exists(LOGS . 'string-scope.log'));
CakeLog::drop('string-scope');
CakeLog::config('shops', array(
'engine' => 'File',
'types' => array('info', 'notice', 'warning'),
'scopes' => array('transactions', 'orders'),
'file' => 'shops.log',
));
CakeLog::write('info', 'info message', 'transactions');
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->assertTrue(file_exists(LOGS . 'shops.log'));
$this->assertTrue(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::write('transactions', 'transaction message', 'orders');
$this->assertTrue(file_exists(LOGS . 'shops.log'));
$this->assertFalse(file_exists(LOGS . 'transactions.log'));
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::write('error', 'error message', 'orders');
$this->assertTrue(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->assertFalse(file_exists(LOGS . 'shops.log'));
$this->_deleteLogs();
CakeLog::write('orders', 'order message', 'transactions');
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->assertFalse(file_exists(LOGS . 'orders.log'));
$this->assertTrue(file_exists(LOGS . 'shops.log'));
$this->_deleteLogs();
CakeLog::write('warning', 'warning message', 'orders');
$this->assertTrue(file_exists(LOGS . 'error.log'));
$this->assertTrue(file_exists(LOGS . 'shops.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::drop('shops');
}
/**
* test bogus type and scope
*
* @return void
*/
public function testBogusTypeAndScope() {
$this->_resetLogConfig();
$this->_deleteLogs();
CakeLog::config('file', array(
'engine' => 'File',
'path' => LOGS
));
CakeLog::write('bogus', 'bogus message');
$this->assertTrue(file_exists(LOGS . 'bogus.log'));
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::write('bogus', 'bogus message', 'bogus');
$this->assertTrue(file_exists(LOGS . 'bogus.log'));
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::write('error', 'bogus message', 'bogus');
$this->assertFalse(file_exists(LOGS . 'bogus.log'));
$this->assertTrue(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
}
/**
* test scoped logging with convenience methods
*
* @return void
*/
public function testConvenienceScopedLogging() {
if (file_exists(LOGS . 'shops.log')) {
unlink(LOGS . 'shops.log');
}
if (file_exists(LOGS . 'error.log')) {
unlink(LOGS . 'error.log');
}
if (file_exists(LOGS . 'debug.log')) {
unlink(LOGS . 'debug.log');
}
$this->_resetLogConfig();
CakeLog::config('shops', array(
'engine' => 'File',
'types' => array('info', 'debug', 'notice', 'warning'),
'scopes' => array('transactions', 'orders'),
'file' => 'shops',
));
CakeLog::info('info message', 'transactions');
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->assertTrue(file_exists(LOGS . 'shops.log'));
$this->assertTrue(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::error('error message', 'orders');
$this->assertTrue(file_exists(LOGS . 'error.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->assertFalse(file_exists(LOGS . 'shops.log'));
$this->_deleteLogs();
CakeLog::warning('warning message', 'orders');
$this->assertTrue(file_exists(LOGS . 'error.log'));
$this->assertTrue(file_exists(LOGS . 'shops.log'));
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
CakeLog::drop('shops');
}
/**
* test convenience methods
*
* @return void
*/
public function testConvenienceMethods() {
$this->_deleteLogs();
CakeLog::config('debug', array(
'engine' => 'File',
'types' => array('notice', 'info', 'debug'),
'file' => 'debug',
));
CakeLog::config('error', array(
'engine' => 'File',
'types' => array('emergency', 'alert', 'critical', 'error', 'warning'),
'file' => 'error',
));
$testMessage = 'emergency message';
CakeLog::emergency($testMessage);
$contents = file_get_contents(LOGS . 'error.log');
$this->assertRegExp('/(Emergency|Critical): ' . $testMessage . '/', $contents);
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
$testMessage = 'alert message';
CakeLog::alert($testMessage);
$contents = file_get_contents(LOGS . 'error.log');
$this->assertRegExp('/(Alert|Critical): ' . $testMessage . '/', $contents);
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
$testMessage = 'critical message';
CakeLog::critical($testMessage);
$contents = file_get_contents(LOGS . 'error.log');
$this->assertContains('Critical: ' . $testMessage, $contents);
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
$testMessage = 'error message';
CakeLog::error($testMessage);
$contents = file_get_contents(LOGS . 'error.log');
$this->assertContains('Error: ' . $testMessage, $contents);
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
$testMessage = 'warning message';
CakeLog::warning($testMessage);
$contents = file_get_contents(LOGS . 'error.log');
$this->assertContains('Warning: ' . $testMessage, $contents);
$this->assertFalse(file_exists(LOGS . 'debug.log'));
$this->_deleteLogs();
$testMessage = 'notice message';
CakeLog::notice($testMessage);
$contents = file_get_contents(LOGS . 'debug.log');
$this->assertRegExp('/(Notice|Debug): ' . $testMessage . '/', $contents);
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->_deleteLogs();
$testMessage = 'info message';
CakeLog::info($testMessage);
$contents = file_get_contents(LOGS . 'debug.log');
$this->assertRegExp('/(Info|Debug): ' . $testMessage . '/', $contents);
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->_deleteLogs();
$testMessage = 'debug message';
CakeLog::debug($testMessage);
$contents = file_get_contents(LOGS . 'debug.log');
$this->assertContains('Debug: ' . $testMessage, $contents);
$this->assertFalse(file_exists(LOGS . 'error.log'));
$this->_deleteLogs();
}
/**
* test levels customization
*
* @return void
*/
public function testLevelCustomization() {
$this->skipIf(DIRECTORY_SEPARATOR === '\\', 'Log level tests not supported on Windows.');
$levels = CakeLog::defaultLevels();
$this->assertNotEmpty($levels);
$result = array_keys($levels);
$this->assertEquals(array(0, 1, 2, 3, 4, 5, 6, 7), $result);
$levels = CakeLog::levels(array('foo', 'bar'));
CakeLog::defaultLevels();
$this->assertEquals('foo', $levels[8]);
$this->assertEquals('bar', $levels[9]);
$levels = CakeLog::levels(array(11 => 'spam', 'bar' => 'eggs'));
CakeLog::defaultLevels();
$this->assertEquals('spam', $levels[8]);
$this->assertEquals('eggs', $levels[9]);
$levels = CakeLog::levels(array(11 => 'spam', 'bar' => 'eggs'), false);
CakeLog::defaultLevels();
$this->assertEquals(array('spam', 'eggs'), $levels);
$levels = CakeLog::levels(array('ham', 9 => 'spam', '12' => 'fam'), false);
CakeLog::defaultLevels();
$this->assertEquals(array('ham', 'spam', 'fam'), $levels);
}
/**
* Test writing log files with custom levels
*
* @return void
*/
public function testCustomLevelWrites() {
$this->_deleteLogs();
$this->_resetLogConfig();
CakeLog::levels(array('spam', 'eggs'));
$testMessage = 'error message';
CakeLog::write('error', $testMessage);
CakeLog::defaultLevels();
$this->assertTrue(file_exists(LOGS . 'error.log'));
$contents = file_get_contents(LOGS . 'error.log');
$this->assertContains('Error: ' . $testMessage, $contents);
CakeLog::config('spam', array(
'engine' => 'File',
'file' => 'spam.log',
'types' => 'spam',
));
CakeLog::config('eggs', array(
'engine' => 'File',
'file' => 'eggs.log',
'types' => array('spam', 'eggs'),
));
$testMessage = 'spam message';
CakeLog::write('spam', $testMessage);
CakeLog::defaultLevels();
$this->assertTrue(file_exists(LOGS . 'spam.log'));
$this->assertTrue(file_exists(LOGS . 'eggs.log'));
$contents = file_get_contents(LOGS . 'spam.log');
$this->assertContains('Spam: ' . $testMessage, $contents);
$testMessage = 'egg message';
CakeLog::write('eggs', $testMessage);
CakeLog::defaultLevels();
$contents = file_get_contents(LOGS . 'spam.log');
$this->assertNotContains('Eggs: ' . $testMessage, $contents);
$contents = file_get_contents(LOGS . 'eggs.log');
$this->assertContains('Eggs: ' . $testMessage, $contents);
CakeLog::drop('spam');
CakeLog::drop('eggs');
$this->_deleteLogs();
}
}

152
lib/Cake/Test/Case/Log/Engine/ConsoleLogTest.php Normal file
View file

@ -0,0 +1,152 @@
<?php
/**
* ConsoleLogTest file
*
* CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice
*
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://book.cakephp.org/2.0/en/development/testing.html CakePHP(tm) Tests
* @package Cake.Test.Case.Log.Engine
* @since CakePHP(tm) v 1.3
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('ConsoleLog', 'Log/Engine');
/**
* Class TestConsoleLog
*
* @package Cake.Test.Case.Log.Engine
*/
class TestConsoleLog extends ConsoleLog {
}
/**
* Class TestCakeLog
*
* @package Cake.Test.Case.Log.Engine
*/
class TestCakeLog extends CakeLog {
public static function replace($key, &$engine) {
self::$_Collection->{$key} = $engine;
}
}
/**
* ConsoleLogTest class
*
* @package Cake.Test.Case.Log.Engine
*/
class ConsoleLogTest extends CakeTestCase {
public function setUp() {
parent::setUp();
CakeLog::config('debug', array(
'engine' => 'File',
'types' => array('notice', 'info', 'debug'),
'file' => 'debug',
));
CakeLog::config('error', array(
'engine' => 'File',
'types' => array('error', 'warning'),
'file' => 'error',
));
}
public function tearDown() {
parent::tearDown();
if (file_exists(LOGS . 'error.log')) {
unlink(LOGS . 'error.log');
}
if (file_exists(LOGS . 'debug.log')) {
unlink(LOGS . 'debug.log');
}
}
/**
* Test writing to ConsoleOutput
*
* @return void
*/
public function testConsoleOutputWrites() {
TestCakeLog::config('test_console_log', array(
'engine' => 'TestConsole',
));
$mock = $this->getMock('TestConsoleLog', array('write'), array(
array('types' => 'error'),
));
TestCakeLog::replace('test_console_log', $mock);
$message = 'Test error message';
$mock->expects($this->once())
->method('write');
TestCakeLog::write(LOG_ERR, $message);
}
/**
* Test logging to both ConsoleLog and FileLog
*
* @return void
*/
public function testCombinedLogWriting() {
TestCakeLog::config('test_console_log', array(
'engine' => 'TestConsole',
));
$mock = $this->getMock('TestConsoleLog', array('write'), array(
array('types' => 'error'),
));
TestCakeLog::replace('test_console_log', $mock);
// log to both file and console
$message = 'Test error message';
$mock->expects($this->once())
->method('write');
TestCakeLog::write(LOG_ERR, $message);
$this->assertTrue(file_exists(LOGS . 'error.log'), 'error.log missing');
$logOutput = file_get_contents(LOGS . 'error.log');
$this->assertContains($message, $logOutput);
// TestConsoleLog is only interested in `error` type
$message = 'Test info message';
$mock->expects($this->never())
->method('write');
TestCakeLog::write(LOG_INFO, $message);
// checks that output is correctly written in the correct logfile
$this->assertTrue(file_exists(LOGS . 'error.log'), 'error.log missing');
$this->assertTrue(file_exists(LOGS . 'debug.log'), 'debug.log missing');
$logOutput = file_get_contents(LOGS . 'error.log');
$this->assertNotContains($message, $logOutput);
$logOutput = file_get_contents(LOGS . 'debug.log');
$this->assertContains($message, $logOutput);
}
/**
* test default value of stream 'outputAs'
*
* @return void
*/
public function testDefaultOutputAs() {
TestCakeLog::config('test_console_log', array(
'engine' => 'TestConsole',
));
if (DS === '\\' && !(bool)env('ANSICON')) {
$expected = ConsoleOutput::PLAIN;
} else {
$expected = ConsoleOutput::COLOR;
}
$stream = TestCakeLog::stream('test_console_log');
$config = $stream->config();
$this->assertEquals($expected, $config['outputAs']);
}
}

194
lib/Cake/Test/Case/Log/Engine/FileLogTest.php Normal file
View file

@ -0,0 +1,194 @@
<?php
/**
* FileLogTest file
*
* CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice
*
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://book.cakephp.org/2.0/en/development/testing.html CakePHP(tm) Tests
* @package Cake.Test.Case.Log.Engine
* @since CakePHP(tm) v 1.3
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('FileLog', 'Log/Engine');
/**
* CakeLogTest class
*
* @package Cake.Test.Case.Log.Engine
*/
class FileLogTest extends CakeTestCase {
/**
* testLogFileWriting method
*
* @return void
*/
public function testLogFileWriting() {
$this->_deleteLogs(LOGS);
$log = new FileLog();
$log->write('warning', 'Test warning');
$this->assertTrue(file_exists(LOGS . 'error.log'));
$result = file_get_contents(LOGS . 'error.log');
$this->assertRegExp('/^2[0-9]{3}-[0-9]+-[0-9]+ [0-9]+:[0-9]+:[0-9]+ Warning: Test warning/', $result);
$log->write('debug', 'Test warning');
$this->assertTrue(file_exists(LOGS . 'debug.log'));
$result = file_get_contents(LOGS . 'debug.log');
$this->assertRegExp('/^2[0-9]{3}-[0-9]+-[0-9]+ [0-9]+:[0-9]+:[0-9]+ Debug: Test warning/', $result);
$log->write('random', 'Test warning');
$this->assertTrue(file_exists(LOGS . 'random.log'));
$result = file_get_contents(LOGS . 'random.log');
$this->assertRegExp('/^2[0-9]{3}-[0-9]+-[0-9]+ [0-9]+:[0-9]+:[0-9]+ Random: Test warning/', $result);
}
/**
* test using the path setting to write logs in other places.
*
* @return void
*/
public function testPathSetting() {
$path = TMP . 'tests' . DS;
$this->_deleteLogs($path);
$log = new FileLog(compact('path'));
$log->write('warning', 'Test warning');
$this->assertTrue(file_exists($path . 'error.log'));
}
/**
* test log rotation
*
* @return void
*/
public function testRotation() {
$path = TMP . 'tests' . DS;
$this->_deleteLogs($path);
file_put_contents($path . 'error.log', "this text is under 35 bytes\n");
$log = new FileLog(array(
'path' => $path,
'size' => 35,
'rotate' => 2
));
$log->write('warning', 'Test warning one');
$this->assertTrue(file_exists($path . 'error.log'));
$result = file_get_contents($path . 'error.log');
$this->assertRegExp('/Warning: Test warning one/', $result);
$this->assertEquals(0, count(glob($path . 'error.log.*')));
clearstatcache();
$log->write('warning', 'Test warning second');
$files = glob($path . 'error.log.*');
$this->assertEquals(1, count($files));
$result = file_get_contents($files[0]);
$this->assertRegExp('/this text is under 35 bytes/', $result);
$this->assertRegExp('/Warning: Test warning one/', $result);
sleep(1);
clearstatcache();
$log->write('warning', 'Test warning third');
$result = file_get_contents($path . 'error.log');
$this->assertRegExp('/Warning: Test warning third/', $result);
$files = glob($path . 'error.log.*');
$this->assertEquals(2, count($files));
$result = file_get_contents($files[0]);
$this->assertRegExp('/this text is under 35 bytes/', $result);
$result = file_get_contents($files[1]);
$this->assertRegExp('/Warning: Test warning second/', $result);
file_put_contents($path . 'error.log.0000000000', "The oldest log file with over 35 bytes.\n");
sleep(1);
clearstatcache();
$log->write('warning', 'Test warning fourth');
// rotate count reached so file count should not increase
$files = glob($path . 'error.log.*');
$this->assertEquals(2, count($files));
$result = file_get_contents($path . 'error.log');
$this->assertRegExp('/Warning: Test warning fourth/', $result);
$result = file_get_contents(array_pop($files));
$this->assertRegExp('/Warning: Test warning third/', $result);
$result = file_get_contents(array_pop($files));
$this->assertRegExp('/Warning: Test warning second/', $result);
file_put_contents($path . 'debug.log', "this text is just greater than 35 bytes\n");
$log = new FileLog(array(
'path' => $path,
'size' => 35,
'rotate' => 0
));
file_put_contents($path . 'debug.log.0000000000', "The oldest log file with over 35 bytes.\n");
$log->write('debug', 'Test debug');
$this->assertTrue(file_exists($path . 'debug.log'));
$result = file_get_contents($path . 'debug.log');
$this->assertRegExp('/^2[0-9]{3}-[0-9]+-[0-9]+ [0-9]+:[0-9]+:[0-9]+ Debug: Test debug/', $result);
$this->assertFalse(strstr($result, 'greater than 5 bytes'));
$this->assertEquals(0, count(glob($path . 'debug.log.*')));
}
public function testMaskSetting() {
if (DS === '\\') {
$this->markTestSkipped('File permission testing does not work on Windows.');
}
$path = TMP . 'tests' . DS;
$this->_deleteLogs($path);
$log = new FileLog(array('path' => $path, 'mask' => 0666));
$log->write('warning', 'Test warning one');
$result = substr(sprintf('%o', fileperms($path . 'error.log')), -4);
$expected = '0666';
$this->assertEquals($expected, $result);
unlink($path . 'error.log');
$log = new FileLog(array('path' => $path, 'mask' => 0644));
$log->write('warning', 'Test warning two');
$result = substr(sprintf('%o', fileperms($path . 'error.log')), -4);
$expected = '0644';
$this->assertEquals($expected, $result);
unlink($path . 'error.log');
$log = new FileLog(array('path' => $path, 'mask' => 0640));
$log->write('warning', 'Test warning three');
$result = substr(sprintf('%o', fileperms($path . 'error.log')), -4);
$expected = '0640';
$this->assertEquals($expected, $result);
unlink($path . 'error.log');
}
/**
* helper function to clears all log files in specified directory
*
* @return void
*/
protected function _deleteLogs($dir) {
$files = array_merge(glob($dir . '*.log'), glob($dir . '*.log.*'));
foreach ($files as $file) {
unlink($file);
}
}
}

92
lib/Cake/Test/Case/Log/Engine/SyslogLogTest.php Normal file
View file

@ -0,0 +1,92 @@
<?php
/**
* CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice
*
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://book.cakephp.org/2.0/en/development/testing.html CakePHP(tm) Tests
* @package Cake.Test.Case.Log.Engine
* @since CakePHP(tm) v 2.4
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('SyslogLog', 'Log/Engine');
/**
* SyslogLogTest class
*
* @package Cake.Test.Case.Log.Engine
*/
class SyslogLogTest extends CakeTestCase {
/**
* Tests that the connection to the logger is open with the right arguments
*
* @return void
*/
public function testOpenLog() {
$log = $this->getMock('SyslogLog', array('_open', '_write'));
$log->expects($this->once())->method('_open')->with('', LOG_ODELAY, LOG_USER);
$log->write('debug', 'message');
$log = $this->getMock('SyslogLog', array('_open', '_write'));
$log->config(array(
'prefix' => 'thing',
'flag' => LOG_NDELAY,
'facility' => LOG_MAIL,
'format' => '%s: %s'
));
$log->expects($this->once())->method('_open')
->with('thing', LOG_NDELAY, LOG_MAIL);
$log->write('debug', 'message');
}
/**
* Tests that single lines are written to syslog
*
* @dataProvider typesProvider
* @return void
*/
public function testWriteOneLine($type, $expected) {
$log = $this->getMock('SyslogLog', array('_open', '_write'));
$log->expects($this->once())->method('_write')->with($expected, $type . ': Foo');
$log->write($type, 'Foo');
}
/**
* Tests that multiple lines are split and logged separately
*
* @return void
*/
public function testWriteMultiLine() {
$log = $this->getMock('SyslogLog', array('_open', '_write'));
$log->expects($this->at(1))->method('_write')->with(LOG_DEBUG, 'debug: Foo');
$log->expects($this->at(2))->method('_write')->with(LOG_DEBUG, 'debug: Bar');
$log->expects($this->exactly(2))->method('_write');
$log->write('debug', "Foo\nBar");
}
/**
* Data provider for the write function test
*
* @return array
*/
public function typesProvider() {
return array(
array('emergency', LOG_EMERG),
array('alert', LOG_ALERT),
array('critical', LOG_CRIT),
array('error', LOG_ERR),
array('warning', LOG_WARNING),
array('notice', LOG_NOTICE),
array('info', LOG_INFO),
array('debug', LOG_DEBUG)
);
}
}

89
lib/Cake/Test/Case/Log/LogEngineCollectionTest.php Normal file
View file

@ -0,0 +1,89 @@
<?php
/**
* LogEngineCollectionTest file
*
* CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice
*
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://book.cakephp.org/2.0/en/development/testing.html CakePHP(tm) Tests
* @package Cake.Test.Case.Log
* @since CakePHP(tm) v 2.4
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('LogEngineCollection', 'Log');
App::uses('FileLog', 'Log/Engine');
/**
* LoggerEngineLog class
*/
class LoggerEngineLog extends FileLog {
}
/**
* LogEngineCollectionTest class
*
* @package Cake.Test.Case.Log
*/
class LogEngineCollectionTest extends CakeTestCase {
public $Collection;
/**
* Start test callback
*
* @return void
*/
public function setUp() {
parent::setUp();
$this->Collection = new LogEngineCollection();
}
/**
* test load
*
* @return void
*/
public function testLoad() {
$result = $this->Collection->load('key', array('engine' => 'File'));
$this->assertInstanceOf('CakeLogInterface', $result);
}
/**
* test load with deprecated Log suffix
*
* @return void
*/
public function testLoadWithSuffix() {
$result = $this->Collection->load('key', array('engine' => 'FileLog'));
$this->assertInstanceOf('CakeLogInterface', $result);
}
/**
* test that engines starting with Log also work properly
*
* @return void
*/
public function testLoadWithSuffixAtBeginning() {
$result = $this->Collection->load('key', array('engine' => 'LoggerEngine'));
$this->assertInstanceOf('CakeLogInterface', $result);
}
/**
* test load with invalid Log
*
* @return void
* @expectedException CakeLogException
*/
public function testLoadInvalid() {
$result = $this->Collection->load('key', array('engine' => 'ImaginaryFile'));
$this->assertInstanceOf('CakeLogInterface', $result);
}
}