public virtual async Task LoginWithInValidUserNameAndPasswordUsingCodeMayNotWorksFine()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs {
UseRealServer = false
}))
{
TokenResponse token = await testEnvironment.Server.Login("InValidUser", "InvalidPassword", "TestResOwner");
Assert.IsTrue(token.IsError);
}
}
public virtual async Task LoginWithValidUserNameAndPasswordUsingCodeShouldWorksFine()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs {
UseRealServer = false
}))
{
Token token = await testEnvironment.Server.LoginWithCredentials("ValidUserName", "ValidPassword", "TestResOwner");
Assert.AreEqual("test", await(await testEnvironment.Server.BuildHttpClient(token).GetAsync("api/customers/get-custom-data?api-version=1.0")).Content.ReadAsAsync <string>()); // see TestUserService
}
}
public virtual async Task TestWebApiDefaultRouting()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpClient httpClient = testEnvironment.Server.BuildHttpClient(token);
(await httpClient.GetAsync("api/values")).EnsureSuccessStatusCode();
}
}
public async Task StaticFilesResponsesMustHaveSecurityHeaders()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
HttpResponseMessage getVirtualPathUrl = await testEnvironment.Server.BuildHttpClient()
.GetAsync("/Files/V1");
Assert.AreEqual(true, getVirtualPathUrl.Headers.Contains("X-Content-Type-Options"));
Assert.AreEqual(true, getVirtualPathUrl.Headers.Contains("X-Download-Options"));
}
}
public virtual void AllOnAppStartsMustBeCalledOnceAtStartup()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
foreach (IAppEvents appEvents in testEnvironment.GetObjects <IAppEvents>())
{
A.CallTo(() => appEvents.OnAppStartup())
.MustHaveHappenedOnceExactly();
}
}
}
public virtual async Task SimpleODataInCSharpClientTest()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.BuildTestODataClient(token: token);
Assert.AreEqual(3, await client.Simple().Sum(1, 2).ExecuteAsScalarAsync <int>());
}
}
public virtual async Task WebApiExceptionHandlerFilterAttributeMustReturnUnknownErrorReasonPhraseAndInternalServerErrorStatusCodeAndCorrelationIdInResponseWhenExceptionOtherThanAppExceptionIsThrown()
{
IEmailService emailService = A.Fake <IEmailService>();
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Throws(new InvalidOperationException("Test"));
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(emailService);
},
ActiveAppEnvironmentCustomizer = appEnv =>
{
appEnv.DebugMode = false;
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token, afterResponse: message =>
{
if (message.StatusCode == HttpStatusCode.InternalServerError)
{
Assert.AreEqual(BitMetadataBuilder.UnknownError, message.ReasonPhrase);
Assert.IsTrue(message.Headers.Any(h => h.Key == "Reason-Phrase" && h.Value.Any(v => v == BitMetadataBuilder.UnknownError)));
ILogger logger = TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <ILogger>().Last();
Guid correlationId = (Guid)logger.LogData.Single(logData => logData.Key == "X-CorrelationId").Value;
Assert.AreEqual(correlationId.ToString(), message.Headers.Single(h => h.Key == "X-CorrelationId").Value.Single());
}
});
try
{
await client.TestModels()
.SendEmail(to: "Someone", title: "Email title", message: "Email message")
.ExecuteAsync();
Assert.Fail();
}
catch (WebRequestException ex)
{
Assert.IsTrue(ex.Response.Contains(BitMetadataBuilder.UnknownError));
Assert.AreEqual(HttpStatusCode.InternalServerError, ex.Code);
}
}
}
public async Task DontRedirectToSsoIfLoggedIn()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpResponseMessage getIndexPageResponse = await testEnvironment.Server.BuildHttpClient(token)
.GetAsync("/");
Assert.AreNotEqual(HttpStatusCode.Redirect, getIndexPageResponse.StatusCode);
}
}
public async Task LoggedInUsersMustHaveAccessToODataWebApis()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpResponseMessage getMetadataResponse = await testEnvironment.Server.GetHttpClient(token)
.GetAsync("/odata/Bit/$metadata");
Assert.AreEqual(HttpStatusCode.OK, getMetadataResponse.StatusCode);
}
}
public async Task WebApiResponsesMustHaveSecurityHeaders()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpResponseMessage getMetadataResponse = await testEnvironment.Server.GetHttpClient(token)
.GetAsync("/odata/Bit/$metadata");
Assert.AreEqual(true, getMetadataResponse.Headers.Contains("X-Content-Type-Options"));
}
}
public virtual async Task MediaTypeFormattersShouldReturnMinimalStreamedODataJsonWhenNoContentTypeIsDeclaredInRequest()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpResponseMessage getTestModelsResponse = await testEnvironment.Server.GetHttpClient(token)
.GetAsync("/odata/Test/TestModels");
Assert.AreEqual("application/json; odata.metadata=minimal; odata.streaming=true; charset=utf-8", getTestModelsResponse.Content.Headers.ContentType.ToString());
}
}
public async Task TestComplexProjection()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpResponseMessage response = await testEnvironment.Server.BuildHttpClient(token)
.GetAsync("/odata/Test/ChildEntities?$top=1&$select=Id,Name&$expand=ParentEntity($select=Id,Name)");
response.EnsureSuccessStatusCode();
}
}
public async Task LogExceptionWhenEmailSendFailedAndTryForTheSecondTime()
{
IEmailService emailService = A.Fake <IEmailService>();
TaskCompletionSource <bool> emailSent = new TaskCompletionSource <bool>();
int tryCount = 0;
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Invokes(() =>
{
tryCount++;
if (tryCount == 2)
{
emailSent.SetResult(true);
return;
}
throw new InvalidOperationException();
});
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = manager =>
{
manager.RegisterInstance(emailService);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
ODataClient client = testEnvironment.Server.BuildODataClient(token: token);
string jobId = (await client.Controller <TestModelsController, TestModel>()
.Action(nameof(TestModelsController.SendEmailUsingBackgroundJobService))
.Set(new TestModelsController.EmailParameters {
to = "Someone", title = "Email title", message = "Email message"
})
.ExecuteAsScalarAsync <Guid>()).ToString();
Assert.AreEqual(true, await emailSent.Task);
ILogger logger = TestDependencyManager.CurrentTestDependencyManager
.Objects.OfType <ILogger>()
.Last();
A.CallTo(() => logger.LogException(A <Exception> .That.Matches(e => e is InvalidOperationException), A <string> .That.Matches(errMsg => errMsg.Contains(jobId))))
.MustHaveHappened(Repeated.Exactly.Once);
Assert.AreEqual(2, tryCount);
}
}
public virtual async Task LoginWithInValidUserNameAndPasswordUsingCodeMayNotWorksFine()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs {
UseRealServer = false
}))
{
TokenClient tokenClient = testEnvironment.Server.BuildTokenClient("TestResOwner", "secret");
TokenResponse tokenResponse = await tokenClient.RequestResourceOwnerPasswordAsync("InValidUser", "InvalidPassword", scope : "openid profile user_info");
Assert.IsTrue(tokenResponse.IsError);
}
}
public async Task MetadataMiddlewareResultMustBeJson()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
HttpResponseMessage getMetadataForV1 = await testEnvironment.Server.BuildHttpClient()
.GetAsync("Metadata/V1");
Assert.AreEqual("application/json", getMetadataForV1.Content.Headers.ContentType.MediaType);
Assert.AreEqual("utf-8", getMetadataForV1.Content.Headers.ContentType.CharSet);
}
}
public virtual async Task TestGettingSomeVariables()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs { UseRealServer = true }))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId: "TestResOwner");
using (RemoteWebDriver driver = testEnvironment.Server.GetWebDriver(new RemoteWebDriverOptions { Token = token }))
{
await driver.ExecuteTest("Bit.Tests.Implementations.Tests.UiAutomationTests.testGettingSomeVariables", 5, 5, "Hi", new DateTimeOffset(2016, 1, 1, 1, 1, 1, TimeSpan.Zero), new { firstNum = 5, secondNum = 5, message = "Hi", date = new DateTimeOffset(2016, 1, 1, 1, 1, 1, TimeSpan.Zero) });
}
}
}
public virtual async Task WebApiExceptionHandlerFilterAttributeMustReturnKnownErrorReasonPhraseAndNotFoundStatusCodeAndCorrelationIdInResponseWhenResourceNotFoundExceptionThrownsInWebApi()
{
IEmailService emailService = A.Fake <IEmailService>();
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Throws(new ResourceNotFoundException("Test"));
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(emailService);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token, afterResponse: message =>
{
if (message.StatusCode == HttpStatusCode.NotFound)
{
Assert.AreEqual(BitMetadataBuilder.KnownError, message.ReasonPhrase);
Assert.IsTrue(message.Headers.Any(h => h.Key == "Reason-Phrase" && h.Value.Any(v => v == BitMetadataBuilder.KnownError)));
ILogger logger = TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <ILogger>().Last();
Guid correlationId = (Guid)logger.LogData.Single(logData => logData.Key == "X-CorrelationId").Value;
Assert.AreEqual(correlationId.ToString(), message.Headers.Single(h => h.Key == "X-CorrelationId").Value.Single());
}
});
try
{
await client.Controller <TestModelsController, TestModel>()
.Action(nameof(TestModelsController.SendEmail))
.Set(new TestModelsController.EmailParameters {
to = "Someone", title = "Email title", message = "Email message"
})
.ExecuteAsync();
Assert.Fail();
}
catch (WebRequestException ex)
{
Assert.IsTrue(ex.Response.Contains("Test"));
Assert.AreEqual(HttpStatusCode.NotFound, ex.Code);
}
}
}
public async Task ExceptionHandlerMustNotSaveAnyThingToLogStoreBecauseOfSuccessfulRequests()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IScopeStatusManager scopeStatusManager = testEnvironment.GetObjects <IScopeStatusManager>()
.Single();
A.CallTo(() => scopeStatusManager.MarkAsSucceeded())
.MustHaveHappenedOnceExactly();
}
}
public virtual async Task WebApiShouldReturnSumOfTwoNumbersForRefitClient()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
ICustomersService customersService = testEnvironment.Server.BuildRefitClient <ICustomersService>(token: token);
int response = await customersService.Sum(1, 2, CancellationToken.None);
Assert.AreEqual(3, response);
}
}
public virtual async Task WebApiShouldReturnOk()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpClient client = testEnvironment.Server.BuildHttpClient(token: token);
HttpResponseMessage response = await client.GetAsync("api/customers/1/orders");
response.EnsureSuccessStatusCode();
}
}
public virtual async Task CustomActionMethodWithSingleDtoReturnValueTest()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
Token token = await testEnvironment.Server.LoginWithCredentials("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.BuildTestODataClient(token: token);
await client.TestModels()
.CustomActionMethodWithSingleDtoReturnValueTest()
.ExecuteAsSingleAsync();
}
}
public virtual async Task CustomActionMethodWithQueryableOfEntitiesReturnValueTest()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
ODataClient client = testEnvironment.Server.BuildODataClient(token: token);
await client.Controller <TestModelsController, TestModel>()
.Function(nameof(TestModelsController.CustomActionMethodWithQueryableOfEntitiesReturnValueTest))
.FindEntriesAsync();
}
}
public async Task LoggedInUserMustHaveAccessToJobsDashboard()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpResponseMessage getIndexPageResponse = await testEnvironment.Server.BuildHttpClient(token).GetAsync("/jobs");
Assert.AreEqual(HttpStatusCode.OK, getIndexPageResponse.StatusCode);
Assert.AreEqual("text/html", getIndexPageResponse.Content.Headers.ContentType.MediaType);
}
}
public virtual async Task GetSwaggerShouldWork()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
Token token = await testEnvironment.Server.LoginWithCredentials("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpClient client = testEnvironment.Server.BuildHttpClient(token: token);
HttpResponseMessage response = await client.GetAsync("api/v1/swagger");
response.EnsureSuccessStatusCode();
}
}
public virtual async Task CustomActionMethodWithQueryableOfEntitiesReturnValueTest()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.BuildTestODataClient(token: token);
await client.TestModels()
.CustomActionMethodWithQueryableOfEntitiesReturnValueTest()
.ExecuteAsEnumerableAsync();
}
}
public virtual async Task WebApiRoutingNotFoundReasonPhraseMustGetsReturnedAsUnknownError_NotFound()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpClient client = testEnvironment.Server.BuildHttpClient(token: token);
HttpResponseMessage response = await client.DeleteAsync("odata/Test/parentEntities(3)"); // no route for this url!
Assert.AreEqual("UnknownError:Not Found", response.ReasonPhrase);
}
}
public async Task SignInPageResponseMustHaveSecurityHeaders()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
HttpResponseMessage getSignInPage = await testEnvironment.Server.GetHttpClient()
.GetAsync("/SignIn");
Assert.AreEqual(true, getSignInPage.Headers.Contains("X-Frame-Options"));
Assert.AreEqual(true, getSignInPage.Headers.Contains("X-Content-Type-Options"));
Assert.AreEqual(true, getSignInPage.Headers.Contains("X-Download-Options"));
Assert.AreEqual(true, getSignInPage.Headers.Contains("X-XSS-Protection"));
}
}
public virtual async Task MediaTypeFormattersShouldReturnMinimalODataJsonWhenJsonContentTypeIsDeclaredFirstInRequest()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpResponseMessage getTestModelsResponse = await testEnvironment.Server.GetHttpClient(token)
.AddHeader("Accept", "application/json, text/javascript, */*; q=0.01")
.GetAsync("/odata/Test/TestModels");
Assert.AreEqual("application/json; charset=utf-8; odata.metadata=minimal", getTestModelsResponse.Content.Headers.ContentType.ToString());
}
}
public virtual void InValidLoginMustShowsAnError()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs {
UseRealServer = true
}))
{
using (RemoteWebDriver driver = testEnvironment.Server.BuildWebDriver(new RemoteWebDriverOptions
{
Uri = testEnvironment.Server.GetLoginUrl(acr_values: new Dictionary <string, string> {
{ "x", "1" }, { "y", "2" }
}),
ClientSideTest = false
}))
{
new WebDriverWait(driver, TimeSpan.FromSeconds(3))
.Until(ExpectedConditions.ElementExists(By.Name("loginForm")));
driver.FindElementByName("username").SendKeys("InValidUserName");
driver.FindElementByName("password").SendKeys("InValidPassword");
driver.FindElementByName("login").Click();
new WebDriverWait(driver, TimeSpan.FromSeconds(3))
.Until(ExpectedConditions.ElementExists(By.Name("error")));
Assert.AreEqual("Login failed", driver.FindElementByName("error").GetAttribute("innerText"));
}
bool foundAnyCorrectCall = false;
foreach (TestUserService userService in TestDependencyManager.CurrentTestDependencyManager.Objects.OfType <TestUserService>())
{
try
{
A.CallTo(() => userService.AuthenticateLocalAsync(A <LocalAuthenticationContext> .That.Matches(cntx => cntx.UserName == "InValidUserName" && cntx.Password == "InValidPassword"), A <CancellationToken> .Ignored))
.MustHaveHappenedOnceExactly();
foundAnyCorrectCall = true;
}
catch (ExpectationException) { }
}
Assert.IsTrue(foundAnyCorrectCall);
bool acr_values_are_logged = TestDependencyManager.CurrentTestDependencyManager
.Objects
.OfType <ILogger>()
.Any(l => l.LogData.Any(ld => ld.Key == "AcrValues" && ((string[])ld.Value).SequenceEqual(new[] { "x:1", "y:2" })));
Assert.IsTrue(acr_values_are_logged);
}
}
public virtual async Task WebApiExceptionHandlerFilterAttributeMustReturnKnownErrorReasonPhraseAndInternalServerErrorStatusCodeAndXCorrelationIdInResponseWhenAppExceptionThrownsInWebApi()
{
IEmailService emailService = A.Fake <IEmailService>();
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Throws(new AppException("Test"));
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(emailService);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.BuildTestODataClient(token: token, odataClientSettings: new ODataClientSettings
{
AfterResponse = message =>
{
if (message.StatusCode == HttpStatusCode.InternalServerError)
{
Assert.AreEqual(BitMetadataBuilder.KnownError, message.ReasonPhrase);
Assert.IsTrue(message.Headers.Any(h => h.Key == "Reason-Phrase" && h.Value.Any(v => v == BitMetadataBuilder.KnownError)));
ILogger logger = testEnvironment.GetObjects <ILogger>().Last();
string correlationId = (string)logger.LogData.Single(logData => logData.Key == "X-Correlation-ID").Value;
Assert.AreEqual(correlationId, message.Headers.Single(h => h.Key == "X-Correlation-ID").Value.Single());
}
}
});
try
{
await client.TestModels()
.SendEmail(to: "Someone", title: "Email title", message: "Email message")
.ExecuteAsync();
Assert.Fail();
}
catch (WebRequestException ex)
{
Assert.IsTrue(ex.Response.Contains("Test"));
Assert.AreEqual(HttpStatusCode.InternalServerError, ex.Code);
}
}
}
