public void ReadOnlyPropertyImport_ShouldThrowComposition() { var importer = PartFactory.CreateAttributed(new ReadOnlyPropertyImport()); var container = ContainerFactory.Create(); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddExportedValue("readonly", "new value"); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void ImportValueMismatchFromInt32ToDateTime() { var container = ContainerFactory.Create(); CompositionBatch batch = new CompositionBatch(); batch.AddPart(new ImportValueTypes()); batch.AddExportedValue("DateTime", typeof(DateTime), 42); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport, ErrorId.ReflectionModel_ImportNotAssignableFromExport, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void ExpectedErrorOnSetImport(object importer, ErrorId expectedErrorId) { var container = ContainerFactory.Create(); var batch = new CompositionBatch(); batch.AddPart(importer); batch.AddExportedValue("Value", 42); batch.AddExportedValue("Value", 0); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport, expectedErrorId, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void MergeResult_ResultWithEmptyErrorsAsResultArgument_ShouldReturnResultWithSameErrors() { var emptyResult = CreateCompositionResult(Enumerable.Empty <CompositionError>()); var expectations = Expectations.GetCompositionErrors(); foreach (var e in expectations) { var result = CreateCompositionResult(e); var mergedResult = result.MergeResult(emptyResult); CompositionAssert.AreEqual(result, mergedResult); } }
public void ImportValueExceptionMissing() { var container = ContainerFactory.Create(); Importer importer; CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer = new Importer()); CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport, ErrorId.ImportEngine_ImportCardinalityMismatch, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
private static void AssertCycle(Dependency partADependency, Dependency partBDependency) { var exportA = GetExport("A", partADependency, partBDependency); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotGetExportedValue, () => { var value = exportA.Value; }); var exportB = GetExport("B", partADependency, partBDependency); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotGetExportedValue, () => { var value = exportB.Value; }); }
public void ImportCollectionsExceptionGettingValue() { var container = ContainerFactory.Create(); ImporterThrowsOnGetting importer = new ImporterThrowsOnGetting(); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddExportedValue("Value", 42); batch.AddExportedValue("Value", 0); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate, ErrorId.ReflectionModel_ImportCollectionGetThrewException, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void Errors_CanBeSerialized() { var expectations = Expectations.GetCompositionErrors(); foreach (var e in expectations) { var exception = CreateCompositionException(e); var result = SerializationTestServices.RoundTrip(exception); EnumerableAssert.AreSequenceEqual(exception.Errors, result.Errors, (index, expected, actual) => { CompositionAssert.AreEqual(expected, actual); }); } }
public void ImportIntoDerivationOfExportsException() { var container = ContainerFactory.Create(); CompositionBatch batch = new CompositionBatch(); batch.AddExportedValue("derived", typeof(DerivedExport), 42); var d = new DerivedExportsImporter(); batch.AddPart(d); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport, ErrorId.ReflectionModel_ImportNotAssignableFromExport, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void ImportValues() { var container = ContainerFactory.Create(); Importer importer = new Importer(); Exporter exporter42 = new Exporter(42); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddPart(exporter42); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport, ErrorId.ReflectionModel_ImportNotAssignableFromExport, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void GetExportedValue_MissingPostImports_ShouldThrowComposition() { var part = CreatePart(typeof(MySharedPartExport)); // Signal that the composition should be finished part.Activate(); var definition = part.ExportDefinitions.First(); // Dev10:484204 - This used to cause a failure but after we made // ReflectionComposablePart internal we needed to back remove this // validation for post imports to make declarative composition work. CompositionAssert.ThrowsError(ErrorId.ImportNotSetOnPart, () => { part.GetExportedValue(definition); }); }
public void Value_TwoDifferentValuesAsErrorsArgument_ShouldThrowComposition() { var errorIds1 = Expectations.GetEnumValues <CompositionErrorId>(); var errorIds2 = Expectations.GetEnumValues <CompositionErrorId>(); for (int i = 0; i < errorIds1.Count(); i++) { var errorId1 = errorIds1.ElementAt(i); var errorId2 = errorIds1.ElementAt(errorIds2.Count() - 1 - i); var result = CreateCompositionResult <string>(errorId1, errorId2); CompositionAssert.ThrowsErrors((ErrorId)errorId1, (ErrorId)errorId2, () => { var value = result.Value; }); } }
public void ImportValueExceptionSetterException() { var container = ContainerFactory.Create(); ImporterInvalidSetterException importer = new ImporterInvalidSetterException(); Exporter exporter42 = new Exporter(42); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddPart(exporter42); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate, ErrorId.ReflectionModel_ImportThrewException, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void ImportValueExceptionMultiple() { var container = ContainerFactory.Create(); Importer importer = new Importer(); Exporter exporter42 = new Exporter(42); Exporter exporter6 = new Exporter(6); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddPart(exporter42); batch.AddPart(exporter6); CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void RebindingShouldNotHappenForConstructorArguments() { var container = GetContainerWithCatalog(); CompositionBatch batch = new CompositionBatch(); var p1 = batch.AddExportedValue("MyConstructorCollectionItem", 1); batch.AddExportedValue("MyConstructorCollectionItem", 2); batch.AddExportedValue("MyConstructorCollectionItem", 3); container.Compose(batch); var a = container.GetExportedValue <AWithCollectionArgument>(); EnumerableAssert.AreEqual(a.Values, 1, 2, 3); batch = new CompositionBatch(); batch.AddExportedValue("MyConstructorCollectionItem", 4); batch.AddExportedValue("MyConstructorCollectionItem", 5); batch.AddExportedValue("MyConstructorCollectionItem", 6); // After rejection changes that are incompatible with existing assumptions are no // longer silently ignored. The batch attempting to make this change is rejected // with a ChangeRejectedException CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PreventedByExistingImport, () => { container.Compose(batch); }); // The collection which is a constructor import should not be rebound EnumerableAssert.AreEqual(a.Values, 1, 2, 3); batch.RemovePart(p1); // After rejection changes that are incompatible with existing assumptions are no // longer silently ignored. The batch attempting to make this change is rejected // with a ChangeRejectedException CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PreventedByExistingImport, () => { container.Compose(batch); }); // The collection which is a constructor import should not be rebound EnumerableAssert.AreEqual(a.Values, 1, 2, 3); }