public void BuilderTest_CallContextWithoutSetup_ThrowsException()
{
// reset context - this is not a good style, yes I know
// but test is for ensuring static type behavior
FeatureContext.SetInstance(null);
Assert.Throws <InvalidOperationException>(() => FeatureContext.IsEnabled <MySampleFeature>());
}
public void IsEnabledCallsAllToggles([Frozen] IFeatureToggleProvider toggleProvider, IFeature feature,
Fixture fixture, FeatureContext sut)
{
var featureToggles = fixture.CreateMany<Fake<IFeatureToggle>>().ToList();
foreach (Fake<IFeatureToggle> fake in featureToggles)
{
fake.CallsTo(ft => ft.IsEnabled(feature))
.Returns(null);
}
var finalTogle = A.Fake<Fake<IFeatureToggle>>();
finalTogle.CallsTo(ft => ft.IsEnabled(feature))
.Returns(true);
featureToggles.Add(finalTogle);
A.CallTo(() => toggleProvider.GetFeatureToggles())
.Returns(featureToggles.Select(f => f.FakedObject));
sut.IsEnabled(feature);
foreach (Fake<IFeatureToggle> fake in featureToggles)
{
fake.CallsTo(ft => ft.IsEnabled(feature))
.MustHaveHappened();
}
}
public void IsEnabledCallsAllToggles([Frozen] IFeatureTogglerSource togglerSource, IFeature feature,
Fixture fixture, FeatureContext sut)
{
var featureToggles = fixture.CreateMany <Fake <IFeatureToggler> >().ToList();
foreach (Fake <IFeatureToggler> fake in featureToggles)
{
fake.CallsTo(ft => ft.IsEnabled(sut, feature))
.Returns(null);
}
var finalTogle = A.Fake <Fake <IFeatureToggler> >();
finalTogle.CallsTo(ft => ft.IsEnabled(sut, feature))
.Returns(true);
featureToggles.Add(finalTogle);
A.CallTo(() => togglerSource.GetFeatureToggles())
.Returns(featureToggles.Select(f => f.FakedObject));
sut.IsEnabled(feature);
foreach (Fake <IFeatureToggler> fake in featureToggles)
{
fake.CallsTo(ft => ft.IsEnabled(sut, feature))
.MustHaveHappened();
}
}
public virtual ActionResult Login(LoginModel model, string returnUrl)
{
if (FeatureContext.IsEnabled <UseCaptcha>())
{
var recaptchaHelper = this.GetRecaptchaVerificationHelper();
if (String.IsNullOrEmpty(recaptchaHelper.Response))
{
ModelState.AddModelError("", "Captcha answer cannot be empty.");
return(View(MVC.Account.Views.Login, model));
}
var recaptchaResult = recaptchaHelper.VerifyRecaptchaResponse();
if (recaptchaResult != RecaptchaVerificationResult.Success)
{
ModelState.AddModelError("", "Incorrect captcha answer.");
}
}
if (ModelState.IsValid)
{
var result = signInManager.PasswordSignIn(model.UserName, model.Password, model.RememberMe, shouldLockout: false);
if (result == SignInStatus.Success)
{
return(RedirectToLocal(returnUrl));
}
ModelState.AddModelError("",
result == SignInStatus.LockedOut
? $"Account disabled until {signInManager.UserManager.FindByName(model.UserName).LockoutEndDateUtc} UTC."
: "Invalid username or password.");
}
// If we got this far, something failed, redisplay form
return(View(MVC.Account.Views.Login, model));
}
public void BuilderTest_FeatureWithStrategiesSameOrder_IsEnabledThrows()
{
var builder = new FeatureSetBuilder();
var container = builder.Build(context => context.AddFeature <FeatureWithSameOrderStrategy>());
Assert.Throws <ConfigurationErrorsException>(() => FeatureContext.IsEnabled <FeatureWithSameOrderStrategy>());
}
public void IsEnabledCallsGetsFeatureToggles([Frozen] IFeatureTogglerSource togglerSource, IFeature feature,
FeatureContext sut)
{
Ignore.Exception <FeatureStateNotFoundException, bool>(() => sut.IsEnabled(feature));
A.CallTo(() => togglerSource.GetFeatureToggles())
.MustHaveHappened();
}
public void IsEnabledCallsGetsFeatureToggles([Frozen] IFeatureToggleProvider toggleProvider, IFeature feature,
FeatureContext sut)
{
Ignore.Exception<FeatureStateNotFoundException, bool>(() => sut.IsEnabled(feature));
A.CallTo(() => toggleProvider.GetFeatureToggles())
.MustHaveHappened();
}
public override object GetData(ITabContext context)
{
var features = FeatureContext.GetFeatures();
var vm = features.Select(f => new
{
Enabled = FeatureContext.IsEnabled(f),
Name = f.Name + " (" + f.GetType().FullName + ")"
}).ToList();
return(vm);
}
protected void OnFeaturesRepeaterItemDataBound(object sender, RepeaterItemEventArgs e)
{
var stateControl = e.Item.FindControl("chkEnabled") as CheckBox;
var feature = e.Item.DataItem as BaseFeature;
if (stateControl != null && feature != null)
{
stateControl.Enabled = feature.CanModify;
stateControl.Checked = FeatureContext.IsEnabled(feature.GetType());
stateControl.InputAttributes["value"] = feature.GetType().FullName;
}
}
private static IResourceResult GenerateResponse()
{
var features = FeatureContext.GetFeatures();
var vm = features.Select(f => new
{
Enabled = FeatureContext.IsEnabled(f),
f.Name,
f.CanModify,
f.GetType().FullName
}).ToList();
return(new JsonResourceResult(vm));
}
public void IsEnabledCallsIsEnabledOnToggle([Frozen] IFeatureToggleProvider toggleProvider, IFeature feature,
IFeatureToggle featureToggle, bool expected, FeatureContext sut)
{
A.CallTo(() => featureToggle.IsEnabled(feature))
.Returns(expected);
A.CallTo(() => toggleProvider.GetFeatureToggles())
.Returns(new[] {featureToggle});
bool result = sut.IsEnabled(feature);
A.CallTo(() => featureToggle.IsEnabled(feature))
.MustHaveHappened();
Assert.Equal(expected, result);
}
public void IsEnabledCallsIsEnabledOnToggle([Frozen] IFeatureTogglerSource togglerSource, IFeature feature,
IFeatureToggler featureToggler, bool expected, FeatureContext sut)
{
A.CallTo(() => featureToggler.IsEnabled(sut, feature))
.Returns(expected);
A.CallTo(() => togglerSource.GetFeatureToggles())
.Returns(new[] { featureToggler });
bool result = sut.IsEnabled(feature);
A.CallTo(() => featureToggler.IsEnabled(sut, feature))
.MustHaveHappened();
Assert.Equal(expected, result);
}
public void IsEnabledUsesFirstToggleProviderResult([Frozen] IFeatureTogglerSource togglerSource,
IFeature feature, IFeatureToggler skippedToggler, IFeatureToggler enabledToggler, IFeatureToggler endToggler,
bool expected, FeatureContext sut)
{
A.CallTo(() => enabledToggler.IsEnabled(sut, feature))
.Returns(expected);
A.CallTo(() => togglerSource.GetFeatureToggles())
.Returns(new[] { skippedToggler, enabledToggler, endToggler });
bool result = sut.IsEnabled(feature);
Assert.Equal(expected, result);
A.CallTo(() => endToggler.IsEnabled(sut, feature))
.MustNotHaveHappened();
}
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 static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
if (FeatureContext.IsEnabled <ChatV2>())
{
routes.MapRoute("Chat", "chat", MVC.Chat.Index());
}
routes.MapRoute("ChatRoom", "chat/rooms/{room}", MVC.Chat.Index(null).AddRouteValue("room", UrlParameter.Optional));
routes.MapRoute("Home", "", MVC.PvP.Play().AddRouteValue("id", UrlParameter.Optional));
// Not using T4MVC on this route because there is no Index() in PvP
routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "pvp", action = "index", area = "", id = UrlParameter.Optional }
);
}
public virtual ActionResult SubmitCaptcha()
{
var myMembershipId = User.Identity.GetUserId();
var me = PlayerProcedures.GetPlayerFromMembership(myMembershipId);
if (FeatureContext.IsEnabled <UseCaptcha>() && DomainRegistry.Repository.FindSingle(new UserCaptchaIsExpired {
UserId = me.MembershipId
}))
{
var recaptchaHelper = this.GetRecaptchaVerificationHelper();
if (String.IsNullOrEmpty(recaptchaHelper.Response))
{
TempData["Error"] = "You must correctly answer the captcha in order to do this.";
return(RedirectToAction(MVC.PvP.Play()));
}
var recaptchaResult = recaptchaHelper.VerifyRecaptchaResponse();
if (recaptchaResult != RecaptchaVerificationResult.Success)
{
DomainRegistry.Repository.Execute(new UpdateCaptchaEntry
{
UserId = me.MembershipId,
AddFailAttempt = true,
AddPassAttempt = false
});
TempData["Error"] = "Captcha incorrect. Please try again.";
return(RedirectToAction(MVC.PvP.Play()));
}
else if (recaptchaResult == RecaptchaVerificationResult.Success)
{
DomainRegistry.Repository.Execute(new UpdateCaptchaEntry
{
UserId = me.MembershipId,
AddFailAttempt = false,
AddPassAttempt = true
});
}
}
TempData["Result"] = "Captcha successfully submitted! You will not be prompted to do this again for a while.";
return(RedirectToAction(MVC.PvP.Play()));
}
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 virtual ActionResult Register(RegisterModel model)
{
if (FeatureContext.IsEnabled <UseCaptcha>())
{
var recaptchaHelper = this.GetRecaptchaVerificationHelper();
if (String.IsNullOrEmpty(recaptchaHelper.Response))
{
ModelState.AddModelError("", "Captcha answer cannot be empty.");
return(View(MVC.Account.Views.Register, model));
}
var recaptchaResult = recaptchaHelper.VerifyRecaptchaResponse();
if (recaptchaResult != RecaptchaVerificationResult.Success)
{
ModelState.AddModelError("", "Incorrect captcha answer.");
}
}
if (ModelState.IsValid)
{
var user = new User {
UserName = model.UserName?.Trim(), Email = model.Email?.Trim(), CreateDate = DateTime.Now
};
var result = userManager.Create(user, model.Password);
if (result.Succeeded)
{
signInManager.SignIn(user, isPersistent: false, rememberBrowser: false);
return(RedirectToAction(MVC.PvP.Play()));
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return(View(MVC.Account.Views.Register, model));
}
public void IsEnabledThrowsWhenNoToggleProviderHasState(IFeature feature, FeatureContext sut)
{
var exception = Assert.Throws <FeatureStateNotFoundException>(() => sut.IsEnabled(feature));
Assert.Same(feature, exception.Feature);
}
public void IsEnabledUsesFirstToggleProviderResult([Frozen] IFeatureToggleProvider toggleProvider,
IFeature feature, IFeatureToggle skippedToggle, IFeatureToggle enabledToggle, IFeatureToggle endToggle,
bool expected, FeatureContext sut)
{
A.CallTo(() => enabledToggle.IsEnabled(feature))
.Returns(expected);
A.CallTo(() => toggleProvider.GetFeatureToggles())
.Returns(new[] {skippedToggle, enabledToggle, endToggle});
bool result = sut.IsEnabled(feature);
Assert.Equal(expected, result);
A.CallTo(() => endToggle.IsEnabled(feature))
.MustNotHaveHappened();
}
public virtual ActionResult Index(string room)
{
return(FeatureContext.IsEnabled <ChatV2>() ? ChatV2() : ChatV1(room));
}
public void IsEnabledThrowsWhenNoToggleProviderHasState(IFeature feature, FeatureContext sut)
{
var exception = Assert.Throws<FeatureStateNotFoundException>(() => sut.IsEnabled(feature));
Assert.Same(feature, exception.Feature);
}
public void IsEnabledThrowsWhenGivenNullFeature(FeatureContext sut)
{
Assert.Throws<ArgumentNullException>(() => sut.IsEnabled(feature: null));
}
public void IsEnabledThrowsWhenGivenNullFeature(FeatureContext sut)
{
Assert.Throws <ArgumentNullException>(() => sut.IsEnabled(feature: null));
}
private static IHtmlString Render(Type feature, string tagFormat, string[] paths)
{
return(!FeatureContext.IsEnabled(feature) ? System.Web.Optimization.Styles.RenderFormat(tagFormat, paths) : BundleRenderer.Render(paths, tagFormat));
}
public static IHtmlString RenderIfFormat <T>(string tagFromat, params string[] paths) where T : BaseFeature
{
return(FeatureContext.IsEnabled(typeof(T)) ? Render(typeof(T), tagFromat, paths) : new HtmlString(string.Empty));
}
