public void BuilderTest_FeatureWithStrategiesSameOrder_ValidateThrows()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context => context.AddFeature<FeatureWithSameOrderStrategy>());
Assert.Throws<ConfigurationErrorsException>(() => container.ValidateConfiguration());
}
public void ConfigureFeatureSwitch(IAppBuilder app)
{
var builder = new FeatureSetBuilder(new StructureMapDependencyContainer());
builder.Build();
app.MapFeatureSwitch(); //.WithRoles("Administrators");
}
public void BuilderTest_2ndLevelInheritance_NonAddedFeatureNotFound()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context => context.AddFeature<MySample2ndLevelFeature>());
Assert.Null(container.GetFeature<MySample1stLevelFeature>(false));
}
public void BuilderTest_2ndLevelInheritance_NonAddedFeatureNotFound()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context => context.AddFeature <MySample2ndLevelFeature>());
Assert.Null(container.GetFeature <MySample1stLevelFeature>(false));
}
public void BuilderTest_FeatureWithReadOnlyStrategy_FailedEnable()
{
var builder = new FeatureSetBuilder();
builder.Build(ctx => ctx.AddFeature<MySampleFeature>());
Assert.Throws<InvalidOperationException>(() => FeatureContext.Enable<MySampleFeature>());
}
public void ConfigureContainer(ServiceConfigurationContext context)
{
var builder = new FeatureSetBuilder(new StructureMapDependencyContainer(context.Container));
builder.Build(ctx => { ctx.AutoDiscoverFeatures = true; })
.ValidateConfiguration();
}
public void BuilderTest_FeatureWithStrategiesSameOrder_ValidateThrows()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context => context.AddFeature <FeatureWithSameOrderStrategy>());
Assert.Throws <ConfigurationErrorsException>(() => container.ValidateConfiguration());
}
public void BuilderTest_BuildContextWithDiscovery_DiscoveredFeatureFound()
{
var builder = new FeatureSetBuilder();
var container = builder.Build();
Assert.NotNull(container.GetFeature<MySampleDiscoveredFeature>());
Assert.True(container.IsEnabled<MySampleDiscoveredFeature>());
}
public void TestQueryStringStrategy_Success(Type feature, bool expectedState)
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context => context.AddFeature(feature));
Assert.True(container.IsEnabled(feature) == expectedState);
}
public void TestHttpSession_Success()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context => context.AddFeature <FeatureWithSessionStorage>());
Assert.False(container.IsEnabled <FeatureWithSessionStorage>());
}
public void BuilderTest_FeatureWithReadOnlyStrategy_FailedEnable()
{
var builder = new FeatureSetBuilder();
builder.Build(ctx => ctx.AddFeature <MySampleFeature>());
Assert.Throws <InvalidOperationException>(() => FeatureContext.Enable <MySampleFeature>());
}
public void BuilderTest_BuildContextWithDiscovery_DiscoveredFeatureFound()
{
var builder = new FeatureSetBuilder();
var container = builder.Build();
Assert.NotNull(container.GetFeature <MySampleDiscoveredFeature>());
Assert.True(container.IsEnabled <MySampleDiscoveredFeature>());
}
public void TestHttpSession_Success()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context => context.AddFeature<FeatureWithSessionStorage>());
Assert.False(container.IsEnabled<FeatureWithSessionStorage>());
}
public void TestQueryStringStrategy_Success(Type feature, bool expectedState)
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context => context.AddFeature(feature));
Assert.True(container.IsEnabled(feature) == expectedState);
}
public void ConfigureFeatureSwitch(IAppBuilder app)
{
var builder = new FeatureSetBuilder(new StructureMapDependencyContainer());
builder.Build();
app.MapFeatureSwitch(); //.WithRoles("Administrators");
}
public void BuilderTest_OneFeatureOneStrategy_Success()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeature>();
ctx.ForStrategy<AppSettings>().Use<AlwaysTrueStrategyImpl>();
});
}
public void BuilderTest_NoDependencyContainer_UsesDefaultImplementations()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx => ctx.AddFeature<MySampleFeature>());
var isEnabled = container.IsEnabled<MySampleFeature>();
Assert.True(isEnabled);
}
public void BuilderTest_NoDependencyContainerDisabledFeature_UsesDefaultImplementations()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx => ctx.AddFeature <MySampleDisabledFeature>());
var isEnabled = container.IsEnabled <MySampleDisabledFeature>();
Assert.False(isEnabled);
}
public void BuilderTest_NoDependencyContainerFeatureWithNoKey_UsesDefaultImplementations()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx => ctx.AddFeature<MySampleNonExistingKeyFeature>());
var isEnabled = container.IsEnabled<MySampleNonExistingKeyFeature>();
Assert.False(isEnabled);
}
public void BuilderTest_OneFeatureOneStrategy_Success()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeature>();
ctx.ForStrategy <AppSettings>().Use <AlwaysTrueStrategyImpl>();
});
}
public void BuilderTest_CustomStrategyWithConstructorParameters_ThrowsExceptionWithSimpleContainer()
{
var builder = new FeatureSetBuilder();
Assert.Throws <MissingMethodException>(() => builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeatureWithConstructorParameterStrategy>();
ctx.ForStrategy <StrategyWithConstructorParameter>().Use <StrategyWithConstructorParameterReader>();
}));
}
public void BuilderTest_CustomStrategyWithConstructorParameters_ThrowsExceptionWithSimpleContainer()
{
var builder = new FeatureSetBuilder();
Assert.Throws<MissingMethodException>(() => builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeatureWithConstructorParameterStrategy>();
ctx.ForStrategy<StrategyWithConstructorParameter>().Use<StrategyWithConstructorParameterReader>();
}));
}
public void BuilderTest_MultipleStrategies_SwapedDefaultStrategy()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MyFeatureDisabledWithMultipleStrategies>();
ctx.ForStrategy<AlwaysFalse>().Use<AlwaysTrueStrategyImpl>();
});
Assert.True(container.IsStrategyEnabled(typeof(AlwaysTrueStrategyImpl)));
}
public void BuilderTest_MultipleStrategies_SwapedDefaultStrategy()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MyFeatureDisabledWithMultipleStrategies>();
ctx.ForStrategy <AlwaysFalse>().Use <AlwaysTrueStrategyImpl>();
});
Assert.True(container.IsStrategyEnabled(typeof(AlwaysTrueStrategyImpl)));
}
public void BuilderTest_MultipleStrategies_FeatureEnabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MyFeatureDisabledWithMultipleStrategies>();
ctx.ForStrategy <AppSettings>().Use <AlwaysFalseStrategyImpl>();
});
Assert.False(container.IsEnabled <MyFeatureDisabledWithMultipleStrategies>());
}
public void BuilderTest_MultipleStrategies_FeatureEnabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MyFeatureDisabledWithMultipleStrategies>();
ctx.ForStrategy<AppSettings>().Use<AlwaysFalseStrategyImpl>();
});
Assert.False(container.IsEnabled<MyFeatureDisabledWithMultipleStrategies>());
}
public void BuilderTest_AddFeatureWithoutStrategy_ReturnsNothing()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeatureWithoutStrategy>();
});
var enabledStrategies = container.GetEnabledStateStrategiesForFeature<MySampleFeatureWithoutStrategy>();
Assert.False(enabledStrategies.Any());
}
public void SingleFeature_SingleStrategy_TestForEnabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeature>();
ctx.ForStrategy <AppSettings>().Use <AlwaysTrueStrategyImpl>();
});
Assert.True(container.IsStrategyEnabled(typeof(AlwaysTrueStrategyImpl)));
}
public void BuilderTest_2ndLevelInheritance_AllFeaturesFound()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context =>
{
context.AddFeature<MySample2ndLevelFeature>();
context.AutoDiscoverFeatures = true;
});
Assert.NotNull(container.GetFeature<MySample2ndLevelFeature>());
Assert.NotNull(container.GetFeature<MySample1stLevelFeature>());
}
public void SingleFeature_SingleStrategy_TestForEnabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeature>();
ctx.ForStrategy<AppSettings>().Use<AlwaysTrueStrategyImpl>();
});
Assert.True(container.IsStrategyEnabled(typeof(AlwaysTrueStrategyImpl)));
}
public void BuilderTest_2ndLevelInheritance_AllFeaturesFound()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context =>
{
context.AddFeature <MySample2ndLevelFeature>();
context.AutoDiscoverFeatures = true;
});
Assert.NotNull(container.GetFeature <MySample2ndLevelFeature>());
Assert.NotNull(container.GetFeature <MySample1stLevelFeature>());
}
public void BuilderTest_AddFeatureWithoutStrategy_ReturnsNothing()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeatureWithoutStrategy>();
});
var enabledStrategies = container.GetEnabledStateStrategiesForFeature <MySampleFeatureWithoutStrategy>();
Assert.False(enabledStrategies.Any());
}
public void BuilderTest_AddFeature_ReturnsEnabledStrategies()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeature>();
});
var enabledStrategies = container.GetEnabledStateStrategiesForFeature<MySampleFeature>().ToList();
Assert.True(enabledStrategies.Any());
Assert.Equal(typeof(AppSettingsStrategyImpl), enabledStrategies.First().GetType());
}
public void BuilderTest_CustomStrategy_FeatureIsEnabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MyFancyStrategySampleFeature>();
ctx.ForStrategy<UnitTestsAlwaysTrueStrategy>().Use<AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled<MyFancyStrategySampleFeature>();
Assert.True(isEnabled, "MyFancyStrategySampleFeature is not enabled");
}
public void BuilderTest_SwapBuiltInStrategy_NoFailure()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeature>();
ctx.ForStrategy <AppSettings>().Use <AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled <MySampleFeature>();
Assert.True(isEnabled);
}
public void BuilderTest_OneFeatureOneStrategy_Success()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeature>();
ctx.ForStrategy <AppSettings>().Use <AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled <MySampleFeature>();
Assert.True(isEnabled, "MySampleFeature is not enabled");
}
public void BuilderTest_FeatureWithWritableStrategy_FeatureCanDisable()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MyWritableFeatureSingleStrategy>();
ctx.ForStrategy <WritableStrategy>().Use <WritableStrategyImpl>();
});
FeatureContext.Disable <MyWritableFeatureSingleStrategy>();
Assert.False(container.IsEnabled <MyWritableFeatureSingleStrategy>());
}
public void BuilderTest_OneFeatureOneStrategy_Success()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeature>();
ctx.ForStrategy<AppSettings>().Use<AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled<MySampleFeature>();
Assert.True(isEnabled, "MySampleFeature is not enabled");
}
public void BuilderTest_AddFeature_ReturnsEnabledStrategies()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeature>();
});
var enabledStrategies = container.GetEnabledStateStrategiesForFeature <MySampleFeature>().ToList();
Assert.True(enabledStrategies.Any());
Assert.Equal(typeof(AppSettingsStrategyImpl), enabledStrategies.First().GetType());
}
public void BuilderTest_RequestForNonRegisteredFeature_FeatureDisabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeature>();
ctx.ForStrategy <AppSettings>().Use <AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled <MySampleFeatureWithoutStrategy>();
Assert.False(isEnabled);
}
public void BuilderTest_CustomStrategy_FeatureIsEnabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MyFancyStrategySampleFeature>();
ctx.ForStrategy <UnitTestsAlwaysTrueStrategy>().Use <AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled <MyFancyStrategySampleFeature>();
Assert.True(isEnabled, "MyFancyStrategySampleFeature is not enabled");
}
public void BuilderTest_FeatureWithWritableStrategy_FeatureCanDisable()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MyWritableFeatureSingleStrategy>();
ctx.ForStrategy<WritableStrategy>().Use<WritableStrategyImpl>();
});
FeatureContext.Disable<MyWritableFeatureSingleStrategy>();
Assert.False(container.IsEnabled<MyWritableFeatureSingleStrategy>());
}
public void BuilderTest_RequestForNonRegisteredFeature_FeatureDisabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeature>();
ctx.ForStrategy<AppSettings>().Use<AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled<MySampleFeatureWithoutStrategy>();
Assert.False(isEnabled);
}
public void BuilderTest_FeatureWithWritableStrategy_FailToWrite_FeatureDoesNotChangeState()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MyWritableFeatureSingleStrategy>();
ctx.ForStrategy<WritableStrategy>().Use<WritableStrategyExceptionImpl>();
});
Assert.False(container.IsEnabled<MyWritableFeatureSingleStrategy>());
FeatureContext.Enable<MyWritableFeatureSingleStrategy>();
Assert.False(container.IsEnabled<MyWritableFeatureSingleStrategy>());
}
public void BuilderTest_AddSameStrategyMultipleTimes_NoFailures()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeature>();
ctx.ForStrategy <UnitTestsAlwaysTrueStrategy>().Use <AlwaysTrueStrategyImpl>();
ctx.ForStrategy <UnitTestsAlwaysTrueStrategy>().Use <AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled <MySampleFeature>();
Assert.True(isEnabled);
}
public void BuilderTest_FeatureWithWritableStrategy_FailToWrite_FeatureDoesNotChangeState()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MyWritableFeatureSingleStrategy>();
ctx.ForStrategy <WritableStrategy>().Use <WritableStrategyExceptionImpl>();
});
Assert.False(container.IsEnabled <MyWritableFeatureSingleStrategy>());
FeatureContext.Enable <MyWritableFeatureSingleStrategy>();
Assert.False(container.IsEnabled <MyWritableFeatureSingleStrategy>());
}
public void BuilderTest_AddSameStrategyMultipleTimes_NoFailures()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeature>();
ctx.ForStrategy<UnitTestsAlwaysTrueStrategy>().Use<AlwaysTrueStrategyImpl>();
ctx.ForStrategy<UnitTestsAlwaysTrueStrategy>().Use<AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled<MySampleFeature>();
Assert.True(isEnabled);
}
public void BuilderTest_SwapBuiltInStrategy_ContainerHasSwappedStrategy()
{
var builder = new FeatureSetBuilder();
builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeature>();
ctx.ForStrategy <AppSettings>().Use <AlwaysTrueStrategyImpl>();
});
var strategy = builder.GetStrategyImplementation <AppSettings>();
Assert.IsAssignableFrom(typeof(AlwaysTrueStrategyImpl), strategy);
}
public void BuilderTest_CustomStrategyWithConstructorParameters_ThrowsExceptionWithSimpleContainer()
{
var dependencyContainer = new StructureMapDependencyContainer();
dependencyContainer.Configure(expression => expression.For<ISampleInjectedInterface>().Use<SampleInjectedInterface>());
var builder = new FeatureSetBuilder(dependencyContainer);
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeatureWithConstructorParameterStrategy>();
ctx.ForStrategy<StrategyWithConstructorParameter>().Use<StrategyWithConstructorParameterReader>();
});
Assert.True(container.IsEnabled<MySampleFeatureWithConstructorParameterStrategy>());
Assert.NotNull(((StrategyWithConstructorParameterReader)builder.GetStrategyImplementation<StrategyWithConstructorParameter>()).Dependency);
}
public void BuilderTest_FeatureWithWritableStrategy_FeatureCanBeEnabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MyWritableFeatureSingleStrategy>();
ctx.ForStrategy <WritableStrategy>().Use <WritableStrategyImpl>();
});
Assert.False(container.IsEnabled <MyWritableFeatureSingleStrategy>());
Assert.True(container.GetFeature <MyWritableFeatureSingleStrategy>().CanModify, "Feature is not modifiable");
FeatureContext.Enable <MyWritableFeatureSingleStrategy>();
Assert.True(container.IsEnabled <MyWritableFeatureSingleStrategy>());
}
public void BuilderTest_FeatureWithWritableStrategy_FeatureCanBeEnabled()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MyWritableFeatureSingleStrategy>();
ctx.ForStrategy<WritableStrategy>().Use<WritableStrategyImpl>();
});
Assert.False(container.IsEnabled<MyWritableFeatureSingleStrategy>());
Assert.True(container.GetFeature<MyWritableFeatureSingleStrategy>().CanModify, "Feature is not modifiable");
FeatureContext.Enable<MyWritableFeatureSingleStrategy>();
Assert.True(container.IsEnabled<MyWritableFeatureSingleStrategy>());
}
public void BuilderTest_CustomStrategyWithConstructorParameters_ThrowsExceptionWithSimpleContainer()
{
var dependencyContainer = new StructureMapDependencyContainer();
dependencyContainer.Configure(expression => expression.For <ISampleInjectedInterface>().Use <SampleInjectedInterface>());
var builder = new FeatureSetBuilder(dependencyContainer);
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeatureWithConstructorParameterStrategy>();
ctx.ForStrategy <StrategyWithConstructorParameter>().Use <StrategyWithConstructorParameterReader>();
});
Assert.True(container.IsEnabled <MySampleFeatureWithConstructorParameterStrategy>());
Assert.NotNull(((StrategyWithConstructorParameterReader)builder.GetStrategyImplementation <StrategyWithConstructorParameter>()).Dependency);
}
public void BuilderTest_AddMoreFeature_Success()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeature>();
ctx.AddFeature <MySampleFeatureWithoutStrategy>();
ctx.AddFeature <MyFancyStrategySampleFeature>();
ctx.ForStrategy <AppSettings>().Use <AlwaysTrueStrategyImpl>();
ctx.ForStrategy <UnitTestsAlwaysTrueStrategy>().Use <AlwaysTrueStrategyImpl>();
});
Assert.True(container.IsEnabled <MySampleFeature>(), "MySampleFeature is not enabled");
Assert.False(container.IsEnabled <MySampleFeatureWithoutStrategy>(), "MySampleFeatureWithoutStrategy is not enabled");
Assert.True(container.IsEnabled <MyFancyStrategySampleFeature>(), "MyFancyStrategySampleFeature is not enabled");
}
public void BuilderTest_AddMoreFeature_Success()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeature>();
ctx.AddFeature<MySampleFeatureWithoutStrategy>();
ctx.AddFeature<MyFancyStrategySampleFeature>();
ctx.ForStrategy<AppSettings>().Use<AlwaysTrueStrategyImpl>();
ctx.ForStrategy<UnitTestsAlwaysTrueStrategy>().Use<AlwaysTrueStrategyImpl>();
});
Assert.True(container.IsEnabled<MySampleFeature>(), "MySampleFeature is not enabled");
Assert.False(container.IsEnabled<MySampleFeatureWithoutStrategy>(), "MySampleFeatureWithoutStrategy is not enabled");
Assert.True(container.IsEnabled<MyFancyStrategySampleFeature>(), "MyFancyStrategySampleFeature is not enabled");
}
public void ChangeState_AllWritableStrategiesSynced()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MySampleFeatureWithMultipleWritableStrategies>();
ctx.ForStrategy <WritableHashMapStrategyAttribute>().Use <WritableHashtableStrategy>();
ctx.ForStrategy <WritableHashMapStrategy2Attribute>().Use <WritableHashtable2Strategy>();
});
FeatureContext.Enable <MySampleFeatureWithMultipleWritableStrategies>();
Assert.True(FeatureContext.IsEnabled <MySampleFeatureWithMultipleWritableStrategies>());
// TODO:
//Assert.True(container.IsEnabled<MySampleFeatureWithMultipleWritableStrategies>(typeof(WritableHashtableStrategy)));
//Assert.True(container.IsEnabled<MySampleFeatureWithMultipleWritableStrategies>(typeof(WritableHashtable2Strategy)));
}
public void ChangeState_AllWritableStrategiesSynced()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeatureWithMultipleWritableStrategies>();
ctx.ForStrategy<WritableHashMapStrategyAttribute>().Use<WritableHashtableStrategy>();
ctx.ForStrategy<WritableHashMapStrategy2Attribute>().Use<WritableHashtable2Strategy>();
});
FeatureContext.Enable<MySampleFeatureWithMultipleWritableStrategies>();
Assert.True(FeatureContext.IsEnabled<MySampleFeatureWithMultipleWritableStrategies>());
// TODO:
//Assert.True(container.IsEnabled<MySampleFeatureWithMultipleWritableStrategies>(typeof(WritableHashtableStrategy)));
//Assert.True(container.IsEnabled<MySampleFeatureWithMultipleWritableStrategies>(typeof(WritableHashtable2Strategy)));
}
public void BuilderTest_MultipleFeaturesSameStrategy_NoCollisionsInState()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature <MyWritableFeatureSingleStrategy>();
ctx.AddFeature <MyWritableAnotherFeatureSingleStrategy>();
ctx.ForStrategy <WritableStrategy>().Use <WritableStrategyImpl>();
});
FeatureContext.Enable <MyWritableAnotherFeatureSingleStrategy>();
Assert.False(FeatureContext.IsEnabled <MyWritableFeatureSingleStrategy>());
Assert.True(FeatureContext.IsEnabled <MyWritableAnotherFeatureSingleStrategy>());
FeatureContext.Enable <MyWritableFeatureSingleStrategy>();
FeatureContext.Disable <MyWritableAnotherFeatureSingleStrategy>();
Assert.True(FeatureContext.IsEnabled <MyWritableFeatureSingleStrategy>());
Assert.False(FeatureContext.IsEnabled <MyWritableAnotherFeatureSingleStrategy>());
}
public void BuilderTest_MultipleFeaturesSameStrategy_NoCollisionsInState()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MyWritableFeatureSingleStrategy>();
ctx.AddFeature<MyWritableAnotherFeatureSingleStrategy>();
ctx.ForStrategy<WritableStrategy>().Use<WritableStrategyImpl>();
});
FeatureContext.Enable<MyWritableAnotherFeatureSingleStrategy>();
Assert.False(FeatureContext.IsEnabled<MyWritableFeatureSingleStrategy>());
Assert.True(FeatureContext.IsEnabled<MyWritableAnotherFeatureSingleStrategy>());
FeatureContext.Enable<MyWritableFeatureSingleStrategy>();
FeatureContext.Disable<MyWritableAnotherFeatureSingleStrategy>();
Assert.True(FeatureContext.IsEnabled<MyWritableFeatureSingleStrategy>());
Assert.False(FeatureContext.IsEnabled<MyWritableAnotherFeatureSingleStrategy>());
}
public void BuilderTest_SwapBuiltInStrategy_ContainerHasSwappedStrategy()
{
var builder = new FeatureSetBuilder();
builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeature>();
ctx.ForStrategy<AppSettings>().Use<AlwaysTrueStrategyImpl>();
});
var strategy = builder.GetStrategyImplementation<AppSettings>();
Assert.IsAssignableFrom(typeof(AlwaysTrueStrategyImpl), strategy);
}
public void BuilderTest_SwapBuiltInStrategy_NoFailure()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(ctx =>
{
ctx.AddFeature<MySampleFeature>();
ctx.ForStrategy<AppSettings>().Use<AlwaysTrueStrategyImpl>();
});
var isEnabled = container.IsEnabled<MySampleFeature>();
Assert.True(isEnabled);
}
