public void Should_activate_all_upstream_deps_when_chain_deep() { var defaultsOrder = new List <Feature>(); var level1 = new Level1 { OnDefaults = f => defaultsOrder.Add(f) }; var level2 = new Level2 { OnDefaults = f => defaultsOrder.Add(f) }; var level3 = new Level3 { OnDefaults = f => defaultsOrder.Add(f) }; var settings = new SettingsHolder(); var featureSettings = new FeatureActivator(settings); //the orders matter here to expose a bug featureSettings.Add(level3); featureSettings.Add(level2); featureSettings.Add(level1); featureSettings.SetupFeatures(new FeatureConfigurationContext(null)); Assert.True(level1.IsActive, "Level1 wasn't activated"); Assert.True(level2.IsActive, "Level2 wasn't activated"); Assert.True(level3.IsActive, "Level3 wasn't activated"); Assert.IsInstanceOf <Level1>(defaultsOrder[0], "Upstream deps should be activated first"); Assert.IsInstanceOf <Level2>(defaultsOrder[1], "Upstream deps should be activated first"); Assert.IsInstanceOf <Level3>(defaultsOrder[2], "Upstream deps should be activated first"); }
public void Should_activate_upstream_dependencies_first() { var order = new List <Feature>(); var dependingFeature = new DependsOnOne_Feature { OnActivation = f => order.Add(f) }; var feature = new MyFeature1 { OnActivation = f => order.Add(f) }; var settings = new SettingsHolder(); var featureSettings = new FeatureActivator(settings); featureSettings.Add(dependingFeature); featureSettings.Add(feature); settings.EnableFeatureByDefault <MyFeature1>(); featureSettings.SetupFeatures(new FakeFeatureConfigurationContext()); Assert.True(dependingFeature.IsActive); Assert.IsInstanceOf <MyFeature1>(order.First(), "Upstream dependencies should be activated first"); }
public void Should_activate_named_dependency_first() { var order = new List<Feature>(); var dependingFeature = new DependsOnOneByName_Feature { OnActivation = f => order.Add(f) }; var feature = new MyFeature2 { OnActivation = f => order.Add(f) }; var settings = new SettingsHolder(); var featureSettings = new FeatureActivator(settings); featureSettings.Add(dependingFeature); featureSettings.Add(feature); settings.EnableFeatureByDefault<MyFeature2>(); featureSettings.SetupFeatures(null, null, null, null); Assert.True(dependingFeature.IsActive); Assert.IsInstanceOf<MyFeature2>(order.First(), "Upstream dependencies should be activated first"); }
public void Should_not_register_defaults_if_feature_is_not_activated() { var settings = new SettingsHolder(); var featureSettings = new FeatureActivator(settings); featureSettings.Add(new MyFeatureWithDefaultsNotActive()); featureSettings.Add(new MyFeatureWithDefaultsNotActiveDueToUnsatisfiedPrerequisite()); featureSettings.SetupFeatures(new FeatureConfigurationContext(null)); Assert.False(settings.HasSetting("Test1")); Assert.False(settings.HasSetting("Test2")); }
internal void Initialize() { WireUpConfigSectionOverrides(); featureActivator = new FeatureActivator(Settings); configurer.RegisterSingleton(featureActivator); ForAllTypes <Feature>(TypesToScan, t => featureActivator.Add(t.Construct <Feature>())); ForAllTypes <IWantToRunWhenConfigurationIsComplete>(TypesToScan, t => configurer.ConfigureComponent(t, DependencyLifecycle.InstancePerCall)); ForAllTypes <IWantToRunWhenBusStartsAndStops>(TypesToScan, t => configurer.ConfigureComponent(t, DependencyLifecycle.InstancePerCall)); ActivateAndInvoke <IWantToRunBeforeConfigurationIsFinalized>(TypesToScan, t => t.Run(this)); var featureStats = featureActivator.SetupFeatures(new FeatureConfigurationContext(this)); configurer.RegisterSingleton(featureStats); featureActivator.RegisterStartupTasks(configurer); localAddress = Settings.LocalAddress(); foreach (var o in Builder.BuildAll <IWantToRunWhenConfigurationIsComplete>()) { o.Run(this); } }
public void RegisterFeatureEnabledStatusInSettings(HostingComponent.Configuration hostingConfiguration) { featureActivator = new FeatureActivator(settings); foreach (var type in hostingConfiguration.AvailableTypes.Where(t => IsFeature(t))) { featureActivator.Add(type.Construct <Feature>()); } }
public void Should_check_prerequisites() { var featureWithTrueCondition = new MyFeatureWithSatisfiedPrerequisite(); var featureWithFalseCondition = new MyFeatureWithUnsatisfiedPrerequisite(); var featureSettings = new FeatureActivator(new SettingsHolder()); featureSettings.Add(featureWithTrueCondition); featureSettings.Add(featureWithFalseCondition); featureSettings.SetupFeatures(new FeatureConfigurationContext(null)); Assert.True(featureWithTrueCondition.IsActive); Assert.False(featureWithFalseCondition.IsActive); Assert.AreEqual("The description", featureSettings.Status.Single(s => s.Name == featureWithFalseCondition.Name).PrerequisiteStatus.Reasons.First()); }
public void RegisterFeatureEnabledStatusInSettings(List <Type> concreteTypes) { featureActivator = new FeatureActivator(settings); foreach (var type in concreteTypes.Where(t => IsFeature(t))) { featureActivator.Add(type.Construct <Feature>()); } }
FeatureActivator BuildFeatureActivator(IEnumerable <Type> concreteTypes) { var featureActivator = new FeatureActivator(settings); foreach (var type in concreteTypes.Where(t => IsFeature(t))) { featureActivator.Add(type.Construct <Feature>()); } return(featureActivator); }
public void Should_register_defaults_if_feature_is_activated() { var settings = new SettingsHolder(); var featureSettings = new FeatureActivator(settings); featureSettings.Add(new MyFeatureWithDefaults()); featureSettings.SetupFeatures(new FeatureConfigurationContext(null)); Assert.True(settings.HasSetting("Test1")); }
public void Should_only_activate_features_if_dependencies_are_met(FeatureCombinations setup) { var featureSettings = new FeatureActivator(new SettingsHolder()); var dependingFeature = setup.DependingFeature; featureSettings.Add(dependingFeature); Array.ForEach(setup.AvailableFeatures, featureSettings.Add); featureSettings.SetupFeatures(null, null, null, null); Assert.AreEqual(setup.ShouldBeActive, dependingFeature.IsActive); }
public void Should_activate_all_upstream_dependencies_first() { var order = new List<Feature>(); var dependingFeature = new DependsOnAtLeastOne_Feature { OnActivation = f => order.Add(f) }; var feature = new MyFeature1 { OnActivation = f => order.Add(f) }; var feature2 = new MyFeature2 { OnActivation = f => order.Add(f) }; var feature3 = new MyFeature3 { OnActivation = f => order.Add(f) }; var settings = new SettingsHolder(); var featureSettings = new FeatureActivator(settings); featureSettings.Add(dependingFeature); featureSettings.Add(feature); featureSettings.Add(feature2); featureSettings.Add(feature3); settings.EnableFeatureByDefault<MyFeature1>(); settings.EnableFeatureByDefault<MyFeature2>(); settings.EnableFeatureByDefault<MyFeature3>(); featureSettings.SetupFeatures(null, null, null, null); Assert.True(dependingFeature.IsActive); Assert.IsInstanceOf<MyFeature1>(order[0], "Upstream dependencies should be activated first"); Assert.IsInstanceOf<MyFeature2>(order[1], "Upstream dependencies should be activated first"); Assert.IsInstanceOf<MyFeature3>(order[2], "Upstream dependencies should be activated first"); }
public void Should_enable_features_in_defaults() { var defaultsOrder = new List <Feature>(); var activatedOrder = new List <Feature>(); var level1 = new Activate1 { OnActivation = f => activatedOrder.Add(f), OnDefaults = f => defaultsOrder.Add(f) }; var level2 = new Activate2 { OnActivation = f => activatedOrder.Add(f), OnDefaults = f => defaultsOrder.Add(f) }; var level3 = new Activate3 { OnActivation = f => activatedOrder.Add(f), OnDefaults = f => defaultsOrder.Add(f) }; var settings = new SettingsHolder(); var featureSettings = new FeatureActivator(settings); //the orders matter here to expose a bug featureSettings.Add(level3); featureSettings.Add(level2); featureSettings.Add(level1); featureSettings.SetupFeatures(new FeatureConfigurationContext(null)); Assert.True(level1.IsActive, "Activate1 wasn't activated"); Assert.True(level2.IsActive, "Activate2 wasn't activated"); Assert.True(level3.IsActive, "Activate3 wasn't activated"); Assert.IsInstanceOf <Activate1>(defaultsOrder[0], "Upstream deps should be activated first"); Assert.IsInstanceOf <Activate2>(defaultsOrder[1], "Upstream deps should be activated first"); Assert.IsInstanceOf <Activate3>(defaultsOrder[2], "Upstream deps should be activated first"); CollectionAssert.AreEqual(defaultsOrder, activatedOrder); }
public void Should_throw_exception_when_dependency_cycle_is_found() { var order = new List<Feature>(); var level1 = new CycleLevel1 { OnActivation = f => order.Add(f) }; var level2 = new CycleLevel2 { OnActivation = f => order.Add(f) }; var settings = new SettingsHolder(); var featureSettings = new FeatureActivator(settings); featureSettings.Add(level1); featureSettings.Add(level2); Assert.Throws<ArgumentException>(() => featureSettings.SetupFeatures(null, null, null, null)); }
public void Should_not_activate_feature_when_named_dependency_disabled() { var order = new List<Feature>(); var dependingFeature = new DependsOnOneByName_Feature { OnActivation = f => order.Add(f) }; var feature = new MyFeature2 { OnActivation = f => order.Add(f) }; var settings = new SettingsHolder(); var featureSettings = new FeatureActivator(settings); featureSettings.Add(dependingFeature); featureSettings.Add(feature); featureSettings.SetupFeatures(null, null, null, null); Assert.False(dependingFeature.IsActive); Assert.IsEmpty(order); }
public void Should_not_activate_features_with_unmet_dependencies() { var feature = new FeatureWithStartupTask(); var featureSettings = new FeatureActivator(new SettingsHolder()); featureSettings.Add(feature); var builder = new FakeBuilder(typeof(FeatureWithStartupTask.Runner)); featureSettings.SetupFeatures(new FeatureConfigurationContext(null)); featureSettings.StartFeatures(builder); featureSettings.StopFeatures(builder); Assert.True(FeatureWithStartupTask.Runner.Started); Assert.True(FeatureWithStartupTask.Runner.Stopped); }
FeatureActivator BuildFeatureActivator(IEnumerable<Type> concreteTypes) { var featureActivator = new FeatureActivator(settings); foreach (var type in concreteTypes.Where(IsFeature)) { featureActivator.Add(type.Construct<Feature>()); } return featureActivator; }