public void ReturnsUnsuccessfulIfACommandHasTooManyParameters() { var builder = new CommandTreeBuilder(); builder.RegisterModule <TooManyCommandParameters>(); var tree = builder.Build(); var result = tree.CreateApplicationCommands(out _); ResultAssert.Unsuccessful(result); }
public void ReturnsSuccessForValidTree() { var builder = new CommandTreeBuilder(); builder.RegisterModule <ValidCommandGroup>(); var tree = builder.Build(); var result = tree.CreateApplicationCommands(out _); ResultAssert.Successful(result); }
public void ReturnsUnsuccessfulIfGroupsAreTooDeeplyNested() { var builder = new CommandTreeBuilder(); builder.RegisterModule <TooDeeplyNested>(); var tree = builder.Build(); var result = tree.CreateApplicationCommands(out _); ResultAssert.Unsuccessful(result); }
public void ReturnsUnsuccessfulIfThereAreOverloadsInAGroup() { var builder = new CommandTreeBuilder(); builder.RegisterModule <OverloadsAreNotSupportedInGroups>(); var tree = builder.Build(); var result = tree.CreateApplicationCommands(out _); ResultAssert.Unsuccessful(result); }
public void ReturnsSuccessfulIfAnEnumHasTooManyChoices() { var builder = new CommandTreeBuilder(); builder.RegisterModule <TooManyChoiceValues>(); var tree = builder.Build(); var result = tree.CreateApplicationCommands(out _); ResultAssert.Successful(result); }
public void WillChallengeTheUserUsingTheGivenProviderAndReturnUrl() { // Arrange EnableAllAuthenticators(Get <AuthenticationService>()); var controller = GetController <AuthenticationController>(); // Act var result = controller.Authenticate("/theReturnUrl", "MicrosoftAccount"); // Assert ResultAssert.IsChallengeResult(result, "MicrosoftAccount", "/users/account/authenticate/return?ReturnUrl=%2FtheReturnUrl"); }
public void ReturnsUnsuccessfulIfACommandContainsASwitchParameter() { var builder = new CommandTreeBuilder(); builder.RegisterModule <SwitchesAreNotSupported>(); var tree = builder.Build(); var result = tree.CreateApplicationCommands(out _); ResultAssert.Unsuccessful(result); }
public async Task GivenValidExternalAuth_ItLinksCredentialSendsEmailAndLogsIn() { // Arrange var authUser = new AuthenticatedUser( new User("theUsername") { EmailAddress = "*****@*****.**" }, new Credential { Type = "Foo" }); var externalCred = new CredentialBuilder().CreateExternalCredential("MicrosoftAccount", "blorg", "Bloog"); var authResult = new PasswordAuthenticationResult(PasswordAuthenticationResult.AuthenticationResult.Success, authUser); GetMock <AuthenticationService>() .Setup(x => x.Authenticate(authUser.User.Username, "thePassword")) .CompletesWith(authResult); GetMock <AuthenticationService>() .Setup(x => x.AddCredential(authUser.User, externalCred)) .Completes() .Verifiable(); GetMock <IMessageService>() .Setup(x => x.SendCredentialAddedNotice(authUser.User, externalCred)) .Verifiable(); var controller = GetController <AuthenticationController>(); GetMock <AuthenticationService>() .Setup(x => x.CreateSessionAsync(controller.OwinContext, It.IsAny <AuthenticatedUser>())) .Returns(Task.FromResult(0)) .Verifiable(); GetMock <AuthenticationService>() .Setup(x => x.ReadExternalLoginCredential(controller.OwinContext)) .CompletesWith(new AuthenticateExternalLoginResult { ExternalIdentity = new ClaimsIdentity(), Credential = externalCred }); // Act var result = await controller.SignIn( new LogOnViewModel( new SignInViewModel( authUser.User.Username, "thePassword")), "theReturnUrl", linkingAccount : true); // Assert ResultAssert.IsSafeRedirectTo(result, "theReturnUrl"); GetMock <AuthenticationService>().VerifyAll(); GetMock <IMessageService>().VerifyAll(); }
public async Task ReturnsIsDisabledWhenFeatureFlagIsDisabled() { FeatureFlagService .Setup(x => x.IsSearchSideBySideEnabled(It.IsAny <User>())) .Returns(false); var result = await Target.SearchSideBySide(SearchTerm); var model = ResultAssert.IsView <SearchSideBySideViewModel>(result); Assert.True(model.IsDisabled); }
public void ReturnsUnsuccessfulIfAParameterDescriptionIsTooLong() { var builder = new CommandTreeBuilder(); builder.RegisterModule <TooLongParameterDescription>(); var tree = builder.Build(); var result = tree.CreateApplicationCommands(); ResultAssert.Unsuccessful(result); }
public void ReturnsUnsuccessfulIfThereAreTooManyRootLevelCommands() { var builder = new CommandTreeBuilder(); builder.RegisterModule <TooManyCommands>(); var tree = builder.Build(); var result = tree.CreateApplicationCommands(out _); ResultAssert.Unsuccessful(result); }
public async Task ReturnsViewResult() { SearchSideBySideService .Setup(x => x.SearchAsync(It.IsAny <string>(), It.IsAny <User>())) .ReturnsAsync(() => ViewModel); var result = await Target.SearchSideBySide(SearchTerm); var model = ResultAssert.IsView <SearchSideBySideViewModel>(result); Assert.Same(ViewModel, model); }
public async Task Basic() { Logger logger = new Logger(); TestWorkspace workspace = new TestWorkspace(logger.CreateScope("main", LogLevel.Debug)); PipelineResult <Wrapper <int> > result = await PipelineGenerator.CreateBuilder().UseSampleCommandInvoker(new InitCommand().Build(), new string[] { "init" }, workspace: workspace, after: context => Task.FromResult <Wrapper <int> >(0)); logger.AssertInvoked(nameof(IWorkspace.Initialize)); ResultAssert.OkWithZero(result); }
public void ReturnsUnsuccessfulIfMultipleNamedGroupsWithTheSameNameHaveADefaultPermissionAttribute() { var builder = new CommandTreeBuilder(); builder.RegisterModule <AtMostOneDefaultPermissionAttributeAllowed.Named.GroupOne>(); builder.RegisterModule <AtMostOneDefaultPermissionAttributeAllowed.Named.GroupTwo>(); var tree = builder.Build(); var result = tree.CreateApplicationCommands(); ResultAssert.Unsuccessful(result); }
public void WillShowTheViewWithErrorsIfTheModelStateIsInvalid() { var controller = new TestableAuthenticationController(); controller.ModelState.AddModelError(String.Empty, "aFakeError"); var result = controller.LogOn(null, null); ResultAssert.IsView(result, viewData: new { ReturnUrl = (string)null }); }
public void WillRedirectToTheReturnUrl() { var controller = new TestableAuthenticationController(); controller.MockUsers .Setup(x => x.FindByUsernameOrEmailAddressAndPassword(It.IsAny <string>(), It.IsAny <string>())) .Returns(new User("theUsername", null)); var result = controller.LogOff("theReturnUrl") as RedirectResult; ResultAssert.IsRedirectTo(result, "aSafeRedirectUrl"); }
public async Task WillShowTheViewWithErrorsIfTheModelStateIsInvalid() { var controller = GetController <AuthenticationController>(); controller.ModelState.AddModelError(String.Empty, "aFakeError"); var result = await controller.Register(new LogOnViewModel(), null, linkingAccount : false); ResultAssert.IsView(result, viewName: RegisterViewName, viewData: new { ReturnUrl = (string)null }); }
public async Task PerformsRequestCorrectly() { var api = CreateAPI ( b => b .Expect(HttpMethod.Get, $"{Constants.BaseURL}users/@me") .Respond("application/json", SampleRepository.Samples[typeof(IUser)]) ); var result = await api.GetCurrentUserAsync(); ResultAssert.Successful(result); }
public async Task ReturnsViewWithModel(bool hasLastUpdated) { // Arrange SetupGetModel(hasLastUpdated); // Act var result = await GetController <FeaturesController>().Index(); // Assert var model = ResultAssert.IsView <FeatureFlagsViewModel>(result); AssertFlags(Flags, model, hasLastUpdated, RefreshInterval, ContentId); }
public async Task PerformsRequestCorrectly() { var api = CreateAPI ( b => b .Expect(HttpMethod.Get, $"{Constants.BaseURL}users/@me/connections") .Respond("application/json", "[]") ); var result = await api.GetUserConnectionsAsync(); ResultAssert.Successful(result); }
public async Task Basic() { PipelineResult <Wrapper <int> > result = await PipelineGenerator.CreateBuilder().UseSampleCommandInvoker( new DebugCommand().Build(), new string[] { "debug" }, after: context => { Assert.IsFalse(string.IsNullOrEmpty(context.Services.GetService <IConsole>().Out.ToString())); return(Task.CompletedTask); }); ResultAssert.OkWithZero(result); }
public void NamedStatement() { Pattern identifier = Check( (c) => c.IsLetter() || c == '_', (c) => c.IsLetterOrDigit() || c == '_', (c) => c.IsLetterOrDigit()); ResultAssert.Captures("Name", identifier.Consume("Name")); Pattern statement = "statement" & Many(Separator) & identifier.Capture(out Capture capture); ResultAssert.Captures("statement Name", statement.Consume("statement Name")); CaptureAssert.Captures("Name", capture); }
public void Consume_String_FromSource() { Pattern hello = "Hello"; Pattern space = ' '; Pattern world = "World"; Source source = new Source("Hello World"); ResultAssert.Captures("Hello", hello.Consume(ref source)); ResultAssert.Captures(" ", space.Consume(ref source)); ResultAssert.Captures("World", world.Consume(ref source)); source = new Source("Hello World"); ResultAssert.Captures("Hello World", (hello & space & world).Consume(ref source)); }
public async Task PerformsRequestCorrectly() { var guildId = new Snowflake(0); var api = CreateAPI ( b => b .Expect(HttpMethod.Get, $"{Constants.BaseURL}guilds/{guildId}/templates") .Respond("application/json", "[ ]") ); var result = await api.GetGuildTemplatesAsync(guildId); ResultAssert.Successful(result); }
public void WillChallengeTheUserUsingTheGivenProviderAndReturnUrl() { // Arrange const string returnUrl = "/theReturnUrl"; EnableAllAuthenticators(Get <AuthenticationService>()); var controller = GetController <AuthenticationController>(); // Act var result = controller.ChallengeAuthentication(returnUrl, "MicrosoftAccount"); // Assert ResultAssert.IsChallengeResult(result, "MicrosoftAccount", "/users/account/authenticate/return?ReturnUrl=" + HttpUtility.UrlEncode(returnUrl)); }
public async Task PerformsRequestCorrectly() { var api = CreateAPI ( b => b .Expect(HttpMethod.Get, $"{Constants.BaseURL}oauth2/@me") .WithNoContent() .Respond("Authorization/json", SampleRepository.Samples[typeof(IAuthorizationInformation)]) ); var result = await api.GetCurrentAuthorizationInformationAsync(); ResultAssert.Successful(result); }
public async Task GivenUserAlreadyAuthenticated_ItRedirectsToReturnUrl() { // Arrange var controller = GetController <AuthenticationController>(); controller.SetCurrentUser(Fakes.User); // Act var result = await controller.SignIn(new LogOnViewModel(), "/foo/bar/baz", linkingAccount : false); // Assert ResultAssert.IsSafeRedirectTo(result, "/foo/bar/baz"); Assert.Equal(Strings.AlreadyLoggedIn, controller.TempData["Message"]); }
public void GivenUserAlreadyAuthenticated_ItRedirectsToReturnUrl() { // Arrange var controller = GetController <AuthenticationController>(); controller.SetCurrentUser(Fakes.User); // Act var result = controller.LogOn("/foo/bar/baz"); // Assert ResultAssert.IsSafeRedirectTo(result, "/foo/bar/baz"); Assert.Equal(Strings.AlreadyLoggedIn, controller.TempData["Message"]); }
public async Task PerformsRequestCorrectly() { var templateCode = "aaa"; var api = CreateAPI ( b => b .Expect(HttpMethod.Get, $"{Constants.BaseURL}guilds/templates/{templateCode}") .Respond("application/json", SampleRepository.Samples[typeof(ITemplate)]) ); var result = await api.GetTemplateAsync(templateCode); ResultAssert.Successful(result); }
public async Task PerformsRequestCorrectly() { var api = CreateAPI ( b => b .Expect(HttpMethod.Get, $"{Constants.BaseURL}gateway") .WithNoContent() .Respond("application/json", SampleRepository.Samples[typeof(IGatewayEndpoint)]) ); var result = await api.GetGatewayAsync(); ResultAssert.Successful(result); }