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;
}