public void GetFeatureState_ReturnsDisabledFeatureState_ForDisabledParentFeature() { // Arrange var moduleId = new ModuleId("Test"); var parentFeatureId = new FeatureId(moduleId, "ParentFeature"); var parentFeature = new TestFeature(parentFeatureId); var childFeatureId = new FeatureId(moduleId, parentFeatureId, "ChildFeature"); var childFeature = new TestFeature(childFeatureId); var featureProvider = CreateFeatureProvider(parentFeature, childFeature); var configuration = CreateConfiguration(new Dictionary <string, string> { ["Features:Test.ParentFeature:Enabled"] = "false", ["Features:Test.ParentFeature.ChildFeature:Enabled"] = "true" }); var featureStateProvider = new FeatureStateProvider(featureProvider, configuration); // Act var state = featureStateProvider.GetFeatureState(childFeatureId); // Assert Assert.NotNull(state); Assert.Equal(childFeatureId, state.FeatureId); Assert.False(state.Enabled); Assert.NotNull(state.ConfigurationSection); }
public void CreateFeature_ReturnsFeature_ForDisabledFeatureService() { // Arrange var moduleId = new ModuleId("Test"); var featureId = new FeatureId(moduleId, "Test"); var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary <string, string> { ["Features:Test.Test:Enabled"] = "false" }) .Build(); var featureStateProvider = CreateFeatureStateProvider( new FeatureState(featureId, config.GetSection("Features:Test.Test"), false)); var workContext = new WorkContext(); var factory = new FeatureFactory <string>(featureStateProvider, workContext); // Act var feature = factory.CreateFeature( CreateServiceProvider((string)null), featureId); // Assert Assert.NotNull(feature); Assert.Null(feature.Service); Assert.False(feature.Enabled); Assert.True(feature.Missing); }
private bool ResolveEnabled(FeatureId featureId, IConfigurationSection section) { if (!featureId.ParentFeatureId.Equals(FeatureId.Empty)) { var parentState = GetFeatureState(featureId.ParentFeatureId); if (parentState == null || !parentState.Enabled) { return(false); } } if (bool.TryParse(section["Enabled"], out bool enabled)) { return(enabled); } if (bool.TryParse(section.Value, out enabled)) { return(enabled); } if (_rootScope != null) { return(_rootScope.ResolveEnabled(featureId, _rootScope._section)); } var feature = _featureProvider.GetFeature(featureId); if (feature != null) { return(feature.EnabledByDefault); } return(false); }
/// <summary> /// Initialises a new instance of <see cref="Feature{TService}"/>. /// </summary> /// <param name="featureId">The feature id.</param> /// <param name="enabled">Is the feature enabled?</param> /// <param name="missing">Is the feature missing?</param> /// <param name="service">[Optional] The service instance.</param> /// <param name="configuration">[Optional] The configuration section.</param> public Feature(FeatureId featureId, bool enabled, bool missing, TService service = default(TService), IConfigurationSection configuration = null) { FeatureId = featureId; Enabled = enabled; Missing = missing; Service = service; Configuration = configuration; }
/// <inheritdoc /> public FeatureState GetFeatureState(FeatureId featureId, TenantId tenantId) { if (_scopes.TryGetValue(tenantId, out FeatureStateProviderScope scope)) { return(scope.GetFeatureState(featureId)); } return(GetFeatureState(featureId)); }
/// <summary> /// Resolves the feature id value. /// </summary> /// <param name="parentModuleId"></param> /// <param name="parentFeatureId"></param> /// <param name="value"></param> /// <returns></returns> private static string ResolveValue(ModuleId parentModuleId, FeatureId parentFeatureId, string value) { if (parentFeatureId.Equals(FeatureId.Empty)) { return($"{parentModuleId.Value}.{value}"); } return($"{parentFeatureId.Value}.{value}"); }
private IFeatureStateProvider CreateFeatureStateProvider(FeatureId featureId, bool enabled) { var mock = new Mock <IFeatureStateProvider>(); mock.Setup(fsp => fsp.GetFeatureState(It.Is <FeatureId>(fid => fid.Equals(featureId)))) .Returns <FeatureId>(fid => new FeatureState(fid, null, enabled)); return(mock.Object); }
/// <inheritdoc /> public FeatureState GetFeatureState(FeatureId featureId) { if (featureId.Equals(FeatureId.Empty)) { throw new ArgumentException("The feature id must be provided and cannot be FeatureId.Empty", nameof(featureId)); } return(_store.GetOrAdd(featureId, GetFeatureStateCore)); }
/// <summary> /// Initialises a new instance of <see cref="FeatureState"/>. /// </summary> /// <param name="featureId">The feature id.</param> /// <param name="configurationSection">The configuration section.</param> /// <param name="enabled">Enabled state of the feature.</param> public FeatureState(FeatureId featureId, IConfigurationSection configurationSection, bool enabled) { if (!featureId.HasValue) { throw new ArgumentException("Feature id is required"); } FeatureId = featureId; Enabled = enabled; ConfigurationSection = configurationSection; }
public void CanExplicitlyCast_FromFeatureId_ToString() { // Arrange var moduleId = new ModuleId("module"); var id = new FeatureId(moduleId, "feature"); // Act string value = (string)id; // Assert Assert.Equal("module.feature", value); }
private IFeature CreateFeature(FeatureId featureId, Action <FeatureInitialisationContext> onInit) { var mock = new Mock <IFeature>(); mock.Setup(f => f.Id) .Returns(featureId); mock.Setup(f => f.Initialise(It.IsAny <FeatureInitialisationContext>())) .Callback <FeatureInitialisationContext>(onInit); return(mock.Object); }
public void WhenEquating_UsewCaseInsensitiveCompare() { // Arrange var moduleId = new ModuleId("module"); var id = new FeatureId(moduleId, "feature"); // Act bool equals = id.Equals(new FeatureId(moduleId, "FEATURE")); // Assert Assert.True(equals); }
/// <summary> /// Initialises a new instance of <see cref="FeatureBase"/>. /// </summary> /// <param name="id">The feature id.</param> /// <param name="name">[Optional] The feature name.</param> /// <param name="description">[Optional] The feature description.</param> /// <param name="enabledByDefault">[Optional] Default enabled state.</param> protected FeatureBase(FeatureId id, string name = null, string description = null, bool enabledByDefault = false) { if (id.Equals(FeatureId.Empty)) { throw new ArgumentException("The feature id value must be provided", nameof(id)); } Id = id; Name = name; Description = description; EnabledByDefault = enabledByDefault; }
public void WhenComparing_UsesCaseInsensitiveCompare() { // Arrange var moduleId = new ModuleId("module"); string value = "feature"; var id = new FeatureId(moduleId, value); // Act int compare = id.CompareTo("MODULE.FEATURE"); // Assert Assert.Equal(0, compare); }
/// <inheritdoc /> public int CompareTo(FeatureId other) { if (other.HasValue) { return(CompareTo(other.Value)); } if (HasValue) { return(1); } return(0); }
public void ParentMdoule_InheritedFromParentFeature() { // Arrange var moduleId = new ModuleId("module"); var otherModuleId = new ModuleId("otherModule"); var featureId = new FeatureId(moduleId, "feature"); var otherFeatureId = new FeatureId(otherModuleId, featureId, "feature"); // Act // Assert Assert.Equal(moduleId, otherFeatureId.ParentModuleId); Assert.Equal(otherModuleId, otherFeatureId.SourceModuleId); }
public void InitialisingFeatureId_CreatesNestedValue() { // Arrange var moduleId = new ModuleId("module"); // Act var featureAId = new FeatureId(moduleId, "featureA"); var featureBId = new FeatureId(moduleId, featureAId, "featureB"); // Assert Assert.Equal("module.featureA", featureAId.Value); Assert.Equal("module.featureA.featureB", featureBId.Value); Assert.Equal(featureAId, featureBId.ParentFeatureId); }
public void Constructor_ValidatesArguments() { // Arrange var moduleId = new ModuleId("Test"); var featureId = new FeatureId(moduleId, "Test"); var config = new ConfigurationBuilder().Build(); var featureStateProvider = CreateFeatureStateProvider( new FeatureState(featureId, config.GetSection("Features:Test.Test"), true)); // Act // Assert Assert.Throws <ArgumentNullException>(() => new FeatureFactory <string>(null /* featureStateProvider */, null /* workContext */)); Assert.Throws <ArgumentNullException>(() => new FeatureFactory <string>(featureStateProvider, null /* workContext */)); }
private FeatureState GetFeatureStateCore(FeatureId featureId) { var section = _section?.GetSection(featureId.Value); if (section == null) { if (_rootScope != null) { return(_rootScope.GetFeatureState(featureId)); } return(new FeatureState(featureId, null, false)); } return(new FeatureState(featureId, section, ResolveEnabled(featureId, section))); }
public void CanEquate_AgainstFeatureId() { // Arrange var moduleId = new ModuleId("module"); var id = new FeatureId(moduleId, "feature"); // Act bool equate0 = id.Equals(FeatureId.Empty); bool equate1 = id.Equals(new FeatureId(moduleId, "feature")); bool equate2 = id.Equals(new FeatureId(moduleId, "aaaa")); // Assert Assert.False(equate0); Assert.True(equate1); Assert.False(equate2); }
public void CanEquate_AgainstString() { // Arrange var moduleId = new ModuleId("module"); var id = new FeatureId(moduleId, "feature"); // Act bool equate0 = id.Equals((string)null); bool equate1 = id.Equals("module.feature"); bool equate2 = id.Equals("module.aaaa"); // Assert Assert.False(equate0); Assert.True(equate1); Assert.False(equate2); }
public void InitialisedInstance_HasValue_WhenProvidingModuleId() { // Arrange var moduleId = new ModuleId("module"); // Act var value = new FeatureId(moduleId, "feature"); // Asset Assert.True(value.HasValue); Assert.True(value.ParentModuleId.HasValue); Assert.True(value.ParentModuleId.Equals(moduleId)); Assert.True(value.SourceModuleId.HasValue); Assert.True(value.SourceModuleId.Equals(moduleId)); Assert.Equal("feature", value.LocalValue); Assert.Equal("module.feature", value.Value); }
public void CanCompare_AgainstFeatureId() { // Arrange var moduleId = new ModuleId("module"); var id = new FeatureId(moduleId, "feature"); // Act int compare0 = id.CompareTo(FeatureId.Empty); int compare1 = id.CompareTo(new FeatureId(moduleId, "feature")); int compare2 = id.CompareTo(new FeatureId(moduleId, "zzzz")); int compare3 = id.CompareTo(new FeatureId(moduleId, "aaaa")); // Assert Assert.True(1 == compare0); Assert.True(0 == compare1); Assert.True(-1 == compare2); Assert.True(1 == compare3); }
public void CanCompare_AgainstString() { // Arrange var moduleId = new ModuleId("module"); var id = new FeatureId(moduleId, "feature"); // Act int compare0 = id.CompareTo((string)null); int compare1 = id.CompareTo("module.feature"); int compare2 = id.CompareTo("module.zzzz"); int compare3 = id.CompareTo("module.aaaa"); // Assert Assert.True(1 == compare0); Assert.True(0 == compare1); Assert.True(-1 == compare2); Assert.True(1 == compare3); }
/// <inheritdoc /> public IFeature <TService> CreateFeature(IServiceProvider serviceProvider, FeatureId featureId) { Ensure.IsNotNull(serviceProvider, nameof(serviceProvider)); var state = (!_workContext.TenantId.Equals(TenantId.Empty) && !_workContext.TenantId.Equals(TenantId.Default)) ? _featureStateProvider.GetFeatureState(featureId, _workContext.TenantId) : _featureStateProvider.GetFeatureState(featureId); var service = serviceProvider.GetService <TService>(); bool missing = Equals(default(TService), service); return(new Feature <TService>( featureId, state.Enabled, missing, service, state.ConfigurationSection)); }
public void GetFeatureState_ReturnsFeatureState_ForUnknownFeature() { // Arrange var moduleId = new ModuleId("Test"); var featureId = new FeatureId(moduleId, "FeatureA"); var featureProvider = CreateFeatureProvider(); var configuration = CreateConfiguration(new Dictionary <string, string> { }); var featureStateProvider = new FeatureStateProvider(featureProvider, configuration); // Act var state = featureStateProvider.GetFeatureState(featureId); // Assert Assert.NotNull(state); Assert.Equal(featureId, state.FeatureId); Assert.False(state.Enabled); Assert.NotNull(state.ConfigurationSection); }
public void Configure_SkipsFeatureInitialisation_WhenFeatureDisabled() { // Arrange FeatureInitialisationContext capturedContext = null; var featureId = new FeatureId(new ModuleId("Test"), "Test"); var serviceProvider = Mock.Of <IServiceProvider>(); var filter = new FeatureInitialiserStartupFilter( serviceProvider, CreateFeatureProvider( CreateFeature(featureId, fic => capturedContext = fic)), CreateFeatureStateProvider(featureId, false)); Action <IApplicationBuilder> configure = _ => { }; // Act filter.Configure(configure); // Assert Assert.Null(capturedContext); }
public void GetFeatureState_ReturnsEnabledFeatureState_WhenConfigurationMissing_AndFeatureEnabledByDefault() { // Arrange var moduleId = new ModuleId("Test"); var featureId = new FeatureId(moduleId, "FeatureA"); var feature = new TestFeature(featureId, enabledByDefault: true); var featureProvider = CreateFeatureProvider(feature); var configuration = CreateConfiguration(new Dictionary <string, string> { }); var featureStateProvider = new FeatureStateProvider(featureProvider, configuration); // Act var state = featureStateProvider.GetFeatureState(featureId); // Assert Assert.NotNull(state); Assert.Equal(featureId, state.FeatureId); Assert.True(state.Enabled); Assert.NotNull(state.ConfigurationSection); }
/// <summary> /// Initialises a new instance of <see cref="FeatureId"/>. /// </summary> /// <param name="sourceModuleId">The source module id.</param> /// <param name="parentFeatureId">The parent feature id.</param> /// <param name="value">The feature id value.</param> public FeatureId(ModuleId sourceModuleId, FeatureId parentFeatureId, string value) { if (sourceModuleId.Equals(ModuleId.Empty)) { throw new ArgumentException("The source module id must be provided and cannot be ModuleId.Empty", nameof(sourceModuleId)); } if (parentFeatureId.Equals(Empty)) { throw new ArgumentException("The parent feature id must be provided and cannot be FeatureId.Empty", nameof(parentFeatureId)); } HasValue = true; ParentModuleId = parentFeatureId.ParentModuleId; SourceModuleId = sourceModuleId; _parentFeatureIdThunk = new Lazy <FeatureId>(() => parentFeatureId); LocalValue = Ensure.IsNotNullOrEmpty(value, nameof(value)); Value = ResolveValue(ParentModuleId, parentFeatureId, value); }
public void GetFeatureState_ReturnsDisabledFeatureState_ForNestedBooleanValue() { // Arrange var moduleId = new ModuleId("Test"); var featureId = new FeatureId(moduleId, "FeatureA"); var feature = new TestFeature(featureId); var featureProvider = CreateFeatureProvider(feature); var configuration = CreateConfiguration(new Dictionary <string, string> { ["Features:Test.FeatureA:Enabled"] = "false" }); var featureStateProvider = new FeatureStateProvider(featureProvider, configuration); // Act var state = featureStateProvider.GetFeatureState(featureId); // Assert Assert.NotNull(state); Assert.Equal(featureId, state.FeatureId); Assert.False(state.Enabled); Assert.NotNull(state.ConfigurationSection); }