PHP CMTest_TH::getProtectedMethod方法代码示例

 /**
  * @expectedException CM_Exception
  * @expectedExceptionMessage Path is out of filesystem directory
  */
 public function testGetRelativePathOutOfFilesystem()
 {
     $adapter = $this->getMockBuilder('CM_File_Filesystem_Adapter')->setConstructorArgs(array('/base/base2'))->getMockForAbstractClass();
     /** @var CM_File_Filesystem_Adapter $adapter */
     $method = CMTest_TH::getProtectedMethod('CM_File_Filesystem_Adapter', '_getRelativePath');
     $method->invoke($adapter, '/base/base2/../foo');
 }

 public function testGetCollectionName()
 {
     CM_Config::get()->CM_Model_Abstract = new stdClass();
     CM_Config::get()->CM_Model_Abstract->types = [1 => 'CMTest_ModelMock_3', 2 => 'CMTest_ModelMock_4'];
     $adapter = new CM_Model_StorageAdapter_MongoDb();
     $method = CMTest_TH::getProtectedMethod('CM_Model_StorageAdapter_MongoDb', '_getCollectionName');
     $this->assertSame('cmtest_modelmock_3', $method->invoke($adapter, 1));
     $this->assertSame('custom_table', $method->invoke($adapter, 2));
 }

 public function testGetTableName()
 {
     CM_Config::get()->CM_Model_Abstract = new stdClass();
     CM_Config::get()->CM_Model_Abstract->types = array(1 => 'CMTest_ModelMock_1', 2 => 'CMTest_ModelMock_2');
     $adapter = new CM_Model_StorageAdapter_Database();
     $method = CMTest_TH::getProtectedMethod('CM_Model_StorageAdapter_Database', '_getTableName');
     $this->assertSame('cmtest_modelmock_1', $method->invoke($adapter, 1));
     $this->assertSame('custom_table', $method->invoke($adapter, 2));
 }

 public function testGetCacheKey()
 {
     CM_Config::get()->CM_Model_Abstract = new stdClass();
     CM_Config::get()->CM_Model_Abstract->types = array(1 => 'CMTest_ModelMock_1', 2 => 'CMTest_ModelMock_2');
     $adapter = new CM_Model_StorageAdapter_Cache();
     $method = CMTest_TH::getProtectedMethod('CM_Model_StorageAdapter_Cache', '_getCacheKey');
     $this->assertSame('CM_Model_StorageAdapter_Cache_type:1_id:a:1:{s:2:"id";i:2;}', $method->invoke($adapter, 1, array('id' => 2)));
     $this->assertSame('CM_Model_StorageAdapter_Cache_type:2_id:a:1:{s:2:"id";i:3;}', $method->invoke($adapter, 2, array('id' => 3)));
 }

 public function testExtractTraceRow()
 {
     $trace = array(array('file' => 'test.php', 'line' => 18, 'function' => 'foo', 'args' => array()), array('file' => 'test.php', 'line' => 26, 'function' => 'bar', 'class' => 'Foo', 'type' => '->', 'args' => array()), array('file' => 'test.php(28) : eval()\'d code', 'line' => 1, 'function' => '{closure}', 'args' => array()), array('file' => 'test.php', 'line' => 28, 'function' => 'eval'));
     $expected = array(array('code' => 'foo()', 'file' => 'test.php', 'line' => 18), array('code' => 'Foo->bar()', 'file' => 'test.php', 'line' => 26), array('code' => '{closure}()', 'file' => 'test.php(28) : eval()\'d code', 'line' => 1), array('code' => 'eval', 'file' => 'test.php', 'line' => 28));
     $exception = $this->getMockBuilder('Exception')->setMethods(array('getTrace'))->getMockForAbstractClass();
     $exception->expects($this->any())->method('getTrace')->will($this->returnValue($trace));
     $method = CMTest_TH::getProtectedMethod('CM_ExceptionHandling_SerializableException', '_extractTraceRow');
     foreach ($trace as $key => $traceRow) {
         $this->assertSame($expected[$key], $method->invoke(null, $traceRow));
     }
 }

 public function testIsInt()
 {
     $schema = new CM_Model_Schema_Definition(array());
     $_isInt = CMTest_TH::getProtectedMethod('CM_Model_Schema_Definition', '_isInt');
     $this->assertTrue($_isInt->invoke($schema, 1));
     $this->assertTrue($_isInt->invoke($schema, '1'));
     $this->assertFalse($_isInt->invoke($schema, 1.2));
     $this->assertFalse($_isInt->invoke($schema, '1.0'));
     $this->assertFalse($_isInt->invoke($schema, '4E2'));
     $this->assertFalse($_isInt->invoke($schema, 400.0));
 }

 public function testGetPackageFromComposerPackageMissingExtra()
 {
     $composerPackage = $this->getMockBuilder('\\Composer\\Package\\CompletePackage')->setMethods(array('getName', 'getPrettyName', 'getExtra'))->disableOriginalConstructor()->getMock();
     $composerPackage->expects($this->any())->method('getName')->will($this->returnValue('foo'));
     $composerPackage->expects($this->any())->method('getPrettyName')->will($this->returnValue('foo'));
     $composerPackage->expects($this->any())->method('getExtra')->will($this->returnValue(array()));
     /** @var \Composer\Package\CompletePackage $composerPackage */
     $installation = $this->getMockBuilder('CM_App_Installation')->disableOriginalConstructor()->setMethods(array('_getComposerVendorDir'))->getMock();
     $installation->expects($this->any())->method('_getComposerVendorDir')->will($this->returnValue('vendor/'));
     $method = CMTest_TH::getProtectedMethod('CM_App_Installation', '_getPackageFromComposerPackage');
     /** @var CM_App_Package $package */
     $package = $method->invoke($installation, $composerPackage);
     $this->assertSame(array(), $package->getModules());
 }

 public function testCleanUp()
 {
     $paging = $this->getMockBuilder('CM_Paging_Log_Abstract')->disableOriginalConstructor()->setMethods(array('getType'))->getMockForAbstractClass();
     $paging->expects($this->any())->method('getType')->will($this->returnValue(1));
     /** @var CM_Paging_Log_Abstract $paging */
     $paging->__construct();
     $this->assertSame(0, $paging->getCount());
     CMTest_TH::getProtectedMethod($paging, '_add')->invoke($paging, 'foo');
     $paging->_change();
     $this->assertSame(1, $paging->getCount());
     $age = 7 * 86400;
     CMTest_TH::timeForward($age);
     $paging->cleanUp();
     $this->assertSame(0, $paging->getCount());
 }

 public function testLogExceptionFileLog()
 {
     $errorLog = CM_Bootloader::getInstance()->getDirTmp() . uniqid();
     $log = $this->getMockBuilder('CM_Paging_Log_Error')->setMethods(array('add'))->disableOriginalConstructor()->getMock();
     $log->expects($this->any())->method('add')->will($this->throwException(new Exception('foo')));
     $exception = $this->getMockBuilder('CM_Exception')->setMethods(array('getLog', 'getMetaInfo'))->getMock();
     $exception->expects($this->any())->method('getLog')->will($this->returnValue($log));
     $exception->expects($this->any())->method('getMetaInfo')->will($this->returnValue(array()));
     $method = CMTest_TH::getProtectedMethod('CM_ExceptionHandling_Handler_Abstract', 'logException');
     $exceptionHandler = $this->getMockBuilder('CM_ExceptionHandling_Handler_Abstract')->setMethods(array('_getLogFile'))->getMockForAbstractClass();
     $exceptionHandler->expects($this->any())->method('_getLogFile')->will($this->returnValue(new CM_File($errorLog)));
     $this->assertFileNotExists($errorLog);
     $method->invoke($exceptionHandler, $exception);
     $logContents = file_get_contents($errorLog);
     $this->assertNotEmpty($logContents);
     $this->assertContains('### Cannot log error: ', $logContents);
     $this->assertContains('### Original Exception: ', $logContents);
 }

 public function testDeleteOnUnsubscribeInvalid()
 {
     $streamSubscribe = $this->getMockBuilder('CM_Model_Stream_Subscribe')->setMethods(array('getStreamChannel', 'getId'))->getMock();
     $streamChannel = $this->getMockBuilder('CM_Model_StreamChannel_Media')->setMethods(array('isValid', 'onUnsubscribe'))->getMock();
     $streamSubscribe->expects($this->any())->method('getStreamChannel')->will($this->returnValue($streamChannel));
     $streamChannel->expects($this->any())->method('isValid')->will($this->returnValue(false));
     $streamChannel->expects($this->never())->method('onUnsubscribe');
     /** @var CM_Model_StreamChannel_Media $streamChannel */
     /** @var CM_Model_Stream_Subscribe $streamSubscribe */
     $onDelete = CMTest_TH::getProtectedMethod('CM_Model_Stream_Subscribe', '_onDelete');
     $onDelete->invoke($streamSubscribe);
 }

 public function testSetData()
 {
     $data = array('bar' => '23', 'foo' => 'bar');
     $dataNew = array('baar' => '23', 'fooo' => 'bar');
     $model = $this->getMockBuilder('CM_Model_Abstract')->setConstructorArgs(array())->getMockForAbstractClass();
     /** @var CM_Model_Abstract $model */
     $getData = CMTest_TH::getProtectedMethod('CM_Model_Abstract', '_getData');
     $setData = CMTest_TH::getProtectedMethod('CM_Model_Abstract', '_setData');
     $this->assertSame(array(), $getData->invoke($model));
     $setData->invoke($model, $data);
     $this->assertSame($data, $getData->invoke($model));
     $setData->invoke($model, $dataNew);
     $this->assertSame($dataNew, $getData->invoke($model));
 }

 /**
  * @param DateTime     $start
  * @param DateTimeZone $timeZone
  * @throws CM_Exception_Invalid
  */
 private function _testIntervalModeDST(DateTime $start, DateTimeZone $timeZone)
 {
     $currently = clone $start;
     $managerMock = $this->mockClass('CM_Clockwork_Manager');
     $managerMock->mockMethod('_getCurrentDateTimeUTC')->set(function () use(&$currently) {
         return clone $currently;
     });
     $storageClass = $this->mockClass('CM_Clockwork_Storage_Abstract');
     $storageClass->mockMethod('getLastRuntime')->set(function () use(&$lastRuntime) {
         if ($lastRuntime instanceof DateTime) {
             return clone $lastRuntime;
         }
         return $lastRuntime;
     });
     /** @var CM_Clockwork_Storage_FileSystem $storage */
     $storage = $storageClass->newInstanceWithoutConstructor();
     /** @var CM_Clockwork_Manager $manager */
     $manager = $managerMock->newInstance();
     $manager->setStorage($storage);
     $manager->setTimeZone($timeZone);
     $_shouldRun = CMTest_TH::getProtectedMethod('CM_Clockwork_Manager', '_shouldRun');
     $event = new CM_Clockwork_Event('event', '20 minutes');
     $lastRuntime = null;
     $this->assertFalse($_shouldRun->invoke($manager, $event));
     $currently->modify('19 minutes 59 seconds');
     $this->assertFalse($_shouldRun->invoke($manager, $event));
     $currently->modify('1 second');
     $this->assertTrue($_shouldRun->invoke($manager, $event));
     $lastRuntime = clone $currently;
     $currently->modify('19 minutes 59 seconds');
     $this->assertFalse($_shouldRun->invoke($manager, $event));
     $currently->modify('1 second');
     $this->assertTrue($_shouldRun->invoke($manager, $event));
     $lastRuntime = clone $currently;
     $currently->modify('19 minutes 59 seconds');
     $this->assertFalse($_shouldRun->invoke($manager, $event));
     $currently->modify('1 second');
     $this->assertTrue($_shouldRun->invoke($manager, $event));
     if ($timeZone->getOffset($start) === $timeZone->getOffset($currently)) {
         throw new CM_Exception_Invalid("Test did not go through a daylight saving time switch");
     }
 }

 public function testDeleteOnUnpublishInvalid()
 {
     $streamPublish = $this->getMockBuilder('CM_Model_Stream_Publish')->setMethods(array('getStreamChannel', 'getId'))->getMock();
     $streamChannel = $this->getMockBuilder('CM_Model_StreamChannel_Video')->setMethods(array('isValid', 'onUnpublish'))->getMock();
     $streamPublish->expects($this->any())->method('getStreamChannel')->will($this->returnValue($streamChannel));
     $streamChannel->expects($this->any())->method('isValid')->will($this->returnValue(false));
     $streamChannel->expects($this->never())->method('onUnpublish');
     /** @var CM_Model_StreamChannel_Video $streamChannel */
     /** @var CM_Model_Stream_Publish $streamPublish */
     $onDelete = CMTest_TH::getProtectedMethod('CM_Model_Stream_Publish', '_onDelete');
     $onDelete->invoke($streamPublish);
 }

 public function testNotify()
 {
     $actor = CMTest_TH::createUser();
     $action = $this->getMockBuilder('CM_Action_Abstract')->setMethods(array('_notifyFoo', '_track'))->setConstructorArgs(array('foo', $actor))->getMockForAbstractClass();
     $action->expects($this->once())->method('_notifyFoo')->with('bar');
     $method = CMTest_TH::getProtectedMethod('CM_Action_Abstract', '_notify');
     $method->invoke($action, 'bar');
 }