private async void GetBlockMethodReturnsOkResponse()
{
//Arrange
string data = Guid.NewGuid().ToString();
EncryptService encryptService = new EncryptService();
string encryptedPass = encryptService.EncryptData("1111");
User user = new User("Dimitry", "Sukalo", encryptedPass);
Block genesisBlock = new Block();
UserFile userFile = new UserFile(data, data, new byte[1]);
Block block = new Block(userFile, user, genesisBlock);
Mock <IQueryable <Block> > blocks = new List <Block>()
{
genesisBlock,
block
}.AsQueryable().BuildMock();
Mock <DbSet <Block> > blockMock = new Mock <DbSet <Block> >();
SetSettingsInDb(blockMock, blocks);
Mock <IQueryable <User> > users = new List <User>()
{
user
}.AsQueryable().BuildMock();
Mock <DbSet <User> > usersMock = new Mock <DbSet <User> >();
SetSettingsInDb(usersMock, users);
Mock <BlockChainContext> db = new Mock <BlockChainContext>();
db.Setup(m => m.Blocks).Returns(blockMock.Object);
db.Setup(m => m.Users).Returns(usersMock.Object);
Mock <UserManager <User> > userManagerMock = new Mock <UserManager <User> >(new Mock <IUserStore <User> >().Object,
null, null, null, null, null, null, null, null);
Mock <IHttpContextAccessor> _contextAccessor = new Mock <IHttpContextAccessor>();
Mock <IUserClaimsPrincipalFactory <User> > _userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >();
Mock <SignInManager <User> > signInMock = new Mock <SignInManager <User> >(userManagerMock.Object,
_contextAccessor.Object, _userPrincipalFactory.Object, null, null, null, null);
Mock <UnitOfWork> unitMock = new Mock <UnitOfWork>(db.Object, signInMock.Object, userManagerMock.Object);
Mock <DecryptService> decryptMock = new Mock <DecryptService>();
GetDataService getDataService = new GetDataService(unitMock.Object, decryptMock.Object);
//Act
ResultOfApiRequest <UserFile> result = await getDataService.GetFile(user.Token, "1111", data);
//Assert
Assert.NotNull(result);
Assert.Equal(HttpStatusCode.OK, result?.StatusCode);
}
/// <summary>
/// Method which add user to the database
/// </summary>
/// <param name="user">User</param>
/// <returns></returns>
public async Task <ResultOfApiRequest <User> > RegisterUser(User user)
{
//Result of the method
ResultOfApiRequest <User> result;
//Checking if user is exist in the database
bool isExist = await _unitOfWork.UserRepository.GetUserByToken(user.Token) != null;
if (isExist)
{
result = new ResultOfApiRequest <User>(null, HttpStatusCode.BadRequest);
return(result);
}
else
{
//Creating user with temp information for returning to client side
User userTempInfo = new User()
{
Name = user.Name,
Surname = user.Surname,
Password = user.Password
};
//Encrypting user data
string userEncryptedName = _encryptService.EncryptData(user.Name);
string userEncryptedSurname = _encryptService.EncryptData(user.Surname);
string userEncryptedPassword = _encryptService.EncryptData(user.Password);
user.Name = userEncryptedName;
user.Surname = userEncryptedSurname;
user.Password = userEncryptedPassword;
user.UserName = userTempInfo.Name;
//Adding user to the database
bool resultOfAdding = _unitOfWork.UserManager.CreateAsync(user, user.Password).Result.Succeeded;
if (resultOfAdding)
{
await _unitOfWork.BlockChainContext.SaveChangesAsync();
//Change user data to the normal view
user.Name = userTempInfo.Name;
user.Password = userTempInfo.Password;
user.Surname = userTempInfo.Surname;
result = new ResultOfApiRequest <User>(user, HttpStatusCode.OK);
return(result);
}
else
{
result = new ResultOfApiRequest <User>(user, HttpStatusCode.BadRequest);
return(result);
}
}
}
private async void RegisterMethodReturnsOkStatusCode()
{
//Arrange
EncryptService encryptService = new EncryptService();
string password = encryptService.EncryptData("1111");
User user = new User("1111", "1111", "1111")
{
UserName = "******"
};
Mock <IQueryable <User> > users = new List <User>().AsQueryable().BuildMock();
Mock <DbSet <User> > usersMock = new Mock <DbSet <User> >();
SetSettingsInDb(usersMock, users);
Mock <BlockChainContext> db = new Mock <BlockChainContext>();
db.Setup(m => m.Users).Returns(usersMock.Object);
Mock <UserManager <User> > userManagerMock = new Mock <UserManager <User> >(new Mock <IUserStore <User> >().Object,
null, null, null, null, null, null, null, null);
Mock <IHttpContextAccessor> _contextAccessor = new Mock <IHttpContextAccessor>();
Mock <IUserClaimsPrincipalFactory <User> > _userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >();
Mock <SignInManager <User> > signInMock = new Mock <SignInManager <User> >(userManagerMock.Object,
_contextAccessor.Object, _userPrincipalFactory.Object, null, null, null, null);
userManagerMock.Setup(m => m.CreateAsync(user, password)).ReturnsAsync(IdentityResult.Success);
Mock <UnitOfWork> unitMock = new Mock <UnitOfWork>(db.Object, signInMock.Object, userManagerMock.Object);
Mock <EncryptService> encryptMock = new Mock <EncryptService>();
RegisterService registerService = new RegisterService(unitMock.Object, encryptMock.Object);
//Act
ResultOfApiRequest <User> result = await registerService.RegisterUser(user);
//Assert
Assert.NotNull(result);
Assert.Equal(user.Id, result?.Data?.Id);
Assert.Equal(user.Name, result?.Data?.Name);
Assert.Equal(user.Surname, result?.Data?.Surname);
Assert.Equal(user.Password, result?.Data?.Password);
Assert.Equal(user.Token, result?.Data?.Token);
Assert.Equal(HttpStatusCode.OK, result?.StatusCode);
}
public async Task <FileResult> Get(string fileName, string token = null, string password = null)
{
if (string.IsNullOrWhiteSpace(token) && string.IsNullOrWhiteSpace(password))
{
User user = await _unitOfWork.UserManager.GetUserAsync(User);
if (user != null)
{
token = user.Token;
password = _decryptService.DecryptData(user.Password);
}
else
{
return(null);
}
}
//Checking data for validation
if (!string.IsNullOrWhiteSpace(fileName))
{
//Result of getting data from the databse
ResultOfApiRequest <UserFile> result = await _getDataService.GetFile(token, password, fileName);
//Cheking if length of bytes of the file more than 0
if (result.Data.Data.Length > 0)
{
if (result.StatusCode == HttpStatusCode.OK)
{
//Creating the file for uploading to user
using (FileStream fs = new FileStream(result.Data.FileName, FileMode.Create))
{
await fs.WriteAsync(result.Data.Data, 0, result.Data.Data.Length);
}
//Creating file info that to get extension of the file
FileInfo fileInfo = new FileInfo($"DataFromUsers/{fileName}");
string extension = fileInfo?.Extension.Trim(new char[] { '.' });
return(PhysicalFile(fileInfo.FullName, $"application/{extension}", fileName));
}
}
else
{
return(null);
}
}
return(null);
}
private async void RegisterMethodReturnsUserIsExist()
{
//Arrange
User user = new User()
{
Name = Guid.NewGuid().ToString(),
Surname = Guid.NewGuid().ToString(),
Password = Guid.NewGuid().ToString()
};
Mock <IQueryable <User> > users = new List <User>()
{
user
}.AsQueryable().BuildMock();
Mock <DbSet <User> > usersMock = new Mock <DbSet <User> >();
SetSettingsInDb(usersMock, users);
Mock <BlockChainContext> db = new Mock <BlockChainContext>();
db.Setup(m => m.Users).Returns(usersMock.Object);
Mock <UserManager <User> > userManagerMock = new Mock <UserManager <User> >(new Mock <IUserStore <User> >().Object,
null, null, null, null, null, null, null, null);
Mock <IHttpContextAccessor> _contextAccessor = new Mock <IHttpContextAccessor>();
Mock <IUserClaimsPrincipalFactory <User> > _userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >();
Mock <SignInManager <User> > signInMock = new Mock <SignInManager <User> >(userManagerMock.Object,
_contextAccessor.Object, _userPrincipalFactory.Object, null, null, null, null);
Mock <UnitOfWork> unitMock = new Mock <UnitOfWork>(db.Object, signInMock.Object, userManagerMock.Object);
Mock <EncryptService> encryptMock = new Mock <EncryptService>();
RegisterService registerService = new RegisterService(unitMock.Object, encryptMock.Object);
//Act
ResultOfApiRequest <User> result = await registerService.RegisterUser(user);
//Assert
Assert.NotNull(result);
Assert.NotEqual(user.Id, result?.Data?.Id);
Assert.NotEqual(user.Name, result?.Data?.Name);
Assert.NotEqual(user.Surname, result?.Data?.Surname);
Assert.NotEqual(user.Password, result?.Data?.Password);
Assert.NotEqual(user.Token, result?.Data?.Token);
Assert.Equal(HttpStatusCode.BadRequest, result?.StatusCode);
}
private async void AddDataToTheChainReturnsOkRequest()
{
//Arrange
Mock <IQueryable <Block> > blocks = new List <Block>().AsQueryable().BuildMock();
Mock <DbSet <Block> > blockMock = new Mock <DbSet <Block> >();
SetSettingsInDb(blockMock, blocks);
EncryptService encryptService = new EncryptService();
string encryptedPass = encryptService.EncryptData("1111");
User user = new User("Dimitry", "Sukalo", encryptedPass);
Mock <IQueryable <User> > users = new List <User>()
{
user
}.AsQueryable().BuildMock();
Mock <DbSet <User> > usersMock = new Mock <DbSet <User> >();
SetSettingsInDb(usersMock, users);
Mock <BlockChainContext> db = new Mock <BlockChainContext>();
db.Setup(m => m.Blocks).Returns(blockMock.Object);
db.Setup(m => m.Users).Returns(usersMock.Object);
Mock <UserManager <User> > userManagerMock = new Mock <UserManager <User> >(new Mock <IUserStore <User> >().Object,
null, null, null, null, null, null, null, null);
Mock <IHttpContextAccessor> _contextAccessor = new Mock <IHttpContextAccessor>();
Mock <IUserClaimsPrincipalFactory <User> > _userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >();
Mock <SignInManager <User> > signInMock = new Mock <SignInManager <User> >(userManagerMock.Object,
_contextAccessor.Object, _userPrincipalFactory.Object, null, null, null, null);
Mock <UnitOfWork> unitMock = new Mock <UnitOfWork>(db.Object, signInMock.Object, userManagerMock.Object);
Mock <DecryptService> decryptMock = new Mock <DecryptService>();
Mock <PostDataService> postDataService = new Mock <PostDataService>(unitMock.Object, decryptMock.Object);
FormFile file = new FormFile(Stream.Null, 1, 1, "testfile", "");
//Act
ResultOfApiRequest <string> resultOfApiRequest = await postDataService.Object.AddDataToTheChain(file, user.Token, "1111", true);
//Assert
Assert.NotNull(resultOfApiRequest);
Assert.Equal(HttpStatusCode.OK, resultOfApiRequest?.StatusCode);
}
/// <summary>
/// Get user file from the database for downloading
/// </summary>
/// <param name="token">User token</param>
/// <param name="password">User password</param>
/// <param name="fileName">User file name</param>
/// <returns></returns>
public async Task <ResultOfApiRequest <UserFile> > GetFile(string token, string password, string fileName)
{
//Getting user blocks from the database
List <Block> blocks = _unitOfWork.BlockRepository.GetBlocksByUserToken(token);
//Getting user from the databse
User userFromDb = await _unitOfWork.UserRepository.GetUserByToken(token);
//Creating object of the user file
UserFile userFile = new UserFile(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new byte[0]);
//Result of the method
ResultOfApiRequest <UserFile> result;
//Decrypting user password
string userDecryptedPassword = _decryptService.DecryptData(userFromDb?.Password);
if (blocks != null && userFromDb != null && userDecryptedPassword == password)
{
foreach (var block in blocks)
{
if (block.Data.Title == fileName)
{
userFile = block.Data;
break;
}
}
if (userFile.Data.Length > 0)
{
result = new ResultOfApiRequest <UserFile>(userFile, HttpStatusCode.OK);
return(result);
}
else
{
result = new ResultOfApiRequest <UserFile>(userFile, HttpStatusCode.BadRequest);
return(result);
}
}
result = new ResultOfApiRequest <UserFile>(userFile, HttpStatusCode.BadRequest);
return(result);
}
private async void GetBlocksMethodReturnsBadRequest()
{
//Arrange
Mock <IQueryable <Block> > blocks = new List <Block>().AsQueryable().BuildMock();
Mock <DbSet <Block> > blockMock = new Mock <DbSet <Block> >();
SetSettingsInDb(blockMock, blocks);
User user = new User("Dimitry", "Sukalo", "1111");
Mock <IQueryable <User> > users = new List <User>().AsQueryable().BuildMock();
Mock <DbSet <User> > usersMock = new Mock <DbSet <User> >();
SetSettingsInDb(usersMock, users);
Mock <BlockChainContext> db = new Mock <BlockChainContext>();
db.Setup(m => m.Blocks).Returns(blockMock.Object);
db.Setup(m => m.Users).Returns(usersMock.Object);
Mock <UserManager <User> > userManagerMock = new Mock <UserManager <User> >(new Mock <IUserStore <User> >().Object,
null, null, null, null, null, null, null, null);
Mock <IHttpContextAccessor> _contextAccessor = new Mock <IHttpContextAccessor>();
Mock <IUserClaimsPrincipalFactory <User> > _userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >();
Mock <SignInManager <User> > signInMock = new Mock <SignInManager <User> >(userManagerMock.Object,
_contextAccessor.Object, _userPrincipalFactory.Object, null, null, null, null);
Mock <UnitOfWork> unitMock = new Mock <UnitOfWork>(db.Object, signInMock.Object, userManagerMock.Object);
Mock <DecryptService> decryptMock = new Mock <DecryptService>();
GetDataService getDataService = new GetDataService(unitMock.Object, decryptMock.Object);
//Act
ResultOfApiRequest <UserFile> result = await getDataService.GetFile(user.Token, user.Password, Guid.NewGuid().ToString());
//Assert
Assert.NotNull(result);
Assert.Equal(HttpStatusCode.BadRequest, result.StatusCode);
}
public async Task <ActionResult <string> > Post(IFormFile file, string userToken = null, string password = null)
{
if (string.IsNullOrWhiteSpace(userToken) && string.IsNullOrWhiteSpace(password))
{
User user = await _unitOfWork.UserManager.GetUserAsync(User);
if (user != null)
{
userToken = user.Token;
password = _decryptService.DecryptData(user.Password);
}
else
{
return(BadRequest(JsonConvert.SerializeObject(new ResultOfApiRequest <string>("User doesn't exist", HttpStatusCode.BadRequest))));
}
}
if (file != null)
{
//Getting result of adding data to the database
ResultOfApiRequest <string> result = await _postDataService.AddDataToTheChain(file, userToken, password);
//Converting result to json format
string jsonData = JsonConvert.SerializeObject(result);
if (result.StatusCode == HttpStatusCode.OK)
{
return(Ok(jsonData));
}
else
{
return(BadRequest(jsonData));
}
}
return(BadRequest(JsonConvert.SerializeObject(new ResultOfApiRequest <string>(string.Empty, HttpStatusCode.BadRequest))));
}
public async Task <ActionResult <ResultOfApiRequest <User> > > Post(RegisterViewModel registerViewModel)
{
if (registerViewModel != null && ModelState.IsValid)
{
if (registerViewModel.Name != "admin")
{
MapperConfiguration configuration = new MapperConfiguration(conf => conf.CreateMap <RegisterViewModel, User>());
Mapper mapper = new Mapper(configuration);
User user = mapper.Map <RegisterViewModel, User>(registerViewModel);
if (user != null)
{
//Result of adding user to the database
ResultOfApiRequest <User> resultOfApiRequest = await _registerService.RegisterUser(user);
if (resultOfApiRequest.StatusCode == HttpStatusCode.OK)
{
return(Ok(resultOfApiRequest));
}
else
{
ModelState.AddModelError(string.Empty, "User is not registreted.");
return(BadRequest(ModelState));
}
}
ModelState.AddModelError(string.Empty, "Incorrect data");
return(BadRequest(ModelState));
}
ModelState.AddModelError(string.Empty, "Name cannot be admin");
return(BadRequest(ModelState));
}
return(BadRequest(ModelState));
}
/// <summary>
/// Adding data to the block and adding block to the chain
/// </summary>
/// <param name="data">Data of the block</param>
/// <returns></returns>
public async Task <ResultOfApiRequest <string> > AddDataToTheChain(IFormFile file, string userToken, string password, bool isTest = false)
{
//Creating the chain and if chain is exist it will be downloaded from database
Chain chain = new Chain(_unitOfWork);
ResultOfApiRequest <string> result;
//Getting user from the database
User userFromDb = await _unitOfWork.UserRepository.GetUserByToken(userToken);
//Creating new file name which will be saved to the database
string newFileName = Guid.NewGuid().ToString() + file.FileName;
//Decrypting user password for checking if it equal to requester password
string userDecryptedPassword = _decryptService.DecryptData(userFromDb?.Password);
if (userFromDb != null && userDecryptedPassword == password)
{
//Directory name where will be saved user file
string dirName = "DataFromUsers";
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
//Massive of bytes of the user file
byte[] fileData;
UserFile userFile;
DirectoryInfo directoryInfo = new DirectoryInfo(dirName);
foreach (var fileInfo in directoryInfo.GetFiles())
{
fileInfo.Delete();
}
//Checking if method is not used in testing
if (!isTest)
{
//Creating user file in directory
using (var fstream = new FileInfo($"DataFromUsers/{newFileName}").Create())
{
file.CopyTo(fstream);
fstream.Close();
}
//Getting file info for opening this file
FileInfo fileInfo = new FileInfo($"DataFromUsers/{newFileName}");
//Reading bytes from the file
using (FileStream fs = new FileStream(fileInfo.FullName, FileMode.Open))
{
fileData = new byte[fs.Length];
await fs.ReadAsync(fileData, 0, fileData.Length);
fs.Close();
}
//Creating object of user file
userFile = new UserFile(fileInfo.FullName, fileInfo.Name, fileData);
//Deleting file from the directory
fileInfo.Delete();
}
else
{
userFile = new UserFile(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new byte[1]);
}
//Adding user file to the database
await chain.Add(userFile, userFromDb);
result = new ResultOfApiRequest <string>(newFileName, HttpStatusCode.OK);
return(result);
}
result = new ResultOfApiRequest <string>(newFileName, HttpStatusCode.BadRequest);
return(result);
}
