internal async Task Delete_InValidAsync(Category category)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
var response =
(
await api.DeleteCategoryAsync(category) as JsonResult
).Value as ExecutionResult <bool>;
Assert.False(response.Data);
Assert.NotNull(response.Error);
Assert.False(response.IsSucceed);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task UpdatePasswordAsync_ValidAsync()
{
using (var context = Storage.CreateContext())
{
try
{
var auth = Storage.CreateGatewayController(context);
var identity =
(
await auth.LoginAsync(new Credentials {
Login = "******", Password = "******"
}) as JsonResult
).Value as ExecutionResult <Identity>;
GenericChecks.CheckSucceed(identity);
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
identity.Data.Account.Password = "******";
var updated =
(
await api.SaveAccountAsync(identity.Data.Account) as JsonResult
).Value as ExecutionResult <Account>;
GenericChecks.CheckSucceed(updated);
var responseGet =
(
await api.GetAccountAsync(identity.Data.Account.Id.Value) as JsonResult
).Value as ExecutionResult <Account>;
GenericChecks.CheckSucceed(responseGet);
Compare(responseGet.Data, identity.Data.Account, 1);
var newIdentity =
(
await auth.LoginAsync
(
new Credentials {
Login = "******", Password = identity.Data.Account.Password
}
) as JsonResult
).Value as ExecutionResult <Identity>;
GenericChecks.CheckSucceed(identity);
Compare(newIdentity.Data.Account, identity.Data.Account, 1);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task DeleteAccountAsync_ValidAsync(string sql, Account account)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
Storage.RunSql(sql);
var delResult =
(
await api.DeleteAccountAsync(account) as JsonResult
).Value as ExecutionResult <bool>;
GenericChecks.CheckSucceed(delResult);
var responseGet =
(
await api.GetAccountAsync(account.Id.Value) as JsonResult
).Value as ExecutionResult <Account>;
GenericChecks.CheckFail(responseGet);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task GetAccountsAsyncPaging_ValidAsync(string sql, Paging paging, Account[] expected)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
Storage.RunSql(sql);
var response =
(
await api.GetAccountsAsync(paging) as JsonResult
).Value as ExecutionResult <Account[]>;
GenericChecks.CheckSucceed(response);
foreach (var item in expected)
{
var actual = response.Data.FirstOrDefault(x => x.Id == item.Id);
Compare(actual, item);
}
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task GetAccountAsync_InValidAsync(string sql, int id)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
Storage.RunSql(sql);
var getResult =
(
await api.GetAccountAsync(id) as JsonResult
).Value as ExecutionResult <Account>;
GenericChecks.CheckFail(getResult);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task CountAsync_ValidAsync(string[] sql)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
Storage.RunSql(sql);
var response =
(
await api.CountAccountAsync() as JsonResult
).Value as ExecutionResult <int>;
GenericChecks.CheckSucceed(response);
Assert.Equal(sql.Length + 1, response.Data);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task AddAccountAsync_InValidAsync(Account account)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
var addResult =
(
await api.SaveAccountAsync(account) as JsonResult
).Value as ExecutionResult <Account>;
GenericChecks.CheckFail(addResult);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task GetRolesAsync_ValidAsync(string[] expectedRoles)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
var response =
(
api.GetRoles() as JsonResult
).Value as ExecutionResult <List <string> >;
GenericChecks.CheckSucceed(response);
Assert.Equal(expectedRoles.Length, response.Data.Count);
foreach (var item in expectedRoles)
{
var actural = response.Data.First(x => x == item);
Assert.Equal(item, actural);
}
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal void GetInformation_BadToken(string token)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = ControllerContextCreator.CreateInvalid(token);
var response =
(
api.GetInformationAsync() as JsonResult
).Value as ExecutionResult <Information>;
GenericChecks.CheckFail(response);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task UpdateIntroduction_InvalidAsync(Introduction update)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
var updateResponse =
(
await api.SaveIntroductionAsync(update) as JsonResult
).Value as ExecutionResult <Introduction>;
GenericChecks.CheckFail(updateResponse);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
public virtual UrlHelper UrlInit()
{
var controllerContext = ControllerContextCreator.Create(new FakeController());
var CC = controllerContext.RequestContext;
var Url = new System.Web.Mvc.UrlHelper(CC);
return(Url);
}
internal async Task Save_ValidAsync(Category update, Category expected)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
var apiPublic = Storage.CreatePublicController(context);
var response =
(
await api.SaveCategoryAsync(update) as JsonResult
).Value as ExecutionResult <Category>;
Assert.NotNull(response.Data);
Assert.Null(response.Error);
Assert.True(response.IsSucceed);
Compare(expected, response.Data);
var getResponse =
(
await apiPublic.GetCategoryAsync(update.Id.Value) as JsonResult
).Value as ExecutionResult <Category>;
Assert.NotNull(getResponse.Data);
Assert.Null(getResponse.Error);
Assert.True(getResponse.IsSucceed);
Compare(expected, getResponse.Data);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task UpdateAcountAsync_InValidAsync(Account account)
{
using (var context = Storage.CreateContext())
{
try
{
var auth = Storage.CreateGatewayController(context);
var identity =
(
await auth.LoginAsync(new Credentials {
Login = "******", Password = "******"
}) as JsonResult
).Value as ExecutionResult <Identity>;
GenericChecks.CheckSucceed(identity);
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
identity.Data.Account.Login = "******";
Storage.RunSql("INSERT INTO account (id, login, password, salt, role) VALUES (2, 'login', 'password', 'salt', 'role'); ");
var response =
(
await api.SaveAccountAsync(account) as JsonResult
).Value as ExecutionResult <Account>;
GenericChecks.CheckFail(response);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task UpdateIntroduction_ValidAsync(Introduction update, Introduction expected)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator.CreateValid(context, null);
var updateResponse =
(
await api.SaveIntroductionAsync(update) as JsonResult
).Value as ExecutionResult <Introduction>;
GenericChecks.CheckSucceed(updateResponse);
Compare(updateResponse.Data, expected);
Assert.Equal(expected.PosterUrl, updateResponse.Data.PosterUrl);
var apiPublic = Storage.CreatePublicController(context);
var getResponse =
(
await apiPublic.GetIntroductionAsync() as JsonResult
).Value as ExecutionResult <Introduction>;
GenericChecks.CheckSucceed(getResponse);
Compare(getResponse.Data, expected);
Assert.Equal(expected.PosterUrl, getResponse.Data.PosterUrl);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
internal async Task UpdateIntroduction_AddFile_ValidAsync()
{
using (var context = Storage.CreateContext())
{
try
{
var update = new Introduction
{
Content = "The service is on-line. Congratulations.",
Title = "Hello",
PosterDescription = "des",
PosterUrl = @"Files/untitled.png",
Version = 0
};
var stream = File.OpenRead(update.PosterUrl);
var ffcollection = new FormFileCollection
{
new FormFile(stream, 0, stream.Length, "introduction[posterToUpload]", "untitled.png")
};
var api = Storage.CreatePrivateController(context);
api.ControllerContext = await ControllerContextCreator
.CreateValid(context, ffcollection);
var updateResponse =
(
await api.SaveIntroductionAsync(update) as JsonResult
).Value as ExecutionResult <Introduction>;
GenericChecks.CheckSucceed(updateResponse);
Assert.NotNull(updateResponse.Data.PosterUrl);
var config = Storage.CreateConfiguration();
var pathStart = config["Endpoint"] + config["Location:StaticFilesRequestPath"];
Assert.StartsWith(pathStart, updateResponse.Data.PosterUrl);
var storagePath = config.GetSection("Location:FileStorage").Get <string>();
var fileExists = File.Exists(Path.Combine(storagePath, Path.GetFileName(updateResponse.Data.PosterUrl)));
Assert.True(fileExists);
var apiPublic = Storage.CreatePublicController(context);
var getResponse =
(
await apiPublic.GetIntroductionAsync() as JsonResult
).Value as ExecutionResult <Introduction>;
GenericChecks.CheckSucceed(getResponse);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
