public void Analyze_ConfigurationWithCollectionWithMultipleDecoratorsWithValidNumberOfDependencies_DoesNotWarnAboutThatDecorator()
{
// Arrange
Container container = CreateContainerWithRegistrations(Type.EmptyTypes);
container.RegisterDecorator(typeof(IPlugin), typeof(PluginDecoratorWith5Dependencies));
container.RegisterDecorator(typeof(IPlugin), typeof(PluginDecoratorWith5Dependencies));
container.RegisterDecorator(typeof(IPlugin), typeof(PluginDecoratorWith5Dependencies));
// Non of these types have too many dependencies.
container.RegisterCollection <IPlugin>(new[] { typeof(PluginImpl), typeof(SomePluginImpl) });
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container);
// Assert
Assert.AreEqual("No warnings detected.", results.Description, @"
Although the decorator has too many dependencies, the system has not enough information to
differentiate between a decorator with too many dependencies and a decorator that wraps many
elements. The diagnostic system simply registers all dependencies that this decorator has,
and all elements it decorates are a dependency and its hard to see the real number of
dependencies it has. Because of this, we have to suppress violations on collections
completely.");
}
public void Analyze_WithInvalidConfiguration_ReturnsResultsWithExpectedViolationInformation()
{
// Arrange
var expectedImplementationTypeInformation = new DebuggerViewItem(
name: "ImplementationType",
description: typeof(PluginWith8Dependencies).Name,
value: typeof(PluginWith8Dependencies));
var expectedDependenciesInformation = new DebuggerViewItem(
name: "Dependencies",
description: "8 dependencies.",
value: null);
Container container = CreateContainerWithRegistrations(typeof(PluginWith8Dependencies));
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container).Value as DebuggerViewItem[];
var result = results.Single();
var violationInformation = result.Value as DebuggerViewItem[];
// Assert
Assert_AreEqual(expectedImplementationTypeInformation, violationInformation[0]);
Assert_AreEqual(expectedDependenciesInformation, violationInformation[1], validateValue: false);
}
public void Analyze_OnConfigurationWithOneShortCircuitedRegistrationWithTwoPossibleSolutions_ReturnsThatWarning()
{
// Arrange
var container = new Container();
var registration = Lifestyle.Singleton.CreateRegistration <ImplementsBothInterfaces>(container);
container.AddRegistration(typeof(IService1), registration);
container.AddRegistration(typeof(IService2), registration);
container.Register <Controller <int> >();
container.Verify(VerificationOption.VerifyOnly);
// Act
var results = GetShortCircuitedResults(DebuggerGeneralWarningsContainerAnalyzer.Analyze(container));
// Assert
Assert.AreEqual(1, results.Length);
Assert.AreEqual(typeof(Controller <int>).ToFriendlyName(), results[0].Name);
Assert.AreEqual(
"Controller<Int32> might incorrectly depend on unregistered type ImplementsBothInterfaces " +
"(Transient) instead of IService1 (Singleton) or IService2 (Singleton).",
results[0].Description);
}
public void Analyze_ShortCircuitedRegistrationWithMultipleTypesInOneGroup_ReportsExpectedWarning()
{
// Arrange
var container = new Container();
var registration = Lifestyle.Singleton.CreateRegistration <ImplementsBothInterfaces>(container);
container.AddRegistration(typeof(IService1), registration);
container.AddRegistration(typeof(IService2), registration);
// Two types in same group
container.Register <Controller <int> >();
container.Register <Controller <float> >();
container.Verify(VerificationOption.VerifyOnly);
// Act
var results = GetShortCircuitedResults(DebuggerGeneralWarningsContainerAnalyzer.Analyze(container)).Single();
// Assert
Assert.AreEqual("Controller<T>", results.Name);
Assert.AreEqual("2 short circuited components.", results.Description);
AssertThat.IsInstanceOfType(typeof(DebuggerViewItem[]), results.Value);
Assert.AreEqual(2, ((DebuggerViewItem[])results.Value).Length);
}
public void Analyze_OnConfigurationWithOneShortCircuitedRegistration_ReturnsThatWarning()
{
// Arrange
var container = new Container();
container.Options.ResolveUnregisteredConcreteTypes = true;
container.Register <IUnitOfWork, MyUnitOfWork>(Lifestyle.Singleton);
// HomeController depends on MyUnitOfWork.
container.Register <HomeController>();
container.Verify(VerificationOption.VerifyOnly);
// Act
var results = GetShortCircuitedResults(DebuggerGeneralWarningsContainerAnalyzer.Analyze(container));
// Assert
Assert.AreEqual(1, results.Length);
Assert.AreEqual("HomeController", results[0].Name);
Assert.AreEqual(
"HomeController might incorrectly depend on unregistered type MyUnitOfWork " +
"(Transient) instead of IUnitOfWork (Singleton).",
results[0].Description);
}
public void Analyze_OnConfigurationWithMultipleViolations_ReturnsThoseTwoViolations()
{
// Arrange
Container container = CreateContainerWithRegistrations(
typeof(PluginWith8Dependencies),
typeof(AnotherPluginWith8Dependencies));
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container).Value as DebuggerViewItem[];
// Assert
Assert.AreEqual(2, results.Length);
var plugin1 = results.Single(r => r.Name == typeof(PluginWith8Dependencies).Name);
Assert.AreEqual(
typeof(PluginWith8Dependencies).Name + " has 8 dependencies which might indicate a SRP violation.",
plugin1.Description);
var plugin2 = results.Single(r => r.Name == typeof(AnotherPluginWith8Dependencies).Name);
Assert.AreEqual(
typeof(AnotherPluginWith8Dependencies).Name +
" has 8 dependencies which might indicate a SRP violation.",
plugin2.Description);
}
public void Analyze_OnEmptyConfiguration_ReturnsNull()
{
// Arrange
var container = new Container();
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container);
// Assert
Assert.AreEqual("No warnings detected.", results.Description);
}
public void Analyze_OnValidConfiguration_ReturnsNull()
{
// Arrange
Container container = CreateContainerWithRegistrations(typeof(PluginWith7Dependencies));
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container);
// Assert
Assert.AreEqual("No warnings detected.", results.Description,
"6 dependencies is still considered valid (to prevent too many false positives).");
}
public void Analyze_ShortCiruitedRegistrationWithSameLifestyle_ReportsExpectedWarning()
{
// Arrange
var container = new Container();
container.Register <ILogger, NullLogger>();
container.Register <ServiceDependingOn <NullLogger> >();
container.Verify(VerificationOption.VerifyOnly);
// Act
var results = GetShortCircuitedResults(DebuggerGeneralWarningsContainerAnalyzer.Analyze(container)).Single();
// Assert
Assert.AreEqual("ServiceDependingOn<NullLogger>", results.Name);
}
public void Analyze_ConfigurationWithViolation_ReturnsTheExpectedDebuggerViewItems()
{
// Arrange
var container = new Container();
container.Register <IFoo, FooBar>(Lifestyle.Singleton);
container.Register <IBar, FooBar>(Lifestyle.Singleton);
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container).Value as DebuggerViewItem[];
// Assert
Assert.AreEqual(typeof(IBar).Name, results[0].Name);
Assert.AreEqual(typeof(IFoo).Name, results[1].Name);
}
public void Analyze_OnConfigurationWithOneViolation_ReturnsThatViolation()
{
// Arrange
Container container = CreateContainerWithRegistrations(typeof(PluginWith8Dependencies));
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container).Value as DebuggerViewItem[];
// Assert
Assert.AreEqual(1, results.Length);
Assert.AreEqual(typeof(PluginWith8Dependencies).Name, results[0].Name);
Assert.AreEqual(typeof(PluginWith8Dependencies).Name +
" has 8 dependencies which might indicate a SRP violation.",
results[0].Description);
}
public void Analyze_ContainerWithOneMismatch_ReturnsItemWithExpectedDescription()
{
// Arrange
var container = new Container();
container.Register <IUserRepository, InMemoryUserRepository>();
// RealUserService depends on IUserRepository
container.RegisterSingle <RealUserService>();
container.Verify();
// Act
var item = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container);
// Assert
Assert.AreEqual("1 possible lifestyle mismatch for 1 service.", item.Description);
}
public void Analyze_ContainerWithOneMismatch_ReturnsItemWithExpectedName()
{
// Arrange
var container = new Container();
container.Register <IUserRepository, InMemoryUserRepository>();
// RealUserService depends on IUserRepository
container.RegisterSingle <RealUserService>();
container.Verify();
// Act
var item = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container);
// Assert
Assert.AreEqual("Potential Lifestyle Mismatches", item.Name);
}
private DebuggerViewItem[] GetAnalysisResults()
{
var registrations = this.container.GetCurrentRegistrations();
var rootRegistrations = this.container.GetRootRegistrations();
return(new DebuggerViewItem[]
{
DebuggerGeneralWarningsContainerAnalyzer.Analyze(this.container),
new DebuggerViewItem(
name: "Registrations",
description: "Count = " + registrations.Length,
value: registrations),
new DebuggerViewItem(
name: "Root Registrations",
description: "Count = " + rootRegistrations.Length,
value: this.GroupProducers(rootRegistrations))
});
}
public void Analyze_Uncached_ConfigurationWithViolation_ReturnsTheExpectedDebuggerViewItems()
{
// Arrange
var container = new Container();
container.AddRegistration(typeof(IFoo),
Lifestyle.Singleton.CreateRegistrationInternal <FooBar>(container, preventTornLifestyles: false));
container.AddRegistration(typeof(IBar),
new ThreadScopedLifestyle().CreateRegistrationInternal <FooBar>(container, preventTornLifestyles: false));
container.Verify(VerificationOption.VerifyOnly);
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container).Value as DebuggerViewItem[];
// Assert
Assert.AreEqual(typeof(IBar).Name, results[0].Name);
Assert.AreEqual(typeof(IFoo).Name, results[1].Name);
}
public void Analyze_CollectionWithTypeWithTooManyDependencies_WarnsAboutThatViolation()
{
// Arrange
Container container = CreateContainerWithRegistrations(Type.EmptyTypes);
container.RegisterCollection <IPlugin>(new[] { typeof(PluginWith8Dependencies) });
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container).Value as DebuggerViewItem[];
// Assert
Assert.IsNotNull(results, "A warning should have been detected.");
Assert.AreEqual(1, results.Length);
Assert.AreEqual(
typeof(PluginWith8Dependencies).Name + " has 8 dependencies which might indicate a SRP violation.",
results[0].Description);
}
public void Analyze_ContainerWithOneMismatch_ReturnsItemWithExpectedName()
{
// Arrange
var container = new Container();
container.Options.SuppressLifestyleMismatchVerification = true;
container.Register <IUserRepository, InMemoryUserRepository>();
// RealUserService depends on IUserRepository
container.Register <RealUserService>(Lifestyle.Singleton);
container.Verify(VerificationOption.VerifyOnly);
// Act
var item = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container);
// Assert
Assert.AreEqual("Lifestyle Mismatches", item.Name);
}
public void Analyze_ConfigurationWithCollectionADecoratorsWithTooManyDependencies_WarnsAboutThatDecorator()
{
// Arrange
Container container = CreateContainerWithRegistrations(Type.EmptyTypes);
// This decorator has too many dependencies
container.RegisterDecorator(typeof(IPlugin), typeof(PluginDecoratorWith8Dependencies));
// Non of these types have too many dependencies.
container.RegisterCollection <IPlugin>(new[] { typeof(PluginImpl), typeof(SomePluginImpl) });
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container);
// Assert
// We expect two violations here, since the decorator is wrapping two different registrations.
Assert.AreEqual("2 possible single responsibility violations.", results.Description);
}
public void Analyze_ConfigurationWithTwoViolationsOnSingleService_ReturnsOneViewItemForBothViolations()
{
// Arrange
Container container = CreateContainerWithRegistration <IPlugin, PluginWith8Dependencies>();
container.RegisterDecorator(typeof(IPlugin), typeof(PluginDecoratorWith8Dependencies));
container.Verify();
var ip = container.GetRegistration(typeof(IPlugin));
// Act
var items = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container).Value as DebuggerViewItem[];
// Assert
Assert.AreEqual(1, items.Length);
Assert.AreEqual(typeof(IPlugin).Name, items[0].Name);
Assert.AreEqual("2 possible violations.", items[0].Description);
}
public void Analyze_OpenGenericRegistrationWithValidAmountOfDependencies_ReturnsNull()
{
// Arrange
Container container = CreateContainerWithRegistrations();
// Consumer class contains a IGenericPlugin<IDisposable> dependency
container.Register <Consumer <IGenericPlugin <IDisposable> > >();
// Register open generic type with 6 dependencies.
container.Register(typeof(IGenericPlugin <>), typeof(GenericPluginWith6Dependencies <>));
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container);
// Assert
Assert.AreEqual("No warnings detected.", results.Description,
"The registration is considered to be valid, since both the type and decorator do not " +
"exceed the maximum number of dependencies. Message: {0}",
results == null ? null : results.Items().FirstOrDefault());
}
public void Analyze_ConfigurationWithTwoViolationsOnSingleService_ReturnsOneViewItemThatWrapsSecondViolation()
{
// Arrange
Container container = CreateContainerWithRegistration <IPlugin, PluginWith8Dependencies>();
container.RegisterDecorator(typeof(IPlugin), typeof(PluginDecoratorWith8Dependencies));
container.Verify();
// Act
var results = DebuggerGeneralWarningsContainerAnalyzer.Analyze(container).Value as DebuggerViewItem[];
var items = results.Single().Value as DebuggerViewItem[];
var item = items.Single(i => i.Description.Contains(typeof(PluginDecoratorWith8Dependencies).Name));
// Assert
Assert.AreEqual("IPlugin", item.Name);
Assert.AreEqual(typeof(PluginDecoratorWith8Dependencies).Name +
" has 8 dependencies which might indicate a SRP violation.",
item.Description);
}