/** * {@inheritdoc} */ public function rollback() { if ($this->previousDescriptor) { $this->rootModuleFile->addBindingDescriptor($this->previousDescriptor); } else { $this->rootModuleFile->removeBindingDescriptor($this->bindingDescriptor->getUuid()); } }
/** * {@inheritdoc} */ public function rollback() { if ($this->bindingDescriptor->isLoaded() || !$this->containingPackage || !$this->typeDescriptor) { return; } // never fails with the check before, given that the type name of // the description/type didn't changed, which is impossible since // they're immutable $this->bindingDescriptor->load($this->containingPackage, $this->typeDescriptor); if ($this->wasRemoved) { // never fails $this->bindingDescriptors->add($this->bindingDescriptor); } }
public function testFindRootAssetMappings() { $this->discoveryManager->expects($this->once())->method('findRootBindings')->with($this->webPath('/other/path'))->willReturn(array($this->binding2)); $expr = Expr::same('/other/path', AssetMapping::SERVER_PATH); $expected = new AssetMapping('/other/path', 'target2', '/js', $this->binding2->getUuid()); $this->assertEquals(array($expected), $this->manager->findRootAssetMappings($expr)); }
/** * {@inheritdoc} */ public function rollback() { // sanity check if (!$this->bindingDescriptor->isLoaded()) { return; } // never fails with the check before $this->bindingDescriptor->unload(); if ($this->previousDescriptor) { // never fails $this->bindingDescriptors->add($this->previousDescriptor); } else { // never fails $this->bindingDescriptors->remove($this->bindingDescriptor->getUuid()); } }
public function testWritePackageFileWritesDefaultParameterValuesOfBindings() { $packageFile = new PackageFile(); $package = new Package($packageFile, '/path', new InstallInfo('vendor/package', '/path')); // We need to create a type and a binding in state ENABLED $bindingType = new BindingTypeDescriptor('my/type', null, array(new BindingParameterDescriptor('param', BindingParameterDescriptor::OPTIONAL, 'default'))); $bindingType->load($package); $binding = new BindingDescriptor('/app/config*.yml', 'my/type', array(), 'glob', Uuid::fromString(self::BINDING_UUID1)); $binding->load($package, $bindingType); // The default value is accessible $this->assertSame('default', $binding->getParameterValue('param')); // But not written by the writer $packageFile->addBindingDescriptor($binding); $this->writer->writePackageFile($packageFile, $this->tempFile); $this->assertFileExists($this->tempFile); $this->assertJsonFileEquals(__DIR__ . '/Fixtures/json/binding-no-default-params.json', $this->tempFile); }
/** * Unloads and loads a binding descriptor. * * The descriptor is remembered and reloaded again in {@link postRollback()} * if the intercepted operation needs to be rolled back. * * @param BindingDescriptor $bindingDescriptor The descriptor to reload. */ protected function reloadBindingDescriptor(BindingDescriptor $bindingDescriptor) { if (!$bindingDescriptor->isLoaded()) { return; } // Keep backup of containing package before calling unload() $containingPackage = $bindingDescriptor->getContainingPackage(); $typeName = $bindingDescriptor->getTypeName(); $typeDescriptor = $this->typeDescriptors->getEnabled($typeName); // never fails with the check in the beginning $bindingDescriptor->unload(); // never fails after unloading, given that the type name matches // (which we can guarantee here) $bindingDescriptor->load($containingPackage, $typeDescriptor); $this->reloadedDescriptors[] = $bindingDescriptor; }
private function syncBindingUuid(BindingDescriptor $enabledBefore = null, BindingDescriptor $enabledAfter = null) { if (!$enabledBefore && $enabledAfter) { $this->discovery->bind($enabledAfter->getQuery(), $enabledAfter->getTypeName(), $enabledAfter->getParameterValues(), $enabledAfter->getLanguage()); } elseif ($enabledBefore && !$enabledAfter) { $this->discovery->unbind($enabledBefore->getQuery(), $enabledBefore->getTypeName(), $enabledBefore->getParameterValues(), $enabledBefore->getLanguage()); } }
public function testSerializePackageFileWritesDefaultParameterValuesOfBindings() { $packageFile = new PackageFile(); $package = new Package($packageFile, '/path', new InstallInfo('vendor/package', '/path')); // We need to create a type and a binding in state ENABLED $bindingType = new BindingTypeDescriptor('my/type', null, array(new BindingParameterDescriptor('param', BindingParameterDescriptor::OPTIONAL, 'default'))); $bindingType->load($package); $binding = new BindingDescriptor('/app/config*.yml', 'my/type', array(), 'glob', Uuid::fromString(self::BINDING_UUID1)); $binding->load($package, $bindingType); // The default value is accessible $this->assertSame('default', $binding->getParameterValue('param')); // But not written by the serializer $packageFile->addBindingDescriptor($binding); $json = <<<JSON { "version": "1.0", "bindings": { "2438256b-c2f5-4a06-a18f-f79755e027dd": { "query": "/app/config*.yml", "type": "my/type" } } } JSON; $this->assertJsonEquals($json, $this->serializer->serializePackageFile($packageFile)); }
/** * {@inheritdoc} */ public function rollback() { $this->discovery->removeBinding($this->bindingDescriptor->getUuid()); }
private function bindingToMapping(BindingDescriptor $binding) { return new AssetMapping(substr($binding->getQuery(), 0, -8), $binding->getParameterValue(AssetPlugin::TARGET_PARAMETER), $binding->getParameterValue(AssetPlugin::PATH_PARAMETER), $binding->getUuid()); }
public function testBuildDiscoveryOnlyIncludesEnabledBindingsOfInstalledPackages() { $this->initDefaultManager(); $this->packageFile1->addBindingDescriptor($binding1 = new BindingDescriptor('/path1', 'my/type')); $this->packageFile1->addBindingDescriptor($binding2 = new BindingDescriptor('/path2', 'my/type')); $this->packageFile1->addBindingDescriptor($binding3 = new BindingDescriptor('/path3', 'my/type')); $this->installInfo1->addEnabledBindingUuid($binding2->getUuid()); $this->installInfo1->addDisabledBindingUuid($binding3->getUuid()); $this->packageFile1->addTypeDescriptor($bindingType = new BindingTypeDescriptor('my/type')); $this->discovery->expects($this->once())->method('defineType')->with($bindingType->toBindingType()); $this->discovery->expects($this->once())->method('bind')->with('/path2', 'my/type', array(), 'glob'); $this->manager->buildDiscovery(); }
/** * Adds a binding descriptor. * * @param BindingDescriptor $descriptor The binding descriptor to add. */ public function addBindingDescriptor(BindingDescriptor $descriptor) { $this->bindingDescriptors[$descriptor->getUuid()->toString()] = $descriptor; }
private function bindingsEqual(BindingDescriptor $descriptor1, BindingDescriptor $descriptor2) { return $descriptor1->getBinding() == $descriptor2->getBinding(); }
public static function compareBindingDescriptors(BindingDescriptor $a, BindingDescriptor $b) { // Make sure that bindings are always printed in the same order return strcmp($a->getUuid()->toString(), $b->getUuid()->toString()); }
private function bindingsEqual(BindingDescriptor $binding1, BindingDescriptor $binding2) { if ($binding1->getUuid() !== $binding2->getUuid()) { return false; } if ($binding1->getTypeName() !== $binding2->getTypeName()) { return false; } if ($binding1->getQuery() !== $binding2->getQuery()) { return false; } if ($binding1->getLanguage() !== $binding2->getLanguage()) { return false; } if ($binding1->getParameterValues() !== $binding2->getParameterValues()) { return false; } return true; }
private function bindingToMapping(BindingDescriptor $binding) { return new AssetMapping(substr($binding->getQuery(), 0, -8), $binding->getParameterValue(DiscoveryUrlGenerator::SERVER_PARAMETER), $binding->getParameterValue(DiscoveryUrlGenerator::PATH_PARAMETER), $binding->getUuid()); }
private function assertBindingValid(BindingDescriptor $bindingDescriptor) { if ($bindingDescriptor->isTypeNotFound() || $bindingDescriptor->isTypeNotEnabled()) { return; } foreach ($bindingDescriptor->getLoadErrors() as $exception) { throw $exception; } }
/** * Adds a binding descriptor. * * @param BindingDescriptor $bindingDescriptor The binding descriptor. */ public function add(BindingDescriptor $bindingDescriptor) { $this->map[$bindingDescriptor->getUuid()->toString()] = $bindingDescriptor; }
public function testMatch() { $type = new BindingTypeDescriptor('vendor/type', null, array(new BindingParameterDescriptor('param'))); $type->load($this->package); $uuid = Uuid::fromString('abcdb814-9dad-11d1-80b4-00c04fd430c8'); $this->package->getInstallInfo()->addEnabledBindingUuid($uuid); $binding = new BindingDescriptor('/path', 'vendor/type', array('param' => 'value'), 'glob', $uuid); $binding->load($this->package, $type); $this->assertFalse($binding->match(Expr::same('foobar', BindingDescriptor::CONTAINING_PACKAGE))); $this->assertTrue($binding->match(Expr::same($this->package->getName(), BindingDescriptor::CONTAINING_PACKAGE))); $this->assertFalse($binding->match(Expr::same(BindingState::DISABLED, BindingDescriptor::STATE))); $this->assertTrue($binding->match(Expr::same(BindingState::ENABLED, BindingDescriptor::STATE))); $this->assertFalse($binding->match(Expr::startsWith('abce', BindingDescriptor::UUID))); $this->assertTrue($binding->match(Expr::startsWith('abcd', BindingDescriptor::UUID))); $this->assertFalse($binding->match(Expr::same('/path/nested', BindingDescriptor::QUERY))); $this->assertTrue($binding->match(Expr::same('/path', BindingDescriptor::QUERY))); $this->assertFalse($binding->match(Expr::same('xpath', BindingDescriptor::LANGUAGE))); $this->assertTrue($binding->match(Expr::same('glob', BindingDescriptor::LANGUAGE))); $this->assertFalse($binding->match(Expr::same('vendor/other', BindingDescriptor::TYPE_NAME))); $this->assertTrue($binding->match(Expr::same('vendor/type', BindingDescriptor::TYPE_NAME))); $this->assertFalse($binding->match(Expr::key(BindingDescriptor::PARAMETER_VALUES, Expr::key('param', Expr::same('foobar'))))); $this->assertTrue($binding->match(Expr::key(BindingDescriptor::PARAMETER_VALUES, Expr::key('param', Expr::same('value'))))); }
private function syncBindingUuid(BindingDescriptor $enabledBefore = null, BindingDescriptor $enabledAfter = null) { if (!$enabledBefore && $enabledAfter) { $this->discovery->addBinding($enabledAfter->getBinding()); } elseif ($enabledBefore && !$enabledAfter) { $this->discovery->removeBinding($enabledBefore->getUuid()); } }
public function testHasBindingDescriptor() { $packageFile = new PackageFile(); $binding = new BindingDescriptor('/path', 'my/type'); $this->assertFalse($packageFile->hasBindingDescriptor($binding->getUuid())); $packageFile->addBindingDescriptor($binding); $this->assertTrue($packageFile->hasBindingDescriptor($binding->getUuid())); }
private function assertBindingValid(BindingDescriptor $bindingDescriptor) { if ($bindingDescriptor->isTypeNotFound() || $bindingDescriptor->isTypeNotEnabled()) { return; } foreach ($bindingDescriptor->getViolations() as $violation) { switch ($violation->getCode()) { case ConstraintViolation::NO_SUCH_PARAMETER: throw NoSuchParameterException::forParameterName($violation->getParameterName(), $violation->getTypeName()); case ConstraintViolation::MISSING_PARAMETER: throw MissingParameterException::forParameterName($violation->getParameterName(), $violation->getTypeName()); } } }
/** * @expectedException \RuntimeException * @expectedExceptionMessage Cannot disable bindings in the package "vendor/root". */ public function testDisableBindingFailsIfRoot() { $args = self::$disableCommand->parseArgs(new StringArgs('ab12')); $descriptor = new BindingDescriptor('/path', 'my/type', array(), 'glob'); $descriptor->load($this->packages->getRootPackage()); $this->discoveryManager->expects($this->once())->method('findBindings')->with($this->uuid('ab12'))->willReturn(array($descriptor)); $this->discoveryManager->expects($this->never())->method('disableBinding'); $this->handler->handleDisable($args, $this->io); }