public function testCreateInstanceWithRingPHP()
 {
     $log = $trace = Stub::make('\\Monolog\\Logger', []);
     $ringphp_handler = Stub::make('WyriHaximus\\React\\RingPHP\\HttpClientAdapter');
     $connection = new Guzzle5Connection(['host' => 'localhost', 'port' => 9200, 'ringphp_handler' => $ringphp_handler], null, $log, $trace);
     $this->assertInstanceOf('Iwai\\Elasticsearch\\Guzzle5Connection', $connection);
 }

 public function run(CodeGuy $I)
 {
     $I->wantTo('run steps from scenario');
     $I->haveStub($test = Stub::makeEmpty('\\Codeception\\TestCase\\Cept'));
     $I->haveStub($scenario = Stub::make('\\Codeception\\Scenario', array('test' => $test, 'steps' => Stub::factory('\\Codeception\\Step', 2))));
     $I->executeTestedMethodOn($scenario)->seeMethodInvoked($test, 'runStep')->seePropertyEquals($scenario, 'currentStep', 1);
 }

 protected function makeTest()
 {
     return Stub::makeEmpty(
         '\Codeception\TestCase\Cept',
         array('dispatcher' => Stub::makeEmpty('Symfony\Component\EventDispatcher\EventDispatcher'))
     );
 }

 public function testHaveAndSeeInDatabase()
 {
     $this->module->haveInDatabase('users', array('name' => 'john'));
     $this->module->seeInDatabase('users', array('name' => 'john'));
     $this->module->_before(\Codeception\Util\Stub::make('\\Codeception\\TestCase'));
     $this->module->dontSeeInDatabase('users', array('name' => 'john'));
 }

 protected function makeTestCase($file, $name = '')
 {
     return Stub::make('\Codeception\Lib\DescriptiveTestCase', [
             'getReportFields' => ['file' => codecept_root_dir() . $file],
             'getName' => $name]
     );
 }

 public function constructDumbGenericCLI($params = array(), $override = array())
 {
     $defaultParams = array('namespace' => 'DumbExtension', 'type' => 'cli');
     $defaultOverride = array();
     $instance = Stub::construct('\\Alledia\\Framework\\Joomla\\Extension\\Generic', array_merge($defaultParams, $params), array_merge($defaultOverride, $override));
     return $instance;
 }

 protected function makeCommand($className, $saved = true, $extraMethods = [])
 {
     if (!$this->config) {
         $this->config = [];
     }
     $self = $this;
     $mockedMethods = ['save' => function ($file, $output) use($self, $saved) {
         if (!$saved) {
             return false;
         }
         $self->filename = $file;
         $self->content = $output;
         $self->log[] = ['filename' => $file, 'content' => $output];
         $self->saved[$file] = $output;
         return true;
     }, 'getGlobalConfig' => function () use($self) {
         return $self->config;
     }, 'getSuiteConfig' => function () use($self) {
         return $self->config;
     }, 'buildPath' => function ($path, $testName) {
         $path = rtrim($path, DIRECTORY_SEPARATOR);
         $testName = str_replace(['/', '\\'], [DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR], $testName);
         return pathinfo($path . DIRECTORY_SEPARATOR . $testName, PATHINFO_DIRNAME) . DIRECTORY_SEPARATOR;
     }, 'getSuites' => function () {
         return ['shire'];
     }, 'getApplication' => function () {
         return new \Codeception\Util\Maybe();
     }];
     $mockedMethods = array_merge($mockedMethods, $extraMethods);
     $this->command = Stub::construct($className, [$this->commandName], $mockedMethods);
 }

 public function testDispatchMethod()
 {
     $separator = Storage::$separator;
     $method = self::getPrivateMethod('dispatch');
     $structure = $method->invoke(Stub::make(self::$class), "base{$separator}inner{$separator}key");
     $this->assertEquals($structure, array('base', 'inner', 'key'), 'Parsing of the passed path is failed');
 }

 /**
  * @return Client
  */
 private static function create()
 {
     /** @var Delivery $delivery */
     $delivery = Stub::make('ArchiDelivery\\Delivery');
     $client = new Client($delivery);
     return $client;
 }

 public function testParsingASimpleRequest()
 {
     // Given...
     $repository = Stub::makeEmpty('Doctrine\\ORM\\EntityRepository', ['__call' => function ($name) {
         switch ($name) {
             case 'findOneById':
                 return self::AUTHOR_ENTITY;
                 break;
             case 'findById':
                 return self::COMMENT_ENTITIES;
                 break;
         }
     }]);
     $authorRelationship = Stub::makeEmpty('GoIntegro\\Hateoas\\Metadata\\Resource\\ResourceRelationship');
     $commentsRelationship = Stub::makeEmpty('GoIntegro\\Hateoas\\Metadata\\Resource\\ResourceRelationship');
     $relationships = Stub::makeEmpty('GoIntegro\\Hateoas\\Metadata\\Resource\\ResourceRelationships', ['toOne' => ['author' => $authorRelationship], 'toMany' => ['comments' => $commentsRelationship]]);
     $metadata = Stub::makeEmpty('GoIntegro\\Hateoas\\Metadata\\Resource\\ResourceMetadata', ['relationships' => $relationships, 'isToOneRelationship' => TRUE, 'isToManyRelationship' => TRUE]);
     $em = Stub::makeEmpty('Doctrine\\ORM\\EntityManagerInterface', ['getRepository' => $repository]);
     $mm = Stub::makeEmpty('GoIntegro\\Hateoas\\Metadata\\Resource\\MetadataMinerInterface', ['mine' => $metadata]);
     $hydrant = new ResourceLinksHydrant($em, $mm);
     $params = Stub::makeEmpty('GoIntegro\\Hateoas\\JsonApi\\Request\\Params', ['primaryClass' => "HateoasInc\\Bundle\\ExampleBundle\\Entity\\User"]);
     $resourceObject = ['content' => "Meh.", 'links' => ['author' => '5', 'comments' => ['45', '54', '67']]];
     // When...
     $hydrant->hydrate($params, $resourceObject);
     $expected = ['content' => "Meh.", 'links' => ['author' => self::AUTHOR_ENTITY, 'comments' => self::COMMENT_ENTITIES]];
     // Then...
     $this->assertEquals($expected, $resourceObject);
 }

 public function testGetHttpClient()
 {
     /** @var \AwesomeMotive\Drip\Token $token */
     $token = Stub::make("\\AwesomeMotive\\Drip\\Token", ['get_accessToken' => '1234']);
     $this->drip->set_token($token);
     $client = $this->drip->get_httpClient();
     $this->assertInstanceOf("\\GuzzleHttp\\Client", $client);
 }

 public function test_unserialize_real_serialized_object()
 {
     $user = Stub::make('StdClass', array('username' => 'username', 'email' => '[email protected]'));
     $so = new SerializedObject(serialize($user));
     $result = $so->unserialize();
     $this->assertEquals($result->username, 'username');
     $this->assertEquals($result->email, '[email protected]');
 }

 public function _before()
 {
     //echo "ENV:".getenv('thisTestRun_testIncludePath');
     //die();
     //chdir(getenv('thisTestRun_testIncludePath'));
     //require_once "system/classes/Config.php";
     $this->config = Stub::construct('Config');
 }

 public function testDelete()
 {
     $file = Stub::construct('\\Uploads\\models\\UploadedFile', ['filePath' => $this->baseTestFileString], ['getOwnerClass' => 'Test', 'getOwnerId' => 2, 'getDirToUpload' => yii::getAlias(implode(DIRECTORY_SEPARATOR, ['@backend', 'web', 'upload']))]);
     $file->save();
     $filePath = $file->fullPath;
     $file->delete();
     $this->assertFalse(file_exists($filePath));
 }

 public function testHaveAndSeeInDatabase()
 {
     $user_id = $this->module->haveInDatabase('users', array('name' => 'john', 'email' => '[email protected]'));
     $this->assertInternalType('integer', $user_id);
     $this->module->seeInDatabase('users', array('name' => 'john', 'email' => '[email protected]'));
     $this->module->_after(\Codeception\Util\Stub::make('\Codeception\TestCase'));
     $this->module->dontSeeInDatabase('users', array('name' => 'john'));
 }

 public function testIsCloudflareRequest()
 {
     $tests = [[Stub::makeEmpty(RequestAdapter::class, ['getRemoteAddr' => '103.21.244.2', 'getHeaders' => ['cf-connecting-ip' => '127.0.0.1']]), true], [Stub::makeEmpty(RequestAdapter::class, ['getRemoteAddr' => '103.22.200.1', 'getHeaders' => ['cf-connecting-ip' => '127.0.0.1']]), true], [Stub::makeEmpty(RequestAdapter::class, ['getRemoteAddr' => '103.21.243.2', 'getHeaders' => ['cf-connecting-ip' => '127.0.0.1']]), false], [Stub::makeEmpty(RequestAdapter::class, ['getRemoteAddr' => '103.21.244.2', 'getHeaders' => ['custom-ip' => '127.0.0.1']]), false]];
     foreach ($tests as $testData) {
         list($request, $result) = $testData;
         $this->assertEquals($result, (new CloudflareDetector($this->ipAddresses, $request))->isCloudflareRequest());
     }
 }

 public function convertWithException(\CodeGuy $I)
 {
     $I->wantTo("test if converting of different measure types fails.");
     $I->haveStub($converter = Stub::make($this->class));
     $I->amTestingMethod('\\Measure\\Converter.convert');
     $I->executeTestedMethodOn($converter, 1, 'liter', 'kg');
     $I->seeExceptionThrown('\\ErrorException');
 }

 public function testGetDocumentsIdsReturnsEmptyArray()
 {
     $query = Stub::make(SearchQuery::class, ['getFilters' => function () {
         return [];
     }]);
     $this->object = new ResultSet($query, []);
     $this->assertSame([], $this->object->getDocumentIds());
 }

 public function testBeforeHookResetsVariables()
 {
     $this->module->haveHttpHeader('Origin', 'http://www.example.com');
     $this->module->sendGET('/rest/user/');
     $this->assertEquals('http://www.example.com', $this->module->client->getServerParameter('HTTP_ORIGIN'));
     $this->module->_before(Stub::makeEmpty('\\Codeception\\TestCase\\Cest'));
     $this->assertNull($this->module->client->getServerParameter('HTTP_ORIGIN', null));
 }

 /**
  * When running multiple environments, getClassesFromFile() method in SuiteManager is called once for each env.
  * See \Codeception\Codecept::runSuite() - for each env new SuiteManager is created and tests loaded.
  * Make sure that calling getClassesFromFile() multiple times will always return the same classes.
  *
  * @group core
  */
 public function testAddCestWithEnv()
 {
     $file = \Codeception\Configuration::dataDir() . 'SimpleCestWithNamespace.php';
     $this->suiteman->addCest($file);
     $this->assertEquals(3, $this->suiteman->getSuite()->count());
     $newSuiteMan = Stub::make('\\Codeception\\SuiteManager', array('dispatcher' => $this->dispatcher, 'suite' => new PHPUnit_Framework_TestSuite(), 'settings' => array('bootstrap' => false, 'class_name' => 'CodeGuy', 'namespace' => '')));
     $newSuiteMan->addCest($file);
     $this->assertEquals(3, $newSuiteMan->getSuite()->count());
 }