public void TypeActivatorRequiresPublicConstructor(CreateInstanceFunc createFunc)
{
var ex = Assert.Throws <InvalidOperationException>(() =>
CreateInstance <ClassWithPrivateCtor>(createFunc, provider: null));
Assert.Equal(Resources.FormatNoConstructorMatch(typeof(ClassWithPrivateCtor)), ex.Message);
}
public void TypeActivatorRequiresPublicConstructor(CreateInstanceFunc createFunc, Type type)
{
var ex = Assert.Throws <InvalidOperationException>(() =>
createFunc(provider: null, type: type, args: new object[0]));
Assert.Equal(Resources.FormatNoConstructorMatch(type), ex.Message);
}
public void TypeActivatorWorksWithCtorWithOptionalArgs(CreateInstanceFunc createFunc)
{
var provider = new ServiceCollection().BuildServiceProvider();
var anotherClass = CreateInstance <ClassWithOptionalArgsCtor>(createFunc, provider);
Assert.NotNull(anotherClass);
Assert.Equal("BLARGH", anotherClass.Whatever);
}
public void TypeActivatorThrowsOnMultipleMarkedCtors(CreateInstanceFunc createFunc)
{
// Act
var exception = Assert.Throws <InvalidOperationException>(() => CreateInstance <ClassWithMultipleMarkedCtors>(createFunc, null, "hello"));
// Assert
Assert.Equal("Multiple constructors were marked with ActivatorUtilitiesConstructorAttribute.", exception.Message);
}
public void TypeActivatorThrowsWhenMarkedCtorDoesntAcceptArguments(CreateInstanceFunc createFunc)
{
// Act
var exception = Assert.Throws <InvalidOperationException>(() => CreateInstance <ClassWithAmbiguousCtorsAndAttribute>(createFunc, null, 0, "hello"));
// Assert
Assert.Equal("Constructor marked with ActivatorUtilitiesConstructorAttribute does not accept all given argument types.", exception.Message);
}
public void TypeActivatorWorksWithStaticCtor(CreateInstanceFunc createFunc)
{
// Act
var anotherClass = CreateInstance <ClassWithStaticCtor>(createFunc, provider: null);
// Assert
Assert.NotNull(anotherClass);
}
public void TypeActivatorCanDisambiguateConstructorsWithUniqueArguments(CreateInstanceFunc createFunc)
{
var serviceProvider = new ServiceCollection()
.AddTransient <IFakeService, FakeService>()
.BuildServiceProvider();
var instance = CreateInstance <ClassWithAmbiguousCtors>(createFunc, serviceProvider, "1", 2);
Assert.NotNull(instance);
}
public void TypeActivatorRethrowsOriginalExceptionFromConstructor(CreateInstanceFunc createFunc)
{
var ex1 = Assert.Throws <Exception>(() =>
CreateInstance <ClassWithThrowingEmptyCtor>(createFunc, provider: null));
var ex2 = Assert.Throws <Exception>(() =>
CreateInstance <ClassWithThrowingCtor>(createFunc, provider: null, args: new[] { new FakeService() }));
Assert.Equal(nameof(ClassWithThrowingEmptyCtor), ex1.Message);
Assert.Equal(nameof(ClassWithThrowingCtor), ex2.Message);
}
public void UnRegisteredServiceAsConstructorParameterThrowsException(CreateInstanceFunc createFunc)
{
var serviceCollection = new ServiceCollection()
.AddSingleton <CreationCountFakeService>();
var serviceProvider = CreateServiceProvider(serviceCollection);
var ex = Assert.Throws <ResolutionFailedException>(() =>
CreateInstance <CreationCountFakeService>(createFunc, serviceProvider));
Assert.True(ex.Message.StartsWith($"Resolution of the dependency failed, type = \"{typeof(IFakeService)}\""));
}
public void UnRegisteredServiceAsConstructorParameterThrowsException(CreateInstanceFunc createFunc)
{
var serviceProvider = new ServiceCollection()
.AddSingleton <CreationCountFakeService>()
.BuildServiceProvider();
var ex = Assert.Throws <InvalidOperationException>(() =>
CreateInstance <CreationCountFakeService>(createFunc, serviceProvider));
Assert.Equal(Resources.FormatCannotResolveService(typeof(IFakeService), typeof(CreationCountFakeService)),
ex.Message);
}
public void TypeActivatorRequiresPublicConstructor(CreateInstanceFunc createFunc, Type type)
{
// Arrange
var expectedMessage = $"A suitable constructor for type '{type}' could not be located. " +
"Ensure the type is concrete and all parameters of a public constructor are either registered as services or passed as arguments. Also ensure no extraneous arguments are provided.";
// Act and Assert
var ex = Assert.Throws <InvalidOperationException>(() =>
createFunc(provider: null, type: type, args: Array.Empty <object>()));
Assert.Equal(expectedMessage, ex.Message);
}
public void TypeActivatorWorksWithCtorWithOptionalArgs_WithStructDefaults(CreateInstanceFunc createFunc)
{
// Arrange
var provider = new TestServiceCollection();
var serviceProvider = CreateServiceProvider(provider);
// Act
var anotherClass = CreateInstance <ClassWithOptionalArgsCtorWithStructs>(createFunc, serviceProvider);
// Assert
Assert.NotNull(anotherClass);
}
public void TypeActivatorRequiresPublicConstructor(CreateInstanceFunc createFunc, Type type)
{
// Arrange
var expectedMessage = $"A suitable constructor for type '{type}' could not be located. " +
"Ensure the type is concrete and services are registered for all parameters of a public constructor.";
// Act and Assert
var ex = Assert.Throws <InvalidOperationException>(() =>
createFunc(provider: null, type: type, args: new object[0]));
Assert.Equal(expectedMessage, ex.Message);
}
public void UnRegisteredServiceAsConstructorParameterThrowsException(CreateInstanceFunc createFunc)
{
var serviceCollection = new ServiceCollection()
.AddSingleton <CreationCountFakeService>();
var serviceProvider = CreateServiceProvider(serviceCollection);
var ex = Assert.Throws <InvalidOperationException>(() =>
CreateInstance <CreationCountFakeService>(createFunc, serviceProvider));
Assert.Equal($"Unable to resolve service for type '{typeof(IFakeService)}' while attempting" +
$" to activate '{typeof(CreationCountFakeService)}'.",
ex.Message);
}
public void TypeActivatorWorksWithCtorWithOptionalArgs(CreateInstanceFunc createFunc)
{
// Arrange
var provider = new TestServiceCollection();
var serviceProvider = CreateServiceProvider(provider);
// Act
var anotherClass = CreateInstance <ClassWithOptionalArgsCtor>(createFunc, serviceProvider);
// Assert
Assert.NotNull(anotherClass);
Assert.Equal("BLARGH", anotherClass.Whatever);
}
public void TypeActivatorRequiresAllArgumentsCanBeAccepted(CreateInstanceFunc createFunc)
{
var serviceProvider = new ServiceCollection()
.AddTransient <IFakeService, FakeService>()
.BuildServiceProvider();
var ex1 = Assert.Throws <InvalidOperationException>(() =>
CreateInstance <AnotherClassAcceptingData>(createFunc, serviceProvider, "1", "2", "3"));
var ex2 = Assert.Throws <InvalidOperationException>(() =>
CreateInstance <AnotherClassAcceptingData>(createFunc, serviceProvider, 1, 2));
Assert.Equal(Resources.FormatNoConstructorMatch(typeof(AnotherClassAcceptingData)), ex1.Message);
Assert.Equal(Resources.FormatNoConstructorMatch(typeof(AnotherClassAcceptingData)), ex2.Message);
}
public void TypeActivatorUsesMarkedConstructor(CreateInstanceFunc createFunc)
{
// Arrange
var serviceCollection = new TestServiceCollection();
serviceCollection.AddSingleton <IFakeService, FakeService>();
var serviceProvider = CreateServiceProvider(serviceCollection);
// Act
var instance = CreateInstance <ClassWithAmbiguousCtorsAndAttribute>(createFunc, serviceProvider, "hello");
// Assert
Assert.Equal("IFakeService, string", instance.CtorUsed);
}
public void TypeActivatorCanDisambiguateConstructorsWithUniqueArguments(CreateInstanceFunc createFunc)
{
// Arrange
var serviceCollection = new ServiceCollection()
.AddTransient <IFakeService, FakeService>();
var serviceProvider = CreateServiceProvider(serviceCollection);
// Act
var instance = CreateInstance <ClassWithAmbiguousCtors>(createFunc, serviceProvider, "1", 2);
// Assert
Assert.NotNull(instance);
Assert.NotNull(instance.FakeService);
Assert.Equal("1", instance.Data1);
Assert.Equal(2, instance.Data2);
}
public void TypeActivatorWorksWithCtorWithOptionalArgs_WithStructDefaults(CreateInstanceFunc createFunc)
{
// Arrange
var provider = new TestServiceCollection();
var serviceProvider = CreateServiceProvider(provider);
// Act
var anotherClass = CreateInstance <ClassWithOptionalArgsCtorWithStructs>(createFunc, serviceProvider);
// Assert
Assert.NotNull(anotherClass);
Assert.Equal(ConsoleColor.DarkGreen, anotherClass.Color);
Assert.Null(anotherClass.ColorNull);
Assert.Equal(12, anotherClass.Integer);
Assert.Null(anotherClass.IntegerNull);
}
public void TypeActivatorRequiresAllArgumentsCanBeAccepted(CreateInstanceFunc createFunc)
{
// Arrange
var expectedMessage = $"A suitable constructor for type '{typeof(AnotherClassAcceptingData).FullName}' could not be located. " +
"Ensure the type is concrete and services are registered for all parameters of a public constructor.";
var serviceCollection = new ServiceCollection()
.AddTransient <IFakeService, FakeService>();
var serviceProvider = CreateServiceProvider(serviceCollection);
var ex1 = Assert.Throws <InvalidOperationException>(() =>
CreateInstance <AnotherClassAcceptingData>(createFunc, serviceProvider, "1", "2", "3"));
var ex2 = Assert.Throws <InvalidOperationException>(() =>
CreateInstance <AnotherClassAcceptingData>(createFunc, serviceProvider, 1, 2));
Assert.Equal(expectedMessage, ex1.Message);
Assert.Equal(expectedMessage, ex2.Message);
}
public void TypeActivatorWorksWithCtorWithOptionalArgs_WithStructDefaults(CreateInstanceFunc createFunc)
{
// Arrange
var provider = new TestServiceCollection();
var serviceProvider = CreateServiceProvider(provider);
// Act
var anotherClass = CreateInstance <ClassWithOptionalArgsCtorWithStructs>(createFunc, serviceProvider);
// Assert
Assert.NotNull(anotherClass);
Assert.Equal(ConsoleColor.DarkGreen, anotherClass.Color);
Assert.Null(anotherClass.ColorNull);
Assert.Equal(12, anotherClass.Integer);
Assert.Null(anotherClass.IntegerNull);
// re-enable once https://github.com/dotnet/csharplang/issues/99 is implemented
// see https://github.com/dotnet/runtime/issues/49069
// Assert.Equal(ExpectStructWithPublicDefaultConstructorInvoked, anotherClass.StructWithConstructor.ConstructorInvoked);
}
public void TypeActivatorAcceptsAnyNumberOfAdditionalConstructorParametersToProvide(CreateInstanceFunc createFunc)
{
// Arrange
var serviceCollection = new ServiceCollection()
.AddTransient <IFakeService, FakeService>();
var serviceProvider = CreateServiceProvider(serviceCollection);
// Act
var anotherClass = CreateInstance <AnotherClassAcceptingData>(createFunc, serviceProvider, "1", "2");
// Assert
Assert.NotNull(anotherClass.FakeService);
Assert.Equal("1", anotherClass.One);
Assert.Equal("2", anotherClass.Two);
}
public void TypeActivatorEnablesYouToCreateAnyTypeWithServicesEvenWhenNotInIocContainer(CreateInstanceFunc createFunc)
{
// Arrange
var serviceCollection = new ServiceCollection()
.AddTransient <IFakeService, FakeService>();
var serviceProvider = CreateServiceProvider(serviceCollection);
var anotherClass = CreateInstance <AnotherClass>(createFunc, serviceProvider);
Assert.NotNull(anotherClass.FakeService);
}
private static T CreateInstance <T>(CreateInstanceFunc func, IServiceProvider provider, params object[] args)
{
return((T)func(provider, typeof(T), args));
}
public void TypeActivatorEnablesYouToCreateAnyTypeWithServicesEvenWhenNotInIocContainer(CreateInstanceFunc createFunc)
{
var serviceProvider = new ServiceCollection()
.AddTransient <IFakeService, FakeService>()
.BuildServiceProvider();
var anotherClass = CreateInstance <AnotherClass>(createFunc, serviceProvider);
var result = anotherClass.LessSimpleMethod();
Assert.Equal("[FakeServiceSimpleMethod]", result);
}
public void TypeActivatorAcceptsAnyNumberOfAdditionalConstructorParametersToProvide(CreateInstanceFunc createFunc)
{
var serviceProvider = new ServiceCollection()
.AddTransient <IFakeService, FakeService>()
.BuildServiceProvider();
var anotherClass = CreateInstance <AnotherClassAcceptingData>(createFunc, serviceProvider, "1", "2");
var result = anotherClass.LessSimpleMethod();
Assert.Equal("[FakeServiceSimpleMethod] 1 2", result);
}
