private Either <IError, CapabilityInfo> GetCapabilityFromServer(string name)
{
var message = RequestCreator.Create(_encryptor, MessageType.GetCapability,
JsonConvert.SerializeObject(new CapabilityInfo(name)));
_requestSocket.SendMultipartMessage(message);
var response = _requestSocket.ReceiveMultipartMessage();
var messageType = (MessageType)response.Pop().ConvertToInt32();
switch (messageType)
{
case MessageType.GrantCapability:
var infoJson = _encryptor.Decrypt(response.Pop().ToByteArray());
var info = JsonConvert.DeserializeObject <CapabilityInfo>(infoJson);
return(new Right <IError, CapabilityInfo>(info));
case MessageType.Error:
var errorContent = response.Pop().ToByteArray();
return(new Left <IError, CapabilityInfo>(ErrorMessageReceiver.GetError(errorContent)));
default:
return(new Left <IError, CapabilityInfo>(new UnexpectedMessageError()));
}
}
private void SendEncryptionKey(RequestSocket requestSocket, string publicKey)
{
var encryptionClient = new AsymetricEncryptor(publicKey);
var encryptionKeyJson = JsonConvert.SerializeObject(_encryptor.EncryptionKey);
var request = RequestCreator.Create(encryptionClient, MessageType.SendEncryptionKey, encryptionKeyJson);
requestSocket.SendMultipartMessage(request);
}
[Fact] // async Task<bool> StartHomeManage(string id, byte[] fileContent)
public async Task StartHomeManage_WithGivenRequestIdAndDocumentFile_ShouldInitiateManagementContract()
{
// Arrange
var country = CountryCreator.Create();
var city = CityCreator.Create(country.Id);
var home = HomeCreator.CreateAny(city.Id);
var image = ImageCreator.CreateForModel();
await this.Context.Countries.AddAsync(country);
await this.Context.Cities.AddAsync(city);
await this.Context.Homes.AddAsync(home);
await this.Context.CloudImages.AddAsync(image);
var request = RequestCreator.Create(home);
await this.Context.Requests.AddAsync(request);
await this.Context.SaveChangesAsync();
var approvedRequest = RequestCreator.CreateManageApproved(home, request.User, request.Id);
var user = request.User;
this.UserManager
.Setup(u => u.FindByIdAsync(user.Id))
.Returns(Task.FromResult(user));
await this.UserManager.Object
.AddToRoleAsync(user, "Manager");
var requestService = new Mock <IOwnerRequestService>();
requestService.Setup(x => x.ApproveRequestAsync(request.Id))
.Returns(Task.FromResult(approvedRequest));
var contractService = new Mock <IOwnerContractService>();
contractService.Setup(x => x.CreateManageContractAsync(new byte[1024], request.User))
.Returns(Task.FromResult(true));
var service = new OwnerListingService(this.Context, this.UserManager.Object, requestService.Object, contractService.Object);
// Act
var result = await service.StartHomeManage(request.Id, new byte[1024]);
var changedHomeInfo = await this.Context.Homes.Where(h => h.Id == home.Id).FirstOrDefaultAsync();
var changedUser = await this.Context.Users.Where(u => u.Id == user.Id).FirstOrDefaultAsync();
// Assert
result.Should().BeTrue();
changedHomeInfo.ManagerId.Should().Equals(user.Id);
changedUser.ManagedHomes.Count().Should().Be(1);
}
public void RequestCreateWithoutPayloadTest()
{
var request = RequestCreator.Create(new NoEncryption(), MessageType.Acknowledge);
Assert.AreEqual(2, request.FrameCount);
var type = (MessageType)request.Pop().ConvertToInt32();
Assert.AreEqual(MessageType.Acknowledge, type);
var payload = request.Pop().ToByteArray();
Assert.AreEqual(0, payload.Length);
}
[Fact] // 7. async Task<OwnerRequestDetailsServiceModel> GetRequestDetailsAsync(string requestId)
public async void GetRequestDetailsAsync_WithGivenRequestId_ShouldReturnServiceModel()
{
// Arrange
var country = CountryCreator.Create();
var city = CityCreator.Create(country.Id);
var owner = UserCreator.Create("Suzdurma", "Saturov", "satura", "*****@*****.**");
var home = HomeCreator.CreateOwnerHome(owner.Id, city.Id);
var request = RequestCreator.Create(home);
var doc = new byte[1024];
request.Document = doc;
await this.Context.Countries.AddAsync(country);
await this.Context.Cities.AddAsync(city);
await this.Context.Users.AddAsync(owner);
await this.Context.Homes.AddAsync(home);
await this.Context.Requests.AddAsync(request);
await this.Context.SaveChangesAsync();
var model = new OwnerRequestDetailsServiceModel
{
Id = request.Id,
Date = request.Date.ToString("dd/MM/yyyy h:mm tt"),
UserFirstName = request.User.FirstName,
UserLastName = request.User.LastName,
Email = request.User.Email,
Phone = request.User.PhoneNumber,
RequestType = request.Type.ToString(),
Document = doc,
};
var service = new OwnerRequestService(this.Context);
// Act
var result = await service.GetRequestDetailsAsync(request.Id);
var expected = model;
// Assert
result.Should().BeOfType <OwnerRequestDetailsServiceModel>();
result.Should().Equals(expected);
}
public void RequestCreateWithPayloadTest()
{
var payload = JsonConvert.SerializeObject(ErrorCode.InvocationError);
var request = RequestCreator.Create(new NoEncryption(), MessageType.Error, payload);
Assert.AreEqual(2, request.FrameCount);
var type = (MessageType)request.Pop().ConvertToInt32();
Assert.AreEqual(MessageType.Error, type);
var errorCode = JsonConvert.DeserializeObject <ErrorCode>(request.Pop().ConvertToString());
Assert.AreEqual(ErrorCode.InvocationError, errorCode);
}
private static Maybe <string> RequestPublicKey(RequestSocket requestSocket)
{
var request = RequestCreator.Create(new NoEncryption(), MessageType.RequestPublicKey);
requestSocket.SendMultipartMessage(request);
var responseMessage = requestSocket.ReceiveMultipartMessage();
Maybe <string> response = null;
ResponseReader.Read <string>(new NoEncryption(), new NoEncryption(), responseMessage)
.Case((Response <string> publicKay) => response = new Maybe <string>(publicKay.Payload))
.Fold(_ => response = new Nothing <string>());
return(response);
}
[Fact] // 2. async Task<IEnumerable<OwnerAllRequestsServiceModel>> GetAllRequestsWthDetailsAsync(string id)
public async void GetAllRequestsWthDetailsAsync_WithGivenOwnerId_ShouldReturnCollectionOfRequests()
{
// Arrange
var country = CountryCreator.Create();
var city = CityCreator.Create(country.Id);
var owner = UserCreator.Create("Suzdurma", "Saturov", "satura", "*****@*****.**");
var anotherOwner = UserCreator.Create("Svinevud", "Kulchibutov", "kulkata", "*****@*****.**");
var home = HomeCreator.CreateOwnerHome(owner.Id, city.Id);
var home2 = HomeCreator.CreateOwnerHome(owner.Id, city.Id);
var homе3 = HomeCreator.CreateOwnerHome(owner.Id, city.Id);
var homе4 = HomeCreator.CreateOwnerHome(anotherOwner.Id, city.Id);
var request = RequestCreator.Create(home);
var request2 = RequestCreator.Create(home2);
var request3 = RequestCreator.Create(homе3);
var request4 = RequestCreator.Create(homе4);
request2.User.UserName = "******";
request3.User.UserName = "******";
await this.Context.Countries.AddAsync(country);
await this.Context.Cities.AddAsync(city);
await this.Context.Users.AddRangeAsync(owner, anotherOwner);
await this.Context.Homes.AddRangeAsync(home, home2, homе3, homе4);
await this.Context.Requests.AddRangeAsync(request, request2, request3, request4);
await this.Context.SaveChangesAsync();
var service = new OwnerRequestService(this.Context);
// Act
var result = (await service.GetAllRequestsWthDetailsAsync(owner.Id)).ToList();
var expected = await this.Context.Requests.Where(r => r.Home.OwnerId == owner.Id).ToListAsync();
// Assert
result.Should().AllBeOfType <OwnerAllRequestsServiceModel>();
result.Count().Should().Equals(expected.Count());
result.Should().HaveCount(3, "because there are 3 homes for which the owner received requests individually");
result[0].Username = request.User.UserName; // shpeka
result[1].Username = request2.User.UserName; // fileto
result[2].Username = request3.User.UserName; // butcheto
}
[Fact] // 3. async Task<Request> ApproveRequestAsync(string id)
public async void ApproveRequestAsync_WithGivenId_ShouldApproveRequest_AndReturnTheRequest()
{
// Arrange
var country = CountryCreator.Create();
var city = CityCreator.Create(country.Id);
var owner = UserCreator.Create("Suzdurma", "Saturov", "satura", "*****@*****.**");
var home = HomeCreator.CreateOwnerHome(owner.Id, city.Id);
var home2 = HomeCreator.CreateOwnerHome(owner.Id, city.Id);
var request = RequestCreator.Create(home);
var request2 = RequestCreator.Create(home2);
var requestStatusBefore = request.Status;
var request2StatusBefore = request2.Status;
await this.Context.Countries.AddAsync(country);
await this.Context.Cities.AddAsync(city);
await this.Context.Users.AddAsync(owner);
await this.Context.Homes.AddRangeAsync(home, home2);
await this.Context.Requests.AddRangeAsync(request, request2);
await this.Context.SaveChangesAsync();
var service = new OwnerRequestService(this.Context);
// Act
var result = await service.ApproveRequestAsync(request.Id);
var result2 = await service.ApproveRequestAsync(request2.Id);
var expected = RequestStatus.Approved;
var expected2 = RequestStatus.Approved;
// Assert
result.Should().BeOfType <Request>();
result.Status.Should().Equals(expected);
result2.Status.Should().Equals(expected2);
result.Status.Should().NotBe(requestStatusBefore);
result2.Status.Should().NotBe(request2StatusBefore);
}
[Fact] // 5. async Task<byte[]> GetFileAsync(string requestId)
public async void GetFileAsync_WithGivenRequestId_ShouldReturnByteArrayOfTheFile()
{
// Arrange
var country = CountryCreator.Create();
var city = CityCreator.Create(country.Id);
var owner = UserCreator.Create("Suzdurma", "Saturov", "satura", "*****@*****.**");
var anotherOwner = UserCreator.Create("Svinevud", "Kulchibutov", "kulkata", "*****@*****.**");
var home = HomeCreator.CreateOwnerHome(owner.Id, city.Id);
var request = RequestCreator.Create(home);
request.Document = new byte [1024];
await this.Context.Countries.AddAsync(country);
await this.Context.Cities.AddAsync(city);
await this.Context.Users.AddAsync(owner);
await this.Context.Homes.AddAsync(home);
await this.Context.Requests.AddAsync(request);
await this.Context.SaveChangesAsync();
var service = new OwnerRequestService(this.Context);
// Act
var result = await service.GetFileAsync(request.Id);
var expected = await this.Context.Requests
.Where(r => r.Id == request.Id)
.Select(r => r.Document)
.FirstOrDefaultAsync();
// Assert
result.Should().BeOfType <byte[]>();
result.Should().Equals(expected);
}
[Fact] // 4. async Task<bool> RejectRequestAsync(string id)
public async void RejectRequestAsync_WithGivenId_ShouldRejectRequest_AndReturnTrue()
{
// Arrange
var country = CountryCreator.Create();
var city = CityCreator.Create(country.Id);
var owner = UserCreator.Create("Suzdurma", "Saturov", "satura", "*****@*****.**");
var anotherOwner = UserCreator.Create("Svinevud", "Kulchibutov", "kulkata", "*****@*****.**");
var home = HomeCreator.CreateOwnerHome(owner.Id, city.Id);
var home2 = HomeCreator.CreateOwnerHome(owner.Id, city.Id);
var request = RequestCreator.Create(home);
var request2 = RequestCreator.Create(home2);
var requestStatusBefore = request.Status;
var request2StatusBefore = request2.Status;
await this.Context.Countries.AddAsync(country);
await this.Context.Cities.AddAsync(city);
await this.Context.Users.AddAsync(owner);
await this.Context.Homes.AddRangeAsync(home, home2);
await this.Context.Requests.AddRangeAsync(request, request2);
await this.Context.SaveChangesAsync();
var service = new OwnerRequestService(this.Context);
// Act
var result = await service.RejectRequestAsync(request.Id);
var result2 = await service.RejectRequestAsync(request2.Id);
// Assert
result.Should().BeTrue();
result2.Should().BeTrue();
}
[Fact] // async Task<string> ChangeHomeStatusAsync(Request request)
public async Task ChangeHomeStatusAsync_WithGivenRequestObject_ShouldReturnHomeIdWhenSuccessful()
{
// Arrange
var country = CountryCreator.Create();
var city = CityCreator.Create(country.Id);
var home = HomeCreator.CreateAny(city.Id);
var image = ImageCreator.CreateForModel();
await this.Context.Countries.AddAsync(country);
await this.Context.Cities.AddAsync(city);
await this.Context.Homes.AddAsync(home);
await this.Context.CloudImages.AddAsync(image);
var request = RequestCreator.Create(home);
await this.Context.Requests.AddAsync(request);
await this.Context.SaveChangesAsync();
var service = new OwnerListingService(this.Context, null, null, null);
// Act
var result = await service.ChangeHomeStatusAsync(request);
var homeFromDb = await this.Context.Homes.Where(h => h.Id == home.Id).FirstOrDefaultAsync();
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <string>();
result.Should().Match(home.Id);
result.Should().Match(homeFromDb.Id);
homeFromDb.Status.Should().NotBe(HomeStatus.ToRent);
homeFromDb.Status.Should().Be(HomeStatus.Rented);
}
[Fact] // async Task<bool> StartRent(string id, byte[] fileContent)
public async void StartRent_ForGivenOwnerId_ShouldSuccessfullyInitiateRentAndReturnTrue()
{
// Arrange
var country = CountryCreator.Create();
var city = CityCreator.Create(country.Id);
var home = HomeCreator.CreateAny(city.Id);
var image = ImageCreator.CreateForModel();
await this.Context.Countries.AddAsync(country);
await this.Context.Cities.AddAsync(city);
await this.Context.Homes.AddAsync(home);
await this.Context.CloudImages.AddAsync(image);
var request = RequestCreator.Create(home);
await this.Context.Requests.AddAsync(request);
await this.Context.SaveChangesAsync();
var approvedRequest = RequestCreator.CreateRentApproved(home, request.User, request.Id);
var user = request.User;
this.UserManager
.Setup(u => u.FindByIdAsync(user.Id))
.Returns(Task.FromResult(user));
await this.UserManager.Object
.AddToRoleAsync(user, "Tenant");
var requestService = new Mock <IOwnerRequestService>();
requestService
.Setup(x => x.ApproveRequestAsync(request.Id))
.Returns(Task.FromResult(approvedRequest));
var listingService = new Mock <IOwnerListingService>();
listingService
.Setup(x => x.ChangeHomeStatusAsync(approvedRequest))
.Returns(Task.FromResult(approvedRequest.HomeId));
var rental = new Rental
{
Id = 1,
RentDate = DateTime.UtcNow,
HomeId = home.Id,
TenantId = user.Id,
};
var rentalServiceMock = new Mock <IOwnerRentalService>();
rentalServiceMock.Setup(y => y.CreateRental(home.Id, user.Id))
.Returns(Task.FromResult(rental));
var contractService = new Mock <IOwnerContractService>();
contractService
.Setup(x => x.CreateRentalContractAsync(new byte[1024], request.User, rental))
.Returns(Task.FromResult(true));
var service = new OwnerRentalService(this.Context, requestService.Object, listingService.Object, contractService.Object, this.UserManager.Object);
// Act
var result = await service.StartRent(request.Id, new byte[1024]);
var rentalInfo = await this.Context.Rentals.Where(r => r.Home.Id == home.Id).FirstOrDefaultAsync();
var changedUser = await this.Context.Users.Where(u => u.Id == user.Id).FirstOrDefaultAsync();
// Assert
result.Should().BeTrue();
rentalInfo.TenantId.Should().Equals(user.Id);
changedUser.Rentals.Count().Should().Be(1);
}
