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(CultureInfo.InvariantCulture, 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_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_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_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_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_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); }
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); }