public void Should_warn_of_bad_assembly_files()
{
// Arrange
var badAssemblyFile = Path.GetTempFileName() + ".dll";
var expectedMessageFormat =
@"*Warning: FakeItEasy failed to load assembly '{0}' while scanning for extension points. Any IArgumentValueFormatters, IDummyFactories, and IFakeOptionsBuilders in that assembly will not be available.*";
var expectedMessage = string.Format(expectedMessageFormat, badAssemblyFile);
string actualMessage;
var catalogue = new TypeCatalogue();
try
{
File.CreateText(badAssemblyFile).Dispose();
// Act
actualMessage = CaptureConsoleOutput(() => catalogue.Load(new[] { badAssemblyFile }));
}
finally
{
File.Delete(badAssemblyFile);
}
// Assert
actualMessage.Should().Match(expectedMessage);
}
public void Should_be_able_to_get_types_from_assembly_in_app_domain()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
catalogue.Load(Enumerable.Empty <string>());
// Assert
catalogue.GetAvailableTypes().Should().Contain(typeof(DoubleValueFormatter));
}
public void Should_be_able_to_get_types_from_fakeiteasy()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
catalogue.Load(Enumerable.Empty <string>());
// Assert
catalogue.GetAvailableTypes().Should().Contain(typeof(A));
}
public void Should_be_able_to_get_types_from_assembly_in_app_domain()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
catalogue.Load(Directory.GetFiles(Environment.CurrentDirectory, "*.dll"));
// Assert
catalogue.GetAvailableTypes().Should().Contain(typeof(DoubleValueFormatter));
}
public void Should_not_be_able_to_get_types_from_assembly_that_does_not_reference_fakeiteasy()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
catalogue.Load(Enumerable.Empty <string>());
// Assert
catalogue.GetAvailableTypes().Should().NotContain(typeof(string));
}
public void Should_be_able_to_get_types_from_external_assembly()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
catalogue.Load(new[] { this.GetPathToOriginalExternalDll() });
// Assert
catalogue.GetAvailableTypes().Select(type => type.FullName).Should().Contain("FakeItEasy.IntegrationTests.External.GuidValueFormatter");
}
public void Should_not_include_types_from_fakeiteasy()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
CaptureConsoleOutput(() => catalogue.Load(Enumerable.Empty <string>()));
// Assert
catalogue.GetAvailableTypes().Should().NotContain(typeof(A));
}
public void Should_be_able_to_get_types_from_external_assembly_in_directory()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
catalogue.Load(Directory.GetFiles(Environment.CurrentDirectory, "*.dll"));
// Assert
catalogue.GetAvailableTypes().Select(type => type.FullName).Should().Contain("FakeItEasy.IntegrationTests.External.GuidValueFormatter");
}
public void Should_be_able_to_get_types_from_external_assembly()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
CaptureConsoleOutput(() => catalogue.Load(new[] { this.externalAssemblyGenerator.AssemblyOriginalPath }));
// Assert
catalogue.GetAvailableTypes().Select(type => type.FullName).Should().Contain("FakeItEasy.IntegrationTests.External.GuidValueFormatter");
}
public void Should_not_be_able_to_get_types_from_assembly_that_does_not_reference_fakeiteasy()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
catalogue.Load(Directory.GetFiles(Environment.CurrentDirectory, "*.dll"));
// Assert
catalogue.GetAvailableTypes().Should().NotContain(typeof(string));
}
public void Should_be_able_to_get_types_from_fakeiteasy()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
catalogue.Load(Directory.GetFiles(Environment.CurrentDirectory, "*.dll"));
// Assert
catalogue.GetAvailableTypes().Should().Contain(typeof(A));
}
public void Should_warn_if_some_types_cannot_be_loaded_from_external_assembly()
{
// Arrange
var catalogue = new TypeCatalogue();
// Act
string output = CaptureConsoleOutput(
() => catalogue.Load(new[] { this.externalAssemblyGenerator.AssemblyOriginalPath }));
// Assert
output.Should().MatchModuloLineEndings(@"*Warning: FakeItEasy failed to get some types from assembly 'FakeItEasy.ExtensionPoints.External, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' while scanning for extension points. Some IArgumentValueFormatters, IDummyFactories, and IFakeOptionsBuilders in that assembly might not be available.
System.Reflection.ReflectionTypeLoadException: *
1 type(s) were not loaded for the following reasons:
- System.IO.FileNotFoundException: *");
}
public override void RegisterDependencies(DictionaryContainer container)
{
var bootstrapper = BootstrapperLocator.FindBootstrapper();
container.RegisterSingleton <TypeCatalogueInstanceProvider>(c =>
new TypeCatalogueInstanceProvider(c.Resolve <ITypeCatalogue>()));
container.RegisterSingleton <ITypeCatalogue>(c =>
{
var typeCatalogue = new TypeCatalogue();
typeCatalogue.Load(bootstrapper.GetAssemblyFileNamesToScanForExtensions());
return(typeCatalogue);
});
RegisterEnumerableInstantiatedFromTypeCatalogue <IArgumentValueFormatter>(container);
RegisterEnumerableInstantiatedFromTypeCatalogue <IDummyDefinition>(container);
RegisterEnumerableInstantiatedFromTypeCatalogue <IFakeConfigurator>(container);
}
public void Should_warn_of_duplicate_input_assemblies_with_different_paths()
{
// Arrange
var expectedMessage =
@"*Warning: FakeItEasy failed to load assembly 'FakeItEasy.ExtensionPoints.External*' while scanning for extension points. Any IArgumentValueFormatters, IDummyFactories, and IFakeOptionsBuilders in that assembly will not be available.*";
var catalogue = new TypeCatalogue();
// Act
var actualMessage = CaptureConsoleOutput(() => catalogue.Load(new[]
{
this.externalAssemblyGenerator.AssemblyOriginalPath, this.externalAssemblyGenerator.AssemblyCopyPath
}));
// Assert
actualMessage.Should().Match(expectedMessage);
}
public void Should_warn_of_bad_assembly_files()
{
// Arrange
var badAssemblyFile = Path.GetTempFileName() + ".dll";
var expectedMessageFormat =
@"*Warning: FakeItEasy failed to load assembly '{0}' while scanning for extension points. Any IArgumentValueFormatters, IDummyFactories, and IFakeOptionsBuilders in that assembly will not be available.
*{0}*";
var expectedMessage = string.Format(CultureInfo.InvariantCulture, expectedMessageFormat, badAssemblyFile);
string actualMessage = null;
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream))
{
var catalogue = new TypeCatalogue();
File.CreateText(badAssemblyFile).Close();
try
{
var originalWriter = Console.Out;
Console.SetOut(writer);
try
{
// Act
catalogue.Load(new[] { badAssemblyFile });
}
finally
{
Console.SetOut(originalWriter);
}
}
finally
{
File.Delete(badAssemblyFile);
}
writer.Flush();
actualMessage = writer.Encoding.GetString(stream.GetBuffer());
}
// Assert
actualMessage.Should().Match(expectedMessage);
}
public void Should_be_able_to_get_types_from_referenced_but_not_loaded_assembly()
{
// Ideally, for this test, the FakeItEasy.Tests.ExtensionPoints assembly shouldn't be loaded
// in the AppDomain yet, so that we can ensure it's properly loaded by TypeCatalogue as a
// referenced assembly. But other tests running before this one cause it to be loaded earlier,
// because TypeCatalogue runs the first time FakeItEasy is used.
// Since FakeItEasy.Tests.ExtensionPoints is never actually used, the only reason for it to be
// loaded is because it's referenced by the current assembly. So this test *does* check that
// referenced assemblies are scanned, but it could have actually happened earlier than this test.
// Arrange
var catalogue = new TypeCatalogue();
// Act
CaptureConsoleOutput(() => catalogue.Load(Enumerable.Empty <string>()));
// Assert
catalogue.GetAvailableTypes().Should().Contain(t => t.FullName == "FakeItEasy.Tests.ExtensionPoints.DayOfWeekDummyFactory");
}
public void Should_warn_of_duplicate_input_assemblies_with_different_paths()
{
// Arrange
var currentDirectoryName = new DirectoryInfo(Environment.CurrentDirectory).Name;
// FakeItEasy.IntegrationTests.External has copies of many of the assemblies used in these
// tests as well. By specifying assembly paths from that directory, the catalog will see
// those assemblies in both locations, and should fail to load the duplicates.
var directoryToScan = Path.Combine(
Environment.CurrentDirectory,
Path.Combine(@"..\..\..\FakeItEasy.IntegrationTests.External\bin", currentDirectoryName));
var expectedMessageFormat =
@"*Warning: FakeItEasy failed to load assembly '*FakeItEasy.IntegrationTests.External\bin\{0}\FakeItEasy.IntegrationTests.External.dll' while scanning for extension points. Any IArgumentValueFormatters, IDummyFactories, and IFakeConfigurators in that assembly will not be available.
API restriction: The assembly '*FakeItEasy.IntegrationTests.External\bin\{0}\FakeItEasy.IntegrationTests.External.dll' has already loaded from a different location. It cannot be loaded from a new location within the same appdomain.*";
var expectedMessage = string.Format(CultureInfo.InvariantCulture, expectedMessageFormat, currentDirectoryName);
string actualMessage;
using (var messageStream = new MemoryStream())
using (var messageWriter = new StreamWriter(messageStream))
{
var catalogue = new TypeCatalogue();
var originalWriter = Console.Out;
Console.SetOut(messageWriter);
try
{
// Act
catalogue.Load(Directory.GetFiles(directoryToScan, "*.dll"));
}
finally
{
Console.SetOut(originalWriter);
}
messageWriter.Flush();
actualMessage = messageWriter.Encoding.GetString(messageStream.GetBuffer());
}
// Assert
actualMessage.Should().Match(expectedMessage);
}
public void Should_warn_of_duplicate_input_assemblies_with_different_paths()
{
// Arrange
var originalExternalDll = this.GetPathToOriginalExternalDll();
var copyOfExternalDll = this.GetPathToCopyOfExternalDll();
File.Copy(originalExternalDll, copyOfExternalDll, overwrite: true);
var expectedMessageFormat =
@"*Warning: FakeItEasy failed to load assembly '*{0}' while scanning for extension points. Any IArgumentValueFormatters, IDummyFactories, and IFakeOptionsBuilders in that assembly will not be available.*";
var expectedMessage = string.Format(CultureInfo.InvariantCulture, expectedMessageFormat, copyOfExternalDll);
var catalogue = new TypeCatalogue();
// Act
var actualMessage = CaptureConsoleOutput(() => catalogue.Load(new[]
{
originalExternalDll, copyOfExternalDll
}));
// Assert
actualMessage.Should().Match(expectedMessage);
}
private static IEnumerable <Type> Results(TypeCatalogue types)
{
return(types.Implements <BaseTransportMessage>());
}
public static void RegisterDependencies(IServiceRegistrar registrar)
{
var bootstrapper = BootstrapperLocator.FindBootstrapper();
var typeCatalogue = new TypeCatalogue();
var assemblyFilesNames = bootstrapper.GetAssemblyFileNamesToScanForExtensions()
?? throw new InvalidOperationException(ExceptionMessages.GetAssemblyFileNamesToScanForExtensionsShouldntReturnNull);
typeCatalogue.Load(assemblyFilesNames);
var typeCatalogueInstanceProvider = new TypeCatalogueInstanceProvider(typeCatalogue);
var argumentValueFormatters = typeCatalogueInstanceProvider.InstantiateAllOfType <IArgumentValueFormatter>();
var dummyFactories = typeCatalogueInstanceProvider.InstantiateAllOfType <IDummyFactory>();
var fakeOptionsBuilders = typeCatalogueInstanceProvider.InstantiateAllOfType <IFakeOptionsBuilder>();
var implicitOptionsBuilderCatalogue = new ImplicitOptionsBuilderCatalogue(fakeOptionsBuilders);
var methodInfoManager = new MethodInfoManager();
var argumentConstraintTrap = new ArgumentConstraintTrap();
var expressionArgumentConstraintFactory = new ExpressionArgumentConstraintFactory(argumentConstraintTrap);
var fakeManagerAccessor = new DefaultFakeManagerAccessor();
var fakeObjectCreator = new FakeObjectCreator(
FakeCallProcessorProviderFactory,
new CastleDynamicProxyInterceptionValidator(methodInfoManager),
new DelegateProxyInterceptionValidator());
var callExpressionParser = new CallExpressionParser();
var interceptionAsserter = new DefaultInterceptionAsserter(fakeObjectCreator);
var argumentValueFormatter = new ArgumentValueFormatter(argumentValueFormatters);
var fakeObjectCallFormatter = new DefaultFakeObjectCallFormatter(argumentValueFormatter, fakeManagerAccessor);
var callWriter = new CallWriter(fakeObjectCallFormatter, new FakeCallEqualityComparer());
var configurationFactory = new ConfigurationFactory(RuleBuilderFactory);
registrar.Register <IExpressionCallMatcherFactory>(new ExpressionCallMatcherFactory(expressionArgumentConstraintFactory, methodInfoManager));
registrar.Register(expressionArgumentConstraintFactory);
registrar.Register <FakeAndDummyManager>(
new FakeAndDummyManager(
new DummyValueResolver(new DynamicDummyFactory(dummyFactories), fakeObjectCreator),
fakeObjectCreator,
implicitOptionsBuilderCatalogue));
registrar.Register <IArgumentConstraintManagerFactory>(new ArgumentConstraintManagerFactory());
registrar.Register(new EventHandlerArgumentProviderMap());
registrar.Register <SequentialCallContext.Factory>(SequentialCallContextFactory);
registrar.Register <IStartConfigurationFactory>(
new StartConfigurationFactory(ExpressionCallRuleFactory, configurationFactory, callExpressionParser, interceptionAsserter));
registrar.Register <IFakeConfigurationManager>(
new FakeConfigurationManager(configurationFactory, ExpressionCallRuleFactory, callExpressionParser, interceptionAsserter));
registrar.Register <IFakeManagerAccessor>(fakeManagerAccessor);
registrar.Register <ICallExpressionParser>(callExpressionParser);
registrar.Register((StringBuilderOutputWriter.Factory)StringBuilderOutputWriterFactory);
registrar.Register <IFakeObjectCallFormatter>(fakeObjectCallFormatter);
StringBuilderOutputWriter StringBuilderOutputWriterFactory() =>
new StringBuilderOutputWriter(argumentValueFormatter !);
FakeManager FakeManagerFactory(Type fakeObjectType, object proxy, string?name) =>
new FakeManager(fakeObjectType, proxy, name);
IFakeCallProcessorProvider FakeCallProcessorProviderFactory(Type typeOfFake, IProxyOptions proxyOptions) =>
new FakeManagerProvider(FakeManagerFactory, fakeManagerAccessor, typeOfFake, proxyOptions);
ExpressionCallRule ExpressionCallRuleFactory(ParsedCallExpression callSpecification) =>
new ExpressionCallRule(new ExpressionCallMatcher(callSpecification, expressionArgumentConstraintFactory, methodInfoManager));
IFakeAsserter FakeAsserterFactory(IEnumerable <CompletedFakeObjectCall> calls, int lastSequenceNumber) =>
new FakeAsserter(calls, lastSequenceNumber, callWriter, StringBuilderOutputWriterFactory);
SequentialCallContext SequentialCallContextFactory() =>
new SequentialCallContext(callWriter, StringBuilderOutputWriterFactory);
RuleBuilder RuleBuilderFactory(BuildableCallRule rule, FakeManager fake) =>
new RuleBuilder(rule, fake, FakeAsserterFactory);
}
