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);
}
