public void ShouldExtractDomainNameTest(string url, string expected) { var logger = new FakeLogger(); var extractor = new DomainNameExtractor(logger); string result = extractor.GetDomain(url); Assert.Equal(expected, result); }
public void InterceptWithGenericArgAndPredicate_TwoInterceptors_InterceptsTheInstanceWithBothInterceptors() { // Arrange var logger = new FakeLogger(); var container = new Container(); container.RegisterSingleton<ILogger>(logger); container.Register<ICommand, CommandThatLogsOnExecute>(); container.InterceptWith<InterceptorThatLogsBeforeAndAfter>(IsACommandPredicate); container.InterceptWith<InterceptorThatLogsBeforeAndAfter2>(IsACommandPredicate); container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.BeforeText = "Start1 "); container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter2>(i => i.BeforeText = "Start2 "); container.RegisterInitializer<CommandThatLogsOnExecute>(c => c.ExecuteLogMessage = "Executing"); container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.AfterText = " Done1"); container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter2>(i => i.AfterText = " Done2"); // Act var command = container.GetInstance<ICommand>(); command.Execute(); // Assert Assert.AreEqual("Start2 Start1 Executing Done1 Done2", logger.Message); }
public void Intercept_CollectionWithRegistrationInstances_InterceptsTheInstances() { var logger = new FakeLogger(); var container = new Container(); container.RegisterSingleton<ILogger>(logger); container.RegisterCollection<ICommand>(new[] { Lifestyle.Transient.CreateRegistration(typeof(ICommand), typeof(ConcreteCommand), container), Lifestyle.Transient.CreateRegistration(typeof(ConcreteCommand), container), }); container.InterceptWith<InterceptorThatLogsBeforeAndAfter>(IsACommandPredicate); container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.BeforeText = "Log "); // Act var commands = container.GetAllInstances<ICommand>().ToList(); commands.ForEach(Execute); // Assert Assert.AreEqual("Log Log ", logger.Message); }
public ActionResult TestSettings(TestSmtpSettings testSettings) { ILogger logger = null; try { var fakeLogger = new FakeLogger(); var smtpChannelComponent = _smtpChannel as Component; if (smtpChannelComponent != null) { logger = smtpChannelComponent.Logger; smtpChannelComponent.Logger = fakeLogger; } // Temporarily update settings so that the test will actually use the specified host, port, etc. var smtpSettings = _orchardServices.WorkContext.CurrentSite.As<SmtpSettingsPart>(); smtpSettings.Address = testSettings.From; smtpSettings.Host = testSettings.Host; smtpSettings.Port = testSettings.Port; smtpSettings.EnableSsl = testSettings.EnableSsl; smtpSettings.RequireCredentials = testSettings.RequireCredentials; smtpSettings.UseDefaultCredentials = testSettings.UseDefaultCredentials; smtpSettings.UserName = testSettings.UserName; smtpSettings.Password = testSettings.Password; if (!smtpSettings.IsValid()) { fakeLogger.Error("Invalid settings."); } else { _smtpChannel.Process(new Dictionary<string, object> { {"Recipients", testSettings.To}, {"Subject", testSettings.Subject}, {"Body", testSettings.Body}, {"ReplyTo", testSettings.ReplyTo}, {"Bcc", testSettings.Bcc}, {"CC", testSettings.Cc} }); } if (!String.IsNullOrEmpty(fakeLogger.Message)) { return Json(new { error = fakeLogger.Message }); } return Json(new {status = T("Message sent.").Text}); } catch (Exception e) { return Json(new {error = e.Message}); } finally { var smtpChannelComponent = _smtpChannel as Component; if (smtpChannelComponent != null) { smtpChannelComponent.Logger = logger; } // Undo the temporarily changed smtp settings. _orchardServices.TransactionManager.Cancel(); } }
private static ExpiredFileRemovalJob GetTestObject(List <UploadedFile> files) { IUploadedFileRepository repository = Substitute.For <IUploadedFileRepository>(); repository.GetFiles().Returns(Task.FromResult <IList <UploadedFile> >(files.ToList())); repository.When(r => r.Delete(Arg.Any <FileIdentifier>())) .Do(c => files.RemoveAll(f => c.Arg <FileIdentifier>().Equals(f.Id))); return(new ExpiredFileRemovalJob(repository, FakeLogger.Get <ExpiredFileRemovalJob>())); }
public void Add_AnyString_WritesToLog(string number, string loggedMessage) { IMyLogger logger = new FakeLogger(); var calculator = StringCalculatorFactory(true, logger); calculator.Add(number); Assert.AreEqual(loggedMessage, logger.Message); }
public void GetLdapUserManipulator() { var configRepo = new LdapConfigRepository(); var logger = new FakeLogger(); var ldapConnector = LdapConnectorFactory.GetLdapConnector(new LdapAdminModeChecker(configRepo), configRepo, logger); ILdapUserManipulator ldapUserManipulator = LdapUserManipulatorFactory.GetUserManipulator(ldapConnector, logger, configRepo); Assert.IsInstanceOfType(ldapUserManipulator, typeof(ILdapUserManipulator)); }
public void ValidatorTest(string domainName, bool expected) { var logger = new FakeLogger(); var seriazlier = new FakeDomainSerializer(); var validator = new DomainValidator(logger, seriazlier); bool result = validator.IsValid(domainName); Assert.Equal(expected, result); }
public void CheckIfSslIsEnforcedTest(string domain, bool shouldBeEnforced) { var logger = new FakeLogger(); var serializer = new FakeDomainSerializer(); var check = new SslDomainCheck(logger, serializer); bool result = check.EnforceSsl(domain); Assert.Equal(shouldBeEnforced, result); }
public async Task FindClientByIdAsync_WhenClientDoesNotExist_ExpectNull(DbContextOptions <ConfigurationDbContext> options) { using (var context = new ConfigurationDbContext(options, StoreOptions)) { var store = new ClientStore(context, FakeLogger <ClientStore> .Create()); var client = await store.FindClientByIdAsync(Guid.NewGuid().ToString()); client.Should().BeNull(); } }
void CreateViewModel(FakePackageManagementSolution solution) { viewModelParent = CreateViewModelParent(); viewModel = new TestablePackageViewModel(viewModelParent, solution); fakePackage = viewModel.FakePackage; this.fakeSolution = solution; packageManagementEvents = viewModel.PackageManagementEvents; fakeLogger = viewModel.FakeLogger; fakeUninstallPackageAction = solution.FakeProjectToReturnFromGetProject.FakeUninstallPackageAction; }
public void TryRemoveLoggerTest() { var logger = new FakeLogger(); _compoundLogger.TryAddLogger(logger); Assert.IsNotEmpty(_compoundLogger.Loggers); _compoundLogger.TryRemoveLogger(logger); Assert.IsEmpty(_compoundLogger.Loggers); }
public void TestConvention(string domain, string expected) { var logger = new FakeLogger(); var serializer = new FakeDomainSerializer(); var convention = new ByConvention(logger, serializer); string result = convention.GetTenantName(domain); Assert.Equal(expected, result); }
public void SetUp() { _parser = new FakeParser(); _logger = new FakeLogger(); _fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>()); _directory = new MockDirectoryInfo(_fileSystem, @"C:\databasename"); _service = new FileSystemScriptRepository(_directory, "servername", databaseName, _fileSystem, _parser, _logger, true); }
public void TestOrConvention(string domain, string or, string expected) { var logger = new FakeLogger(); var serializer = new FakeDomainSerializer(); var convention = new ByConvention(logger, serializer); string result = convention.GetTenantName(domain, or); Assert.Equal(expected, result); }
public ILogger CreateLogger(string categoryName) { lock (_lock) { var logger = new FakeLogger(); LoggerInstances.Add(logger); return(logger); } }
public void CheckIfStaticDomainTest(string domain, bool isStatic) { var logger = new FakeLogger(); var serializer = new FakeDomainSerializer(); var check = new StaticDomainCheck(logger, serializer); bool result = check.IsStaticDomain(domain); Assert.Equal(isStatic, result); }
public async Task GetAllResources_WhenAllResourcesRequested_ExpectAllResourcesIncludingHidden(DbContextOptions <ConfigurationDbContext> options) { var visibleIdentityResource = CreateIdentityTestResource(); var visibleApiResource = CreateApiResourceTestResource(); var visibleApiScope = CreateApiScopeTestResource(); var hiddenIdentityResource = new IdentityResource { Name = Guid.NewGuid().ToString(), ShowInDiscoveryDocument = false }; var hiddenApiResource = new ApiResource { Name = Guid.NewGuid().ToString(), Scopes = { Guid.NewGuid().ToString() }, ShowInDiscoveryDocument = false }; var hiddenApiScope = new ApiScope { Name = Guid.NewGuid().ToString(), ShowInDiscoveryDocument = false }; using (var context = new ConfigurationDbContext(options, StoreOptions)) { context.IdentityResources.Add(visibleIdentityResource.ToEntity()); context.ApiResources.Add(visibleApiResource.ToEntity()); context.ApiScopes.Add(visibleApiScope.ToEntity()); context.IdentityResources.Add(hiddenIdentityResource.ToEntity()); context.ApiResources.Add(hiddenApiResource.ToEntity()); context.ApiScopes.Add(hiddenApiScope.ToEntity()); context.SaveChanges(); } Resources resources; using (var context = new ConfigurationDbContext(options, StoreOptions)) { var store = new ResourceStore(context, FakeLogger <ResourceStore> .Create()); resources = await store.GetAllResourcesAsync(); } Assert.NotNull(resources); Assert.NotEmpty(resources.IdentityResources); Assert.NotEmpty(resources.ApiResources); Assert.NotEmpty(resources.ApiScopes); Assert.Contains(resources.IdentityResources, x => x.Name == visibleIdentityResource.Name); Assert.Contains(resources.IdentityResources, x => x.Name == hiddenIdentityResource.Name); Assert.Contains(resources.ApiResources, x => x.Name == visibleApiResource.Name); Assert.Contains(resources.ApiResources, x => x.Name == hiddenApiResource.Name); Assert.Contains(resources.ApiScopes, x => x.Name == visibleApiScope.Name); Assert.Contains(resources.ApiScopes, x => x.Name == hiddenApiScope.Name); }
public void ValidatorTest(string tenantName, bool expected) { var logger = new FakeLogger(); var seriazlier = new FakeDomainSerializer(); var convention = new ByConvention(logger, seriazlier); var validator = new TenantValidator(logger, seriazlier, convention); bool result = validator.IsValid(tenantName); Assert.Equal(expected, result); }
public void IsLoginOK_WhenLoginOK_CallsLogger() { FakeLogger mockLog = new FakeLogger(); var loginManager = new LoginManagerWithMock(mockLog); loginManager.AddUser("u","p"); loginManager.IsLoginOK("u", "p"); StringAssert.Contains("login ok: user: u", mockLog.Text); }
public async Task StoreAsync_WhenPersistedGrantStored_ExpectSuccess() { var persistedGrant = CreateTestObject(); var store = new PersistedGrantStore(_context, FakeLogger <PersistedGrantStore> .Create()); await store.StoreAsync(persistedGrant); var foundGrant = (await _context.PersistedGrants.WhereEqualTo("Key", persistedGrant.Key).GetSnapshotAsync())[0].ConvertTo <Entities.PersistedGrant>(); Assert.NotNull(foundGrant); }
public void Write_To_The_Log() { var logger = new FakeLogger(); var controller = new HelloController(logger); controller.Execute(new FakeRequestContext()); Assert.IsNotNull(logger.LogResult); Assert.IsTrue(logger.LogResult.Length > 0); }
public async Task FindByDeviceCodeAsync_WhenDeviceCodeExists_ExpectDataRetrievedCorrectly() { using var ravenStore = GetDocumentStore(); await new DeviceFlowCodeIndex().ExecuteAsync(ravenStore); var testDeviceCode = $"device_{Guid.NewGuid().ToString()}"; var testUserCode = $"user_{Guid.NewGuid().ToString()}"; var expectedSubject = $"sub_{Guid.NewGuid().ToString()}"; var expectedDeviceCodeData = new DeviceCode { ClientId = "device_flow", RequestedScopes = new[] { "openid", "api1" }, CreationTime = new DateTime(2018, 10, 19, 16, 14, 29), Lifetime = 300, IsOpenId = true, Subject = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim> { new Claim(JwtClaimTypes.Subject, expectedSubject) })) }; using (var session = ravenStore.OpenSession()) { session.Store(new DeviceFlowCode { DeviceCode = testDeviceCode, UserCode = testUserCode, ClientId = expectedDeviceCodeData.ClientId, SubjectId = expectedDeviceCodeData.Subject.FindFirst(JwtClaimTypes.Subject).Value, CreationTime = expectedDeviceCodeData.CreationTime, Expiration = expectedDeviceCodeData.CreationTime.AddSeconds(expectedDeviceCodeData.Lifetime), Data = serializer.Serialize(expectedDeviceCodeData) }); session.SaveChanges(); } WaitForIndexing(ravenStore); DeviceCode code; using (var session = ravenStore.OpenAsyncSession()) { var store = new DeviceFlowStore(session, new PersistentGrantSerializer(), FakeLogger <DeviceFlowStore> .Create()); code = await store.FindByDeviceCodeAsync(testDeviceCode); } code.Should().BeEquivalentTo(expectedDeviceCodeData, assertionOptions => assertionOptions.Excluding(x => x.Subject)); code.Subject.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Subject && x.Value == expectedSubject) .Should().NotBeNull(); }
public async Task StoreAsync_WhenPersistedGrantStored_ExpectSuccess() { var persistedGrant = CreateTestObject(); var store = new PersistedGrantStore(g.operationalDb, FakeLogger <PersistedGrantStore> .Create()); await store.StoreAsync(persistedGrant); var foundGrant = g.operationalDb.Select <Storage.Entities.PersistedGrant>().Where(x => x.Key == persistedGrant.Key).First(); Assert.NotNull(foundGrant); }
public void Logger_SetLoggerWhenSourceRepositoryIsAggregateRepository_LoggerOnAggregateRepositoryIsSet() { var aggregateRepository = new AggregateRepository(new FakePackageRepository [0]); CreateProject(aggregateRepository); var expectedLogger = new FakeLogger(); project.Logger = expectedLogger; Assert.AreEqual(expectedLogger, aggregateRepository.Logger); }
public LikesController( IMapper mapper, ILikeRepository likeRepository, FakeLogger logger, IAccountRepository accountRepository) { _mapper = mapper; _likeRepository = likeRepository; _logger = logger; _accountRepository = accountRepository; }
public async Task FindClientByIdAsync_WhenClientDoesNotExist_ExpectNull() { var storeHolder = GetConfigurationDocumentStoreHolder(); WaitForIndexing(storeHolder.IntegrationTest_GetDocumentStore()); var store = new ClientStore(storeHolder, FakeLogger <ClientStore> .Create()); var client = await store.FindClientByIdAsync(Guid.NewGuid().ToString()); client.Should().BeNull(); }
public void UsingConditionalDirectives() { var logger = new FakeLogger(); #if LOG logger.WriteLogMessage("Message 1"); #endif #if LOG logger.WriteLogMessage("Message 2"); #endif }
public ActionResult TestSettings(TestSmsSettings testSettings) { ILogger logger = null; try { var fakeLogger = new FakeLogger(); var smsChannelComponent = _smsChannel as Component; if (smsChannelComponent != null) { logger = smsChannelComponent.Logger; smsChannelComponent.Logger = fakeLogger; } // Temporarily update settings so that the test will actually use the specified host, port, etc. var smsSettings = _orchardServices.WorkContext.CurrentSite.As <SmsSettingsPart>(); smsSettings.AccountSid = testSettings.AccountSid; smsSettings.AuthToken = testSettings.AuthToken; smsSettings.TwilioNumber = testSettings.From; if (!smsSettings.IsValid()) { fakeLogger.Error("Invalid settings."); } else { _smsChannel.Process(new Dictionary <string, object> { { "Recipients", testSettings.To }, { "Body", testSettings.Body } }); } if (!String.IsNullOrEmpty(fakeLogger.Message)) { return(Json(new { error = fakeLogger.Message })); } return(Json(new { status = T("Message sent.").Text })); } catch (Exception e) { return(Json(new { error = e.Message })); } finally { var smsChannelComponent = _smsChannel as Component; if (smsChannelComponent != null) { smsChannelComponent.Logger = logger; } // Undo the temporarily changed smtp settings. _orchardServices.TransactionManager.Cancel(); } }
public void SetUp() { var gitExe = new Mock <IExternalProcess>(); _parser = new FakeParser(); _logger = new FakeLogger(); _fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>()); _directory = new MockDirectoryInfo(_fileSystem, @"C:\databasename"); _service = new GitScriptRepository(_directory, "servername", databaseName, gitExe.Object, _fileSystem, _parser, _logger, true); }
public void IsLoginOK_WhenLoginOK_CallsLogger() { FakeLogger mockLog = new FakeLogger(); var loginManager = new LoginManagerWithMock(mockLog); loginManager.AddUser("u", "p"); loginManager.IsLoginOK("u", "p"); StringAssert.Contains("login ok: user: u", mockLog.Text); }
public void LogsErrorWhenInputIsZeroTake3() { var fakeLogger = new FakeLogger(); var someService = new SomeService(fakeLogger); someService.DoSomething(0); // Option 3: Create your own instance of ILogger<T> that has a non-extension version of the method // Doesn't work, unless you change system under test to take in a FakeLogger (which is useless) Assert.NotNull(FakeLogger.ProvidedException); Assert.NotNull(FakeLogger.ProvidedMessage); }
public void Log_ExceptionIsNotValidationException_LogsError() { // arrange var logger = new FakeLogger(); var exception = new InvalidOperationException("Something is not right"); // act exception.Log(logger); // assert Assert.Equal(2, logger.LogCallCount); }
public void Log_ExceptionIsValidationException_DoesNotLogError() { // arrange var logger = new FakeLogger(); var exception = new ValidationException("Something is not right"); // act exception.Log(logger); // assert Assert.Equal(0, logger.LogCallCount); }
public virtual void CallingLogExceptionWithUnhandledException_DoesNotLog() { //Arrange var logger = new FakeLogger <ActionStoppingException>(); var sut = new ActionStoppingExceptionHandler(logger); //Act Assert.Catch(() => sut.LogException(new NullReferenceException())); //Assert logger.LoggedEvents.Count.Should().Be(0); }
public virtual void CallingLogExceptionLogsForHandledException() { //Arrange var logger = new FakeLogger <TException>(); var sut = (THandler)Activator.CreateInstance(typeof(THandler), logger); //Act sut.LogException(_exceptionCreator()); //Assert logger.LoggedEvents.Count.Should().Be(1); }
public virtual void CallingLogExceptionWithUnhandledException_Throws() { //Arrange var logger = new FakeLogger <TException>(); var sut = (THandler)Activator.CreateInstance(typeof(THandler), logger); //Act var exception = Assert.Catch(() => sut.LogException(new NullReferenceException())); //Assert exception.Should().BeOfType <ArgumentException>(); }
public void Test(string currentDomain, string expectedToken) { var logger = new FakeLogger(); var serializer = new FakeDomainSerializer(); var check = new StaticDomainCheck(logger, serializer); var tokenizer = new FakeTokenizer(); var generator = new AntiforgeryTokenGenerator(check, tokenizer, currentDomain); var result = generator.GetAntiForgeryToken(); var expected = new MvcHtmlString(expectedToken); Assert.Equal(expected.ToString(), result.ToString()); }
public void ShouldFindDomainByTenantName(string defaultSite, string synonym, string expectedDomain) { var logger = new FakeLogger(); var serializer = new FakeDomainSerializer(); var convention = new ByConvention(logger, serializer); var finder = new DomainFinder(serializer, convention); var found = finder.FindBySynonym(synonym, defaultSite); string result = found.DomainName; Assert.Equal(expectedDomain, result); }
public void TestConvention(string url, string expected) { string defaultTenant = "localhost"; var logger = new FakeLogger(); var serializer = new FakeDomainSerializer(); var extractor = new DomainNameExtractor(logger); var convention = new ByConvention(logger, serializer); var validator = new TenantValidator(logger, serializer, convention); var locator = new TenantLocator(logger, extractor, convention, validator, serializer); string result = locator.FromUrl(url, defaultTenant); Assert.Equal(expected, result); }
public ActionResult TestSettings(TestSmsSettings testSettings) { ILogger logger = null; try { var fakeLogger = new FakeLogger(); var smsChannelComponent = _smsChannel as Component; if (smsChannelComponent != null) { logger = smsChannelComponent.Logger; smsChannelComponent.Logger = fakeLogger; } // Temporarily update settings so that the test will actually use the specified host, port, etc. var smsSettings = _orchardServices.WorkContext.CurrentSite.As<SmsSettingsPart>(); smsSettings.AccountSid = testSettings.AccountSid; smsSettings.AuthToken = testSettings.AuthToken; smsSettings.TwilioNumber = testSettings.From; if (!smsSettings.IsValid()) { fakeLogger.Error("Invalid settings."); } else { _smsChannel.Process(new Dictionary<string, object> { {"Recipients", testSettings.To}, {"Body", testSettings.Body} }); } if (!String.IsNullOrEmpty(fakeLogger.Message)) { return Json(new { error = fakeLogger.Message }); } return Json(new {status = T("Message sent.").Text}); } catch (Exception e) { return Json(new {error = e.Message}); } finally { var smsChannelComponent = _smsChannel as Component; if (smsChannelComponent != null) { smsChannelComponent.Logger = logger; } // Undo the temporarily changed smtp settings. _orchardServices.TransactionManager.Cancel(); } }
public void TestGenerateMethod(string url, string expected) { var logger = new FakeLogger(); var extractor = new DomainNameExtractor(logger); var serializer = new FakeDomainSerializer(); var byConvention = new ByConvention(logger, serializer); var validator = new TenantValidator(logger, serializer, byConvention); const string defaultTenant = "localhost"; var locator = new TenantLocator(logger, extractor, byConvention, validator, serializer); var uri = new Uri(url); var keyGen = new CacheKeyGenerator(uri, locator, defaultTenant); string result = keyGen.Generate(); Assert.Equal(expected, result); }
public void InterceptWithFuncAndPredicate_TwoInterceptors_InterceptsTheInstanceWithBothInterceptors() { // Arrange var logger = new FakeLogger(); Func<IInterceptor> interceptorCreator1 = () => new InterceptorThatLogsBeforeAndAfter(logger) { BeforeText = "Start1 ", AfterText = " Done1" }; Func<IInterceptor> interceptorCreator2 = () => new InterceptorThatLogsBeforeAndAfter(logger) { BeforeText = "Start2 ", AfterText = " Done2" }; var container = new Container(); container.RegisterSingleton<ILogger>(logger); container.Register<ICommand, CommandThatLogsOnExecute>(); container.InterceptWith(interceptorCreator1, IsACommandPredicate); container.InterceptWith(interceptorCreator2, IsACommandPredicate); container.RegisterInitializer<CommandThatLogsOnExecute>(c => c.ExecuteLogMessage = "Executing"); // Act var command = container.GetInstance<ICommand>(); command.Execute(); // Assert Assert.AreEqual("Start2 Start1 Executing Done1 Done2", logger.Message); }
public void InterceptWithInstanceAndPredicate_InterceptingInterfacesEndingWithCommand_InterceptsTheInstance() { // Arrange var logger = new FakeLogger(); var singletonInterceptor = new InterceptorThatLogsBeforeAndAfter(logger) { BeforeText = "Start ", AfterText = " Done" }; var container = ContainerFactory.New(); container.RegisterSingleton<ILogger>(logger); container.Register<ICommand, CommandThatLogsOnExecute>(); container.InterceptWith(singletonInterceptor, IsACommandPredicate); container.RegisterInitializer<CommandThatLogsOnExecute>(c => c.ExecuteLogMessage = "Executing"); // Act var command = container.GetInstance<ICommand>(); command.Execute(); // Assert Assert.AreEqual("Start Executing Done", logger.Message); }
public void InterceptWithGenericArgAndPredicate_RequestingAConcreteType_WillNotBeIntercepted() { // Arrange var logger = new FakeLogger(); var container = ContainerFactory.New(); container.RegisterSingleton<ILogger>(logger); container.InterceptWith<InterceptorThatLogsBeforeAndAfter>(type => type == typeof(ICommand)); container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.BeforeText = "Start "); container.RegisterInitializer<CommandThatLogsOnExecute>(c => c.ExecuteLogMessage = "Executing"); container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.AfterText = " Done"); // Act var command = container.GetInstance<CommandThatLogsOnExecute>(); command.Execute(); // Assert Assert.AreEqual("Executing", logger.Message); Assert.IsTrue(command.GetType() == typeof(CommandThatLogsOnExecute)); }
public LoggerExecutionWrapperTests() { _fakeLogger = new FakeLogger(); _sut = new LoggerExecutionWrapper(_fakeLogger.Log); }
public virtual void SetUp() { _logger = new FakeLogger(); }
public void Intercept_DecoratedGenericRegistrations_WorksLikeACharm() { // Arrange var logger = new FakeLogger(); var container = new Container(); container.RegisterSingleton<ILogger>(logger); container.Register<ICommand, CommandThatLogsOnExecute>(); container.Register(typeof(IValidator<>), typeof(LoggingValidator<>)); container.RegisterDecorator(typeof(IValidator<>), typeof(LoggingValidatorDecorator<>)); container.InterceptWith<InterceptorThatLogsBeforeAndAfter>( t => t.IsInterface && t.Name.StartsWith("IValidator")); container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.BeforeText = "Inercepting "); container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.AfterText = "Intercepted "); // Act container.GetInstance<IValidator<RealCommand>>().Validate(new RealCommand()); // Assert Assert.AreEqual("Inercepting Decorating Validating Decorated Intercepted ", logger.Message); }