public-mirrors
/
composer
mirror of https://github.com/composer/composer
1
0
Fork 0
Code

Merge remote-tracking branch 'naderman/human-readable-errors'

pull/473/merge
Jordi Boggiano 2012-03-18 22:22:46 +01:00
parent 51447074c2 83123b2d40
commit e8bf6e9067
7 changed files with 311 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
src/Composer/DependencyResolver/Problem.php Normal file
View File

@ -0,0 +1,144 @@
<?php
/*
* This file is part of Composer.
*
* (c) Nils Adermann <naderman@naderman.de>
* Jordi Boggiano <j.boggiano@seld.be>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Composer\DependencyResolver;
/**
* Represents a problem detected while solving dependencies
*
* @author Nils Adermann <naderman@naderman.de>
*/
class Problem
{
/**
* A set of reasons for the problem, each is a rule or a job and a rule
* @var array
*/
protected $reasons;
/**
* Add a job as a reason
*
* @param array $job A job descriptor which is a reason for this problem
* @param Rule $rule An optional rule associated with the job
*/
public function addJobRule($job, Rule $rule = null)
{
$this->addReason(serialize($job), array(
'rule' => $rule,
'job' => $job,
));
}
/**
* Add a rule as a reason
*
* @param Rule $rule A rule which is a reason for this problem
*/
public function addRule(Rule $rule)
{
$this->addReason($rule->getId(), array(
'rule' => $rule,
'job' => null,
));
}
/**
* Retrieve all reasons for this problem
*
* @return array The problem's reasons
*/
public function getReasons()
{
return $this->reasons;
}
/**
* A human readable textual representation of the problem's reasons
*/
public function __toString()
{
if (count($this->reasons) === 1) {
reset($this->reasons);
$reason = current($this->reasons);
$rule = $reason['rule'];
$job = $reason['job'];
if ($job && $job['cmd'] === 'install' && empty($job['packages'])) {
return 'The requested package "'.$job['packageName'].'" '.$this->constraintToText($job['constraint']).'could not be found.';
}
}
$messages = array("Problem caused by:");
foreach ($this->reasons as $reason) {
$rule = $reason['rule'];
$job = $reason['job'];
if ($job) {
$messages[] = $this->jobToText($job);
} elseif ($rule) {
if ($rule instanceof Rule) {
$messages[] = $rule->toHumanReadableString();
}
}
}
return implode("\n\t\t\t- ", $messages);
}
/**
* Store a reason descriptor but ignore duplicates
*
* @param string $id A canonical identifier for the reason
* @param string $reason The reason descriptor
*/
protected function addReason($id, $reason)
{
if (!isset($this->reasons[$id])) {
$this->reasons[$id] = $reason;
}
}
/**
* Turns a job into a human readable description
*
* @param array $job
* @return string
*/
protected function jobToText($job)
{
switch ($job['cmd']) {
case 'install':
return 'Installation of package "'.$job['packageName'].'" '.$this->constraintToText($job['constraint']).'was requested. Satisfiable by packages ['.implode(', ', $job['packages']).'].';
case 'update':
return 'Update of package "'.$job['packageName'].'" '.$this->constraintToText($job['constraint']).'was requested.';
case 'remove':
return 'Removal of package "'.$job['packageName'].'" '.$this->constraintToText($job['constraint']).'was requested.';
}
return 'Job(cmd='.$job['cmd'].', target='.$job['packageName'].', packages=['.implode(', ', $job['packages']).'])';
}
/**
* Turns a constraint into text usable in a sentence describing a job
*
* @param LinkConstraint $constraint
* @return string
*/
protected function constraintToText($constraint)
{
return ($constraint) ? 'with constraint '.$constraint.' ' : '';
}
}

1
src/Composer/DependencyResolver/Request.php
View File

@ -52,6 +52,7 @@ class Request
'packages' => $packages, 'packages' => $packages,
'cmd' => $cmd, 'cmd' => $cmd,
'packageName' => $packageName, 'packageName' => $packageName,
'constraint' => $constraint,
); );
} }

75
src/Composer/DependencyResolver/Rule.php
View File

@ -17,6 +17,19 @@ namespace Composer\DependencyResolver;
*/ */
class Rule class Rule
{ {
const RULE_INTERNAL_ALLOW_UPDATE = 1;
const RULE_JOB_INSTALL = 2;
const RULE_JOB_REMOVE = 3;
const RULE_JOB_LOCK = 4;
const RULE_NOT_INSTALLABLE = 5;
const RULE_PACKAGE_CONFLICT = 6;
const RULE_PACKAGE_REQUIRES = 7;
const RULE_PACKAGE_OBSOLETES = 8;
const RULE_INSTALLED_PACKAGE_OBSOLETES = 9;
const RULE_PACKAGE_SAME_NAME = 10;
const RULE_PACKAGE_IMPLICIT_OBSOLETES = 11;
const RULE_LEARNED = 12;
protected $disabled; protected $disabled;
protected $literals; protected $literals;
protected $type; protected $type;
@ -163,6 +176,68 @@ class Rule
} }
} }
public function toHumanReadableString()
{
$ruleText = '';
foreach ($this->literals as $i => $literal) {
if ($i != 0) {
$ruleText .= '|';
}
$ruleText .= $literal;
}
switch ($this->reason) {
case self::RULE_INTERNAL_ALLOW_UPDATE:
return $ruleText;
case self::RULE_JOB_INSTALL:
return "Install command rule ($ruleText)";
case self::RULE_JOB_REMOVE:
return "Remove command rule ($ruleText)";
case self::RULE_JOB_LOCK:
return "Lock command rule ($ruleText)";
case self::RULE_NOT_INSTALLABLE:
return $ruleText;
case self::RULE_PACKAGE_CONFLICT:
$package1 = $this->literals[0]->getPackage();
$package2 = $this->literals[1]->getPackage();
return 'Package "'.$package1.'" conflicts with "'.$package2.'"';
case self::RULE_PACKAGE_REQUIRES:
$literals = $this->literals;
$sourceLiteral = array_shift($literals);
$sourcePackage = $sourceLiteral->getPackage();
$requires = array();
foreach ($literals as $literal) {
$requires[] = $literal->getPackage();
}
$text = 'Package "'.$sourcePackage.'" contains the rule '.$this->reasonData.'. ';
if ($requires) {
$text .= 'Any of these packages satisfy the dependency: '.implode(', ', $requires).'.';
} else {
$text .= 'No package satisfies this dependency.';
}
return $text;
case self::RULE_PACKAGE_OBSOLETES:
return $ruleText;
case self::RULE_INSTALLED_PACKAGE_OBSOLETES:
return $ruleText;
case self::RULE_PACKAGE_SAME_NAME:
return $ruleText;
case self::RULE_PACKAGE_IMPLICIT_OBSOLETES:
return $ruleText;
case self::RULE_LEARNED:
return 'learned: '.$ruleText;
}
}
/** /**
* Formats a rule as a string of the format (Literal1|Literal2|...) * Formats a rule as a string of the format (Literal1|Literal2|...)
* *

130
src/Composer/DependencyResolver/Solver.php
View File

@ -21,21 +21,6 @@ use Composer\DependencyResolver\Operation;
*/ */
class Solver class Solver
{ {
const RULE_INTERNAL_ALLOW_UPDATE = 1;
const RULE_JOB_INSTALL = 2;
const RULE_JOB_REMOVE = 3;
const RULE_JOB_LOCK = 4;
const RULE_NOT_INSTALLABLE = 5;
const RULE_NOTHING_PROVIDES_DEP = 6;
const RULE_PACKAGE_CONFLICT = 7;
const RULE_PACKAGE_NOT_EXIST = 8;
const RULE_PACKAGE_REQUIRES = 9;
const RULE_PACKAGE_OBSOLETES = 10;
const RULE_INSTALLED_PACKAGE_OBSOLETES = 11;
const RULE_PACKAGE_SAME_NAME = 12;
const RULE_PACKAGE_IMPLICIT_OBSOLETES = 13;
const RULE_LEARNED = 14;
protected $policy; protected $policy;
protected $pool; protected $pool;
protected $installed; protected $installed;
@ -235,7 +220,7 @@ class Solver
} }
if (!$dontFix && !$this->policy->installable($this, $this->pool, $this->installedMap, $package)) { if (!$dontFix && !$this->policy->installable($this, $this->pool, $this->installedMap, $package)) {
$this->addRule(RuleSet::TYPE_PACKAGE, $this->createRemoveRule($package, self::RULE_NOT_INSTALLABLE, (string) $package)); $this->addRule(RuleSet::TYPE_PACKAGE, $this->createRemoveRule($package, Rule::RULE_NOT_INSTALLABLE, (string) $package));
continue; continue;
} }
@ -261,7 +246,7 @@ class Solver
} }
} }
$this->addRule(RuleSet::TYPE_PACKAGE, $rule = $this->createRequireRule($package, $possibleRequires, self::RULE_PACKAGE_REQUIRES, (string) $link)); $this->addRule(RuleSet::TYPE_PACKAGE, $rule = $this->createRequireRule($package, $possibleRequires, Rule::RULE_PACKAGE_REQUIRES, (string) $link));
foreach ($possibleRequires as $require) { foreach ($possibleRequires as $require) {
$workQueue->enqueue($require); $workQueue->enqueue($require);
@ -276,7 +261,7 @@ class Solver
continue; continue;
} }
$this->addRule(RuleSet::TYPE_PACKAGE, $this->createConflictRule($package, $conflict, self::RULE_PACKAGE_CONFLICT, (string) $link)); $this->addRule(RuleSet::TYPE_PACKAGE, $this->createConflictRule($package, $conflict, Rule::RULE_PACKAGE_CONFLICT, (string) $link));
} }
} }
@ -301,7 +286,7 @@ class Solver
continue; // don't repair installed/installed problems continue; // don't repair installed/installed problems
} }
$reason = ($isInstalled) ? self::RULE_INSTALLED_PACKAGE_OBSOLETES : self::RULE_PACKAGE_OBSOLETES; $reason = ($isInstalled) ? Rule::RULE_INSTALLED_PACKAGE_OBSOLETES : Rule::RULE_PACKAGE_OBSOLETES;
$this->addRule(RuleSet::TYPE_PACKAGE, $this->createConflictRule($package, $provider, $reason, (string) $link)); $this->addRule(RuleSet::TYPE_PACKAGE, $this->createConflictRule($package, $provider, $reason, (string) $link));
} }
} }
@ -327,7 +312,7 @@ class Solver
continue; continue;
} }
$reason = ($package->getName() == $provider->getName()) ? self::RULE_PACKAGE_SAME_NAME : self::RULE_PACKAGE_IMPLICIT_OBSOLETES; $reason = ($package->getName() == $provider->getName()) ? Rule::RULE_PACKAGE_SAME_NAME : Rule::RULE_PACKAGE_IMPLICIT_OBSOLETES;
$this->addRule(RuleSet::TYPE_PACKAGE, $rule = $this->createConflictRule($package, $provider, $reason, (string) $package)); $this->addRule(RuleSet::TYPE_PACKAGE, $rule = $this->createConflictRule($package, $provider, $reason, (string) $package));
} }
} }
@ -466,24 +451,29 @@ class Solver
$conflict = $this->findDecisionRule($literal->getPackage()); $conflict = $this->findDecisionRule($literal->getPackage());
/** TODO: handle conflict with systemsolvable? */ /** TODO: handle conflict with systemsolvable? */
$this->learnedPool[] = array($rule, $conflict);
if ($conflict && RuleSet::TYPE_PACKAGE === $conflict->getType()) { if ($conflict && RuleSet::TYPE_PACKAGE === $conflict->getType()) {
if ($rule->getType() == RuleSet::TYPE_JOB) { $problem = new Problem;
$why = $this->ruleToJob[$rule->getId()];
} else {
$why = $rule;
}
$this->problems[] = array($why);
$this->disableProblem($why); if ($rule->getType() == RuleSet::TYPE_JOB) {
$job = $this->ruleToJob[$rule->getId()];
$problem->addJobRule($job, $rule);
$problem->addRule($conflict);
$this->disableProblem($job);
} else {
$problem->addRule($rule);
$problem->addRule($conflict);
$this->disableProblem($rule);
}
$this->problems[] = $problem;
continue; continue;
} }
// conflict with another job or update/feature rule // conflict with another job or update/feature rule
$problem = new Problem;
$this->problems[] = array(); $problem->addRule($rule);
$problem->addRule($conflict);
// push all of our rules (can only be feature or job rules) // push all of our rules (can only be feature or job rules)
// asserting this literal on the problem stack // asserting this literal on the problem stack
@ -500,14 +490,16 @@ class Solver
} }
if ($assertRule->getType() === RuleSet::TYPE_JOB) { if ($assertRule->getType() === RuleSet::TYPE_JOB) {
$why = $this->ruleToJob[$assertRule->getId()]; $job = $this->ruleToJob[$assertRule->getId()];
} else {
$why = $assertRule;
}
$this->problems[count($this->problems) - 1][] = $why;
$this->disableProblem($why); $problem->addJobRule($job, $assertRule);
$this->disableProblem($job);
} else {
$problem->addRule($assertRule);
$this->disableProblem($assertRule);
} }
}
$this->problems[] = $problem;
// start over // start over
while (count($this->decisionQueue) > $decisionStart) { while (count($this->decisionQueue) > $decisionStart) {
@ -966,7 +958,7 @@ class Solver
foreach ($installedPackages as $package) { foreach ($installedPackages as $package) {
$updates = $this->policy->findUpdatePackages($this, $this->pool, $this->installedMap, $package); $updates = $this->policy->findUpdatePackages($this, $this->pool, $this->installedMap, $package);
$rule = $this->createUpdateRule($package, $updates, self::RULE_INTERNAL_ALLOW_UPDATE, (string) $package); $rule = $this->createUpdateRule($package, $updates, Rule::RULE_INTERNAL_ALLOW_UPDATE, (string) $package);
$rule->setWeak(true); $rule->setWeak(true);
$this->addRule(RuleSet::TYPE_FEATURE, $rule); $this->addRule(RuleSet::TYPE_FEATURE, $rule);
@ -977,9 +969,11 @@ class Solver
switch ($job['cmd']) { switch ($job['cmd']) {
case 'install': case 'install':
if (empty($job['packages'])) { if (empty($job['packages'])) {
$this->problems[] = array($job); $problem = new Problem();
$problem->addJobRule($job);
$this->problems[] = $problem;
} else { } else {
$rule = $this->createInstallOneOfRule($job['packages'], self::RULE_JOB_INSTALL, $job['packageName']); $rule = $this->createInstallOneOfRule($job['packages'], Rule::RULE_JOB_INSTALL, $job['packageName']);
$this->addRule(RuleSet::TYPE_JOB, $rule); $this->addRule(RuleSet::TYPE_JOB, $rule);
$this->ruleToJob[$rule->getId()] = $job; $this->ruleToJob[$rule->getId()] = $job;
} }
@ -990,7 +984,7 @@ class Solver
// todo: cleandeps // todo: cleandeps
foreach ($job['packages'] as $package) { foreach ($job['packages'] as $package) {
$rule = $this->createRemoveRule($package, self::RULE_JOB_REMOVE); $rule = $this->createRemoveRule($package, Rule::RULE_JOB_REMOVE);
$this->addRule(RuleSet::TYPE_JOB, $rule); $this->addRule(RuleSet::TYPE_JOB, $rule);
$this->ruleToJob[$rule->getId()] = $job; $this->ruleToJob[$rule->getId()] = $job;
} }
@ -998,9 +992,9 @@ class Solver
case 'lock': case 'lock':
foreach ($job['packages'] as $package) { foreach ($job['packages'] as $package) {
if (isset($this->installedMap[$package->getId()])) { if (isset($this->installedMap[$package->getId()])) {
$rule = $this->createInstallRule($package, self::RULE_JOB_LOCK); $rule = $this->createInstallRule($package, Rule::RULE_JOB_LOCK);
} else { } else {
$rule = $this->createRemoveRule($package, self::RULE_JOB_LOCK); $rule = $this->createRemoveRule($package, Rule::RULE_JOB_LOCK);
} }
$this->addRule(RuleSet::TYPE_JOB, $rule); $this->addRule(RuleSet::TYPE_JOB, $rule);
$this->ruleToJob[$rule->getId()] = $job; $this->ruleToJob[$rule->getId()] = $job;
@ -1028,7 +1022,7 @@ class Solver
//solver_prepare_solutions(solv); //solver_prepare_solutions(solv);
if ($this->problems) { if ($this->problems) {
throw new SolverProblemsException($this->problems, $this->learnedPool); throw new SolverProblemsException($this->problems);
} }
return $this->createTransaction(); return $this->createTransaction();
@ -1487,22 +1481,21 @@ class Solver
$why = count($this->learnedPool) - 1; $why = count($this->learnedPool) - 1;
assert($learnedLiterals[0] !== null); assert($learnedLiterals[0] !== null);
$newRule = new Rule($learnedLiterals, self::RULE_LEARNED, $why); $newRule = new Rule($learnedLiterals, Rule::RULE_LEARNED, $why);
return array($ruleLevel, $newRule, $why); return array($ruleLevel, $newRule, $why);
} }
private function analyzeUnsolvableRule($conflictRule, &$lastWeakWhy) private function analyzeUnsolvableRule($problem, $conflictRule, &$lastWeakWhy)
{ {
$why = $conflictRule->getId(); $why = $conflictRule->getId();
if ($conflictRule->getType() == RuleSet::TYPE_LEARNED) { if ($conflictRule->getType() == RuleSet::TYPE_LEARNED) {
$learnedWhy = $this->learnedWhy[$why]; $learnedWhy = $this->learnedWhy[$why];
$problem = $this->learnedPool[$learnedWhy]; $problemRules = $this->learnedPool[$learnedWhy];
foreach ($problem as $problemRule) { foreach ($problemRules as $problemRule) {
$this->analyzeUnsolvableRule($problemRule, $lastWeakWhy); $this->analyzeUnsolvableRule($problem, $problemRule, $lastWeakWhy);
} }
return; return;
} }
@ -1520,24 +1513,22 @@ class Solver
} }
if ($conflictRule->getType() == RuleSet::TYPE_JOB) { if ($conflictRule->getType() == RuleSet::TYPE_JOB) {
$why = $this->ruleToJob[$conflictRule->getId()]; $job = $this->ruleToJob[$conflictRule->getId()];
$problem->addJobRule($job, $conflictRule);
} else {
$problem->addRule($conflictRule);
} }
// if this problem was already found skip it
if (in_array($why, $this->problems[count($this->problems) - 1], true)) {
return;
}
$this->problems[count($this->problems) - 1][] = $why;
} }
private function analyzeUnsolvable($conflictRule, $disableRules) private function analyzeUnsolvable($conflictRule, $disableRules)
{ {
$lastWeakWhy = null; $lastWeakWhy = null;
$this->problems[] = array(); $problem = new Problem;
$this->learnedPool[] = array($conflictRule); $problem->addRule($conflictRule);
$this->analyzeUnsolvableRule($conflictRule, $lastWeakWhy); $this->analyzeUnsolvableRule($problem, $conflictRule, $lastWeakWhy);
$this->problems[] = $problem;
$seen = array(); $seen = array();
$literals = $conflictRule->getLiterals(); $literals = $conflictRule->getLiterals();
@ -1569,9 +1560,9 @@ class Solver
} }
$why = $this->decisionQueueWhy[$decisionId]; $why = $this->decisionQueueWhy[$decisionId];
$this->learnedPool[count($this->learnedPool) - 1][] = $why; $problem->addRule($why);
$this->analyzeUnsolvableRule($why, $lastWeakWhy); $this->analyzeUnsolvableRule($problem, $why, $lastWeakWhy);
$literals = $why->getLiterals(); $literals = $why->getLiterals();
/* unnecessary because unlike rule.d, watch2 == 2nd literal, unless watch2 changed /* unnecessary because unlike rule.d, watch2 == 2nd literal, unless watch2 changed
@ -1591,7 +1582,6 @@ class Solver
if ($lastWeakWhy) { if ($lastWeakWhy) {
array_pop($this->problems); array_pop($this->problems);
array_pop($this->learnedPool);
if ($lastWeakWhy->getType() === RuleSet::TYPE_JOB) { if ($lastWeakWhy->getType() === RuleSet::TYPE_JOB) {
$why = $this->ruleToJob[$lastWeakWhy]; $why = $this->ruleToJob[$lastWeakWhy];
@ -1616,8 +1606,12 @@ class Solver
} }
if ($disableRules) { if ($disableRules) {
foreach ($this->problems[count($this->problems) - 1] as $why) { foreach ($this->problems[count($this->problems) - 1] as $reason) {
$this->disableProblem($why); if ($reason['job']) {
$this->disableProblem($reason['job']);
} else {
$this->disableProblem($reason['rule']);
}
} }
$this->resetSolver(); $this->resetSolver();
@ -1670,10 +1664,10 @@ class Solver
{ {
foreach ($this->rules->getIteratorFor(RuleSet::TYPE_LEARNED) as $rule) { foreach ($this->rules->getIteratorFor(RuleSet::TYPE_LEARNED) as $rule) {
$why = $this->learnedWhy[$rule->getId()]; $why = $this->learnedWhy[$rule->getId()];
$problem = $this->learnedPool[$why]; $problemRules = $this->learnedPool[$why];
$foundDisabled = false; $foundDisabled = false;
foreach ($problem as $problemRule) { foreach ($problemRules as $problemRule) {
if ($problemRule->disabled()) { if ($problemRule->disabled()) {
$foundDisabled = true; $foundDisabled = true;
break; break;

53
src/Composer/DependencyResolver/SolverProblemsException.php
View File

@ -19,47 +19,26 @@ class SolverProblemsException extends \RuntimeException
{ {
protected $problems; protected $problems;
public function __construct(array $problems, array $learnedPool) public function __construct(array $problems)
{ {
$message = ''; $this->problems = $problems;
foreach ($problems as $i => $problem) {
$message .= '[';
foreach ($problem as $why) {
if (is_int($why) && isset($learnedPool[$why])) { parent::__construct($this->createMessage());
$rules = $learnedPool[$why];
} else {
$rules = $why;
} }
if (isset($rules['packages'])) { protected function createMessage()
$message .= $this->jobToText($rules);
} else {
$message .= '(';
foreach ($rules as $rule) {
if ($rule instanceof Rule) {
if ($rule->getType() == RuleSet::TYPE_LEARNED) {
$message .= 'learned: ';
}
$message .= $rule . ', ';
} else {
$message .= 'String(' . $rule . '), ';
}
}
$message .= ')';
}
$message .= ', ';
}
$message .= "]\n";
}
parent::__construct($message);
}
public function jobToText($job)
{ {
//$output = serialize($job); $messages = array();
$output = 'Job(cmd='.$job['cmd'].', target='.$job['packageName'].', packages=['.implode(', ', $job['packages']).'])';
return $output; foreach ($this->problems as $problem) {
$messages[] = (string) $problem;
}
return "\n\tProblems:\n\t\t- ".implode("\n\t\t- ", $messages);
}
public function getProblems()
{
return $this->problems;
} }
} }

10
tests/Composer/Test/DependencyResolver/RequestTest.php
View File

@ -40,9 +40,9 @@ class RequestTest extends TestCase
$this->assertEquals( $this->assertEquals(
array( array(
array('packages' => array($foo), 'cmd' => 'install', 'packageName' => 'foo'), array('packages' => array($foo), 'cmd' => 'install', 'packageName' => 'foo', 'constraint' => null),
array('packages' => array($bar), 'cmd' => 'install', 'packageName' => 'bar'), array('packages' => array($bar), 'cmd' => 'install', 'packageName' => 'bar', 'constraint' => null),
array('packages' => array($foobar), 'cmd' => 'remove', 'packageName' => 'foobar'), array('packages' => array($foobar), 'cmd' => 'remove', 'packageName' => 'foobar', 'constraint' => null),
), ),
$request->getJobs()); $request->getJobs());
} }
@ -63,11 +63,11 @@ class RequestTest extends TestCase
$pool->addRepository($repo2); $pool->addRepository($repo2);
$request = new Request($pool); $request = new Request($pool);
$request->install('foo', $this->getVersionConstraint('=', '1')); $request->install('foo', $constraint = $this->getVersionConstraint('=', '1'));
$this->assertEquals( $this->assertEquals(
array( array(
array('packages' => array($foo1, $foo2), 'cmd' => 'install', 'packageName' => 'foo'), array('packages' => array($foo1, $foo2), 'cmd' => 'install', 'packageName' => 'foo', 'constraint' => $constraint),
), ),
$request->getJobs() $request->getJobs()
); );

16
tests/Composer/Test/DependencyResolver/SolverTest.php
View File

@ -59,13 +59,15 @@ class SolverTest extends TestCase
$this->repo->addPackage($this->getPackage('A', '1.0')); $this->repo->addPackage($this->getPackage('A', '1.0'));
$this->reposComplete(); $this->reposComplete();
$this->request->install('B'); $this->request->install('B', $this->getVersionConstraint('=', '1'));
try { try {
$transaction = $this->solver->solve($this->request); $transaction = $this->solver->solve($this->request);
$this->fail('Unsolvable conflict did not resolve in exception.'); $this->fail('Unsolvable conflict did not result in exception.');
} catch (SolverProblemsException $e) { } catch (SolverProblemsException $e) {
// TODO assert problem properties $problems = $e->getProblems();
$this->assertEquals(1, count($problems));
$this->assertEquals('The requested package "b" with constraint == 1.0.0.0 could not be found.', (string) $problems[0]);
} }
} }
@ -589,8 +591,10 @@ class SolverTest extends TestCase
try { try {
$transaction = $this->solver->solve($this->request); $transaction = $this->solver->solve($this->request);
$this->fail('Unsolvable conflict did not resolve in exception.'); $this->fail('Unsolvable conflict did not result in exception.');
} catch (SolverProblemsException $e) { } catch (SolverProblemsException $e) {
$problems = $e->getProblems();
$this->assertEquals(1, count($problems));
// TODO assert problem properties // TODO assert problem properties
} }
} }
@ -610,8 +614,10 @@ class SolverTest extends TestCase
try { try {
$transaction = $this->solver->solve($this->request); $transaction = $this->solver->solve($this->request);
$this->fail('Unsolvable conflict did not resolve in exception.'); $this->fail('Unsolvable conflict did not result in exception.');
} catch (SolverProblemsException $e) { } catch (SolverProblemsException $e) {
$problems = $e->getProblems();
$this->assertEquals(1, count($problems));
// TODO assert problem properties // TODO assert problem properties
} }
} }