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