/**
* Register a mock shell instance with Diesel
*/
protected function registerMockShell($mockShell = null)
{
if (!$mockShell) {
$mockShell = $this->getMock('Bart\\Shell');
}
Diesel::registerInstantiator('Bart\\Shell', $mockShell, true);
}
/**
* Register a git stub with Diesel
* @return \Bart\Git git stub that was registered
*/
public function getGitStub()
{
// mock git and method get change id to return $repo
$gitStub = $this->getMock('\\Bart\\Git', array(), array(), '', false);
Diesel::registerInstantiator('Bart\\Git', function () use($gitStub) {
return $gitStub;
});
return $gitStub;
}
/**
* Register our mock soap instance with local Diesel
*/
private function register_soap_with_diesel()
{
$phpu = $this;
Diesel::registerInstantiator('\\SoapClient', function ($wsdl, $options) use($phpu) {
$phpu->assertEquals($phpu->opts['wsdl'], $wsdl, 'wsdl');
$phpu->assertEquals($phpu->opts['key'], $options['key'], 'opts');
return $phpu->soap;
});
}
/**
* Configure Job for injection of stub Curl with $json
* @param string $url Expected Jenkins URL
* @param JSON $json
*/
private function configure_diesel($url, $json)
{
$mock_curl = $this->getMock('\\Bart\\Curl', array(), array(), '', false);
$mock_curl->expects($this->once())->method('get')->with($this->equalTo(''), $this->equalTo(array()))->will($this->returnValue(array('content' => $json)));
$phpu = $this;
Diesel::registerInstantiator('Bart\\Curl', function ($urlParam, $portParam) use($phpu, $url, $mock_curl) {
$phpu->assertEquals($url, $urlParam, 'url');
$phpu->assertEquals(8080, $portParam, 'port');
return $mock_curl;
});
}
private function configure_for($conf, $is_healthy, $job_name)
{
$mock_job = $this->getMock('\\Bart\\Jenkins\\Job', array(), array(), '', false);
$mock_job->expects($this->once())->method('is_healthy')->will($this->returnValue($is_healthy));
$gitStub = $this->getGitStub();
$phpu = $this;
Diesel::registerInstantiator('Bart\\Jenkins\\Job', function ($host, $jobNameParam) use($phpu, $conf, $job_name, $mock_job) {
$phpu->assertEquals($job_name, $jobNameParam, 'Jenkins job name');
$phpu->assertEquals($conf['jenkins']['host'], $host, 'Jenkins host');
return $mock_job;
});
return array('stl' => new StopTheLineJenkins($conf, '', 'Gorg'), 'git' => $gitStub);
}
/**
* @integrationTest
*/
public function testRawFileContentsReal()
{
// Let's make sure the command we're running is legit
$expectedContents = trim(shell_exec('git show HEAD:composer.json'));
// Replicate the actual shell invocation that would take place
Diesel::registerInstantiator('Bart\\Shell\\Command', function () {
$shell = new Shell();
$args = func_get_args();
return call_user_func_array([$shell, 'command'], $args);
});
$commit = new Commit(new GitRoot(BART_DIR . '/.git'), 'HEAD');
$actualContents = trim($commit->rawFileContents('composer.json'));
$this->assertEquals($expectedContents, $actualContents, 'Raw file contents');
}
public function testConstructor()
{
$conf = array();
// mock git and method get_change_id to return $repo
$mock_git = $this->getMock('\\Bart\\Git', array(), array(), '', false);
$mock_git->expects($this->once())->method('get_change_id')->will($this->returnValue('grinder'));
$phpu = $this;
Diesel::registerInstantiator('Bart\\Git', function ($gitDir) use($mock_git, $phpu) {
$phpu->assertEquals('.git', $gitDir, 'Expected constructor to get git dir');
return $mock_git;
});
$hook = new TestGitHookAction($conf, '.git', 'grinder');
$hook->run($this);
}
/**
* Basic, shared setup for the Build_In_Jenkins hook
*
* @param array $conf Configurations for the hook
* @param string $commit_msg The commit message for the hook
* @param string $job_name The name of the job to be built
* @return array The git hook and the git stub
*/
private function configure_for(array $conf, $commit_msg, $job_name)
{
$hash = 'HEAD';
$info = array('author' => self::$author, 'subject' => '', 'message' => $commit_msg);
$mock_git = $this->getGitStub();
$mock_git->expects($this->once())->method('get_pretty_email')->with($this->equalTo($hash))->will($this->returnValue($info));
$phpu = $this;
$mock_job = $this->getMock('\\Bart\\Jenkins\\Job', array(), array(), '', false);
Diesel::registerInstantiator('Bart\\Jenkins\\Job', function ($host, $name) use($phpu, $conf, $job_name, $mock_job) {
$phpu->assertEquals($job_name, $name, 'Jenkins job name did not match');
$phpu->assertEquals($conf['jenkins']['host'], $host, 'Expected host to match conf');
return $mock_job;
});
return array('j' => new BuildInJenkins($conf, '', self::$repo), 'git' => $mock_git, 'job' => $mock_job);
}
public function testUnderscoresSupported()
{
Diesel::registerInstantiator('\\Bart\\Shell', function () {
// Actually want to see how this works with a real Shell
return new Shell();
});
$this->doStuffWithTempDir(function (BaseTestCase $phpu, $dirName) {
Configuration::configure($dirName);
// Copy sample INI file to path Configuration will look for TestConfig INI
copy(BART_DIR . '/test/etc/conf-parser.conf', $dirName . '/test_underscore.conf');
$configs = new Test_Underscore_Config(false);
$phpu->assertEquals(42, $configs->number(), 'Underscore Configs number');
$phpu->assertEquals('Quail', $configs->wildGame(), 'Underscore Configs wildGame');
});
}
public function testBasicCommandExec()
{
$root = new GitRoot();
$command = CommandTest::withStubbedResult($this, ['a57a266'], 0);
Diesel::registerInstantiator('Bart\\Shell\\Command', function ($fmt, $dir, $limit, $author, $pretty) use($command) {
// Assert that GitRoot sends expected parameters to create the Command
$this->assertEquals('git --git-dir=%s log %s --author=%s --format:%s', $fmt, 'command arg 0');
$this->assertEquals('.git', $dir);
$this->assertEquals('-1', $limit, 'Limit of commits');
$this->assertEquals('jbraynard', $author);
$this->assertEquals('%h', $pretty, 'pretty format');
return $command;
});
// Throw something together with a few args interspersed
$result = $root->getCommandResult('log %s --author=%s --format:%s', '-1', 'jbraynard', '%h');
$this->assertEquals('a57a266', $result->getOutput(true), 'git log');
}
/**
* Stub the expected configuration
* @param bool $buildHealth
*/
private function mockJenkinsJobWithDependencies($buildHealth = true)
{
$this->shmockAndDieselify('\\Bart\\Jenkins\\JenkinsConfig', function ($jConfigs) {
$jConfigs->domain()->once()->return_value('jenkins.example.com');
$jConfigs->port()->once()->return_value('8080');
$jConfigs->protocol()->once()->return_value('http');
$jConfigs->user()->once()->return_value('user');
$jConfigs->token()->once()->return_value('token');
$jConfigs->jobLocation()->once()->return_value('job/Base/job/Build');
}, true);
$mockConnection = $this->shmockAndDieselify('\\Bart\\Jenkins\\Connection', function ($connection) {
$connection->setAuth()->once();
}, true);
$mockJob = $this->shmock('\\Bart\\Jenkins\\Job', function ($jobStub) use($buildHealth) {
$jobStub->isHealthy()->once()->return_value($buildHealth);
}, true);
Diesel::registerInstantiator('\\Bart\\Jenkins\\Job', function ($connection) use($mockJob, $mockConnection) {
$this->assertEquals($mockConnection, $connection, '\\Bart\\Jenkins\\Connection object');
return $mockJob;
});
}
/**
* Mocks out the Diesel Curl class
* @param callable $configure
* @param string $expectedProtocol
* @param string $expectedPort
* @throws \Bart\DieselException
*/
private function mockCurl($configure, $expectedProtocol = 'http', $expectedPort = '8080')
{
$fullUrl = "{$expectedProtocol}://" . self::$fakeDomain . ":{$expectedPort}/" . self::$fakeApiPath;
$mockCurl = $this->shmock('\\Bart\\Curl', function ($curlStub) use($configure) {
$configure($curlStub);
}, true);
Diesel::registerInstantiator('\\Bart\\Curl', function ($url, $port) use($mockCurl, $fullUrl, $expectedPort) {
$this->assertEquals($fullUrl, $url, 'Full Jenkins REST API URL');
$this->assertEquals($expectedPort, $port, 'Port');
return $mockCurl;
});
}
/**
* @param String $remoteGerritCmd
* @param \PHPUnit_Framework_MockObject_Stub $will
* @return Api
*/
private function configureApiForCmd($remoteGerritCmd, $will)
{
$ssh = $this->getMock('\\Bart\\SshWrapper', array(), array(), '', false);
$ssh->expects($this->once())->method('exec')->with($this->equalTo($remoteGerritCmd))->will($will);
$gerritConfigs = $this->gerritConfigs;
Diesel::registerInstantiator('Bart\\Configuration\\GerritConfig', function () use($gerritConfigs) {
return $gerritConfigs;
});
$phpu = $this;
Diesel::registerInstantiator('Bart\\SshWrapper', function ($server, $port) use($ssh, $phpu) {
$phpu->assertEquals('gerrit.example.com', $server, 'gerrit server');
$phpu->assertEquals(29418, $port, 'gerrit ssh port');
return $ssh;
});
return new Api();
}
/**
* @param string[] $stdInArray Array of standard input values
* @param string[] $revList Array of revisions
* @param string[] $validRefs Array of all valid refs
* @param int $numValidRefs Number of valid refs in the standard input array that are actually in $validRefs
*/
private function runProcessRevisionTest(array $stdInArray, array $revList, array $validRefs, $numValidRefs, $emergency = false)
{
$numInputs = count($stdInArray);
$numRevs = count($revList);
$message = $emergency ? "EMERGENCY commit" : "This message will be ignored";
$this->shmockAndDieselify('\\Bart\\Shell', function ($shell) use($stdInArray) {
$shell->realpath(self::POST_RECEIVE_PATH)->once()->return_value(self::POST_RECEIVE_REAL_PATH);
$shell->std_in()->once()->return_value($stdInArray);
});
$this->shmockAndDieselify('\\Bart\\Git\\GitRoot', function ($gitRoot) {
$gitRoot->getCommandResult()->never();
}, true);
$this->shmockAndDieselify('\\Bart\\Git', function ($git) use($revList, $numValidRefs) {
if ($numValidRefs === 0) {
$git->getRevList()->never();
} else {
$git->getRevList(self::START_HASH, self::END_HASH)->times($numValidRefs)->return_value($revList);
}
}, true);
// The number of runs for $gitHookConfig->getValidRefs() depend on the total number of
// inputs in the standard input array and the number of revisions
$stubConfig = $this->shmock('\\Bart\\GitHook\\GitHookConfig', function ($gitHookConfig) use($numInputs, $validRefs, $emergency) {
$gitHookConfig->getValidRefs()->times($numInputs)->return_value($validRefs);
if ($emergency) {
if (!empty($validRefs)) {
$gitHookConfig->getEmergencyNotificationBody()->once()->return_value('Notification body');
$gitHookConfig->getEmergencyNotificationEmailAddress()->once()->return_value('*****@*****.**');
$gitHookConfig->getEmergencyNotificationSubject()->once()->return_value('Emergency subject');
}
}
}, true);
// Register stub mail() function to validate config is loaded and passed in as expected
GlobalFunctions::register('mail', function ($to, $subject, $body) {
$this->assertEquals('*****@*****.**', $to, 'Emergency email address');
$this->assertEquals('Emergency subject', $subject, 'Emergency subject');
$this->assertEquals('Notification body', $body, 'Emergency body');
});
// The number of runs for $gitCommit->message() and $postReceiveRunner->runAllActions depend on $numValidRefs
$numValidCommits = $numValidRefs * $numRevs;
$stubCommit = $this->shmockAndDieselify('\\Bart\\Git\\Commit', function ($gitCommit) use($numValidCommits, $message) {
$gitCommit->messageSubject()->times($numValidCommits)->return_value($message);
}, true);
if ($emergency) {
// We'll skip the hooks for any emergency commit
$numValidCommits = 0;
}
$stubRunner = $this->shmock('\\Bart\\GitHook\\PostReceiveRunner', function ($postReceiveRunner) use($numValidCommits) {
$postReceiveRunner->runAllActions()->times($numValidCommits);
}, true);
// Explicitly register GitHookConfig and PostReceiveRunner stubs so that we can
// ...assert the constructor args are what we expect
Diesel::registerInstantiator('\\Bart\\GitHook\\GitHookConfig', function ($commit) use($stubCommit, $stubConfig) {
$this->assertSame($commit, $stubCommit);
return $stubConfig;
});
Diesel::registerInstantiator('\\Bart\\GitHook\\PostReceiveRunner', function ($commit) use($stubCommit, $stubRunner) {
$this->assertSame($commit, $stubCommit);
return $stubRunner;
});
// Create the controller and verify the mocks
$controller = GitHookController::createFromScriptName(self::POST_RECEIVE_SCRIPT);
$controller->run();
}
