public async void DeleteUserProfileByIdentityIdAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "DeleteUserProfileByIdentityIdAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
context.AddRange(_users);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var user = await context.Users.AsNoTracking().FirstOrDefaultAsync();
var service = new UserAdministrationService(context, _mapper);
var resultPositive = await service.DeleteUserProfileByIdentityIdAsync(user.Id.ToString());
var resultNegative = await service.DeleteUserProfileByIdentityIdAsync(new Guid().ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Message.Should().BeNull();
resultNegative.IsSuccess.Should().BeFalse();
resultNegative.Message.Should().Contain("not exist");
}
}
public async void CreateUserAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "CreateUserAsync_Positive_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
var service = new UserService(context, _mapper);
AddUser user = new AddUser()
{
Id = Guid.NewGuid().ToString()
};
AddUser failAddUser = new AddUser()
{
Id = user.Id
};
var resultPositive = await service.CreateUserProfileAsync(user.Id, user.NickName);
//var resultNegative = await service.CreateUserProfileAsync(failAddUser.Id);
resultPositive.Data.Id.Should().BeEquivalentTo(user.Id);
//resultNegative.IsSuccess.Should().BeFalse();
}
}
public List <Homeowner> GetHomeowners()
{
using (var context = new ApartmentContext())
{
return(context.Homeowners.ToList());
}
}
public Apartment Get(int id)
{
using (var context = new ApartmentContext())
{
return(context.Apartments.FirstOrDefault(a => a.Id == id));
}
}
public async void GetCommentByIdAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "GetCommentByIdAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
context.AddRange(_comments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var comment = await context.Comments.AsNoTracking().FirstOrDefaultAsync();
var service = new CommentAdministrationService(context, _mapper);
var resultPositive = await service.GetCommentByIdAsync(comment.Id.ToString());
var resultNegative = await service.GetCommentByIdAsync(new Guid().ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Title.Should().BeEquivalentTo(comment.Title);
resultNegative.IsSuccess.Should().BeFalse();
resultNegative.Data.Should().BeNull();
}
}
public List <Apartment> GetAppartments()
{
using (var context = new ApartmentContext())
{
return(context.Apartments.ToList());
}
}
public async void DeleteCommentByIdAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "DeleteCommentByIdAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
foreach (var item in _comments)
{
item.AuthorId = Guid.NewGuid();
}
context.AddRange(_comments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var comment = await context.Comments.AsNoTracking().FirstOrDefaultAsync();
var service = new CommentUserService(context, _mapper);
var resultPositive = await service.DeleteCommentByIdAsync(comment.Id.ToString(), comment.AuthorId.ToString());
var resultNegative = await service.DeleteCommentByIdAsync(new Guid().ToString(), new Guid().ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Message.Should().BeNull();
resultNegative.IsSuccess.Should().BeFalse();
resultNegative.Message.Should().Contain("Comment was not found");
}
}
public Homeowner Get(int id)
{
using (var context = new ApartmentContext())
{
return(context.Homeowners.FirstOrDefault(h => h.Id == id));
}
}
public Tenant Get(int id)
{
using (var context = new ApartmentContext())
{
return(context.Tenants.FirstOrDefault(t => t.Id == id));
}
}
public async void CreateCommentAsync_Positive_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "CreateCommentAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
context.AddRange(_users);
context.AddRange(_apartments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var user = context.Users.AsNoTracking().FirstOrDefault();;
var apartment = context.Apartments.AsNoTracking().FirstOrDefault();;
AddComment comment = new AddComment()
{
ApartmentId = apartment.Id.ToString(),
Title = "Title",
Text = "Text"
};
var service = new CommentUserService(context, _mapper);
var resultPositive = await service.CreateCommentAsync(comment, user.Id.ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Title.Should().BeEquivalentTo(comment.Title);
}
}
public List <Reservation> GetReservations()
{
using (var context = new ApartmentContext())
{
return(context.Reservations.ToList());
}
}
public Reservation Get(int id)
{
using (var context = new ApartmentContext())
{
return(context.Reservations.FirstOrDefault(r => r.Id == id));
}
}
public void Update(Reservation reservation)
{
using (var context = new ApartmentContext())
{
context.Entry(reservation).State = System.Data.Entity.EntityState.Modified;
context.SaveChanges();
}
}
public void Update(Tenant tenant)
{
using (var context = new ApartmentContext())
{
context.Entry(tenant).State = System.Data.Entity.EntityState.Modified;
context.SaveChanges();
}
}
public void Create(Tenant tenant)
{
using (var context = new ApartmentContext())
{
context.Tenants.Add(tenant);
context.SaveChanges();
}
}
public void Create(Apartment appartment)
{
using (var context = new ApartmentContext())
{
context.Apartments.Add(appartment);
context.SaveChanges();
}
}
public void Create(Reservation reservation)
{
using (var context = new ApartmentContext())
{
context.Reservations.Add(reservation);
context.SaveChanges();
}
}
public UserController(ApartmentContext context,
IOptions <AppSettings> appSettings,
IMapper mapper)
{
_context = context;
_appSettings = appSettings.Value;
_mapper = mapper;
}
public void Create(Homeowner homeowner)
{
using (var context = new ApartmentContext())
{
context.Homeowners.Add(homeowner);
context.SaveChanges();
}
}
public ApartmentController(IOptionsSnapshot <AppSettings> settings,
IApartmentIntegrationEventService apartmentIntegrationEventService,
ApartmentContext context)
{
_apartmentIntegrationEventService = apartmentIntegrationEventService;
_context = context ?? throw new ArgumentNullException(nameof(context));
_context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
_settings = settings.Value;
}
public async void CreateOrderAsync_Positive_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "CreateOrderAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
context.AddRange(_users);
await context.SaveChangesAsync();
User userWithApartments = context.Users.AsNoTracking().FirstOrDefault();
foreach (var item in _addresses)
{
item.CountryId = context.Countries.FirstOrDefault().Id;
}
for (int i = 0; i < 2; i++)
{
_apartments[i].OwnerId = userWithApartments.Id;
_apartments[i].Address = _addresses[i];
}
context.AddRange(_apartments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var service = new OrderUserService(context, _mapper);
var user = context.Users.AsNoTracking().FirstOrDefault();;
var apartment = context.Apartments.AsNoTracking().FirstOrDefault();;
IEnumerable <DateTime> dateTimes = new List <DateTime>()
{
DateTime.Now.Date
};
AddOrder order = new AddOrder()
{
ApartmentId = apartment.Id.ToString(),
Dates = dateTimes
};
var resultPositive = await service.CreateOrderAsync(order, user.Id.ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Apartment.Title.Should().BeEquivalentTo(apartment.Title);
resultPositive.Data.Order.Dates.FirstOrDefault().Should().BeSameDateAs(dateTimes.First());
context.BusyDates.FirstOrDefault().Date.Should().BeSameDateAs(dateTimes.First());
}
}
public ApartmentIntegrationEventService(
ILogger <ApartmentIntegrationEventService> logger,
IEventBus eventBus,
ApartmentContext apartmentContext,
Func <DbConnection, IIntegrationEventLogService> integrationEventLogServiceFactory)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_apartmentContext = apartmentContext ?? throw new ArgumentNullException(nameof(apartmentContext));
_integrationEventLogServiceFactory = integrationEventLogServiceFactory ?? throw new ArgumentNullException(nameof(integrationEventLogServiceFactory));
_eventBus = eventBus ?? throw new ArgumentNullException(nameof(eventBus));
_eventLogService = _integrationEventLogServiceFactory(apartmentContext.Database.GetDbConnection());
}
public async void GetAllApartmentByUserIdAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "GetAllApartmentByUserIdAsync_PositiveAndNegative_TestAsync")
.Options;
User userWithApartments;
using (var context = new ApartmentContext(options))
{
context.AddRange(_users);
await context.SaveChangesAsync();
userWithApartments = context.Users.AsNoTracking().FirstOrDefault();
foreach (var item in _addresses)
{
item.CountryId = context.Countries.FirstOrDefault().Id;
}
for (int i = 0; i < 2; i++)
{
_apartments[i].OwnerId = userWithApartments.Id;
_apartments[i].Address = _addresses[i];
}
context.AddRange(_apartments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var service = new ApartmentUserService(context, _mapper);
var apartmentsInBase = await context.Apartments.AsNoTracking().ToListAsync();
var userWithoutApartments = await context.Users.Where(_ => _.Id != userWithApartments.Id).FirstOrDefaultAsync();
var resultPositive = await service.GetAllApartmentByOwnerIdAsync(userWithApartments.Id.ToString(), new Common.PagedRequest());
var resultNegative = await service.GetAllApartmentByOwnerIdAsync(userWithoutApartments.Id.ToString(), new Common.PagedRequest());
foreach (var item in apartmentsInBase)
{
resultPositive.Data.Data
.Where(_ => _.Apartment.Id == item.Id.ToString())
.FirstOrDefault()
.Should().NotBeNull();
}
resultNegative.Data.Data.Should().BeEmpty();
}
}
public PicController(IWebHostEnvironment env,
IOptions <AppSettings> options,
ApartmentContext apartmentContext,
IPicService picService,
IPicServicesHandler picServicesHandler)
{
_env = env;
_options = options;
_apartmentContext = apartmentContext;
_picService = picService;
_picServicesHandler = picServicesHandler;
_picServicesHandler.Subscrib(_picService);
}
public async void DeleteApartmentByIdAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "DeleteApartmentByIdAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
await context.AddRangeAsync(_users);
await context.SaveChangesAsync();
var userWithApartments = context.Users.AsNoTracking().FirstOrDefault();
foreach (var item in _addresses)
{
item.CountryId = context.Countries.FirstOrDefault().Id;
}
for (int i = 0; i < 2; i++)
{
_apartments[i].OwnerId = userWithApartments.Id;
_apartments[i].Address = _addresses[i];
}
await context.AddRangeAsync(_apartments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var apartmenr = await context.Apartments.AsNoTracking().FirstOrDefaultAsync();
var service = new ApartmentUserService(context, _mapper);
var resultPositive = await service.DeleteApartmentByIdAsync(apartmenr.Id.ToString(), apartmenr.OwnerId.ToString());
var resultNegative = await service.DeleteApartmentByIdAsync(new Guid().ToString(), new Guid().ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Message.Should().BeNull();
resultNegative.IsSuccess.Should().BeFalse();
resultNegative.Message.Should().Contain("Apartment was not found");
}
}
public async void GetApartmentByIdAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "GetApartmentByIdAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
context.AddRange(_users);
await context.SaveChangesAsync();
var userWithApartments = context.Users.AsNoTracking().FirstOrDefault();
foreach (var item in _addresses)
{
item.CountryId = context.Countries.FirstOrDefault().Id;
}
for (int i = 0; i < 2; i++)
{
_apartments[i].OwnerId = userWithApartments.Id;
_apartments[i].Address = _addresses[i];
}
context.AddRange(_apartments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var apartment = await context.Apartments.AsNoTracking()
.Include(_ => _.Address.Country).FirstOrDefaultAsync();
var service = new ApartmentUserService(context, _mapper);
var resultPositive = await service.GetApartmentByIdAsync(apartment.Id.ToString());
var resultNegative = await service.GetApartmentByIdAsync(new Guid().ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Apartment.Title.Should().BeEquivalentTo(apartment.Title);
resultPositive.Data.Country.Name.Should().BeEquivalentTo(apartment.Address.Country.Name);
resultNegative.IsSuccess.Should().BeFalse();
resultNegative.Data.Should().BeNull();
}
}
public async void GetAllCommentsByApartmentIdAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "GetAllCommentsByApartmentIdAsync_PositiveAndNegative_TestAsync")
.Options;
Apartment apartmentWithComments;
using (var context = new ApartmentContext(options))
{
context.AddRange(_apartments);
await context.SaveChangesAsync();
apartmentWithComments = context.Apartments.AsNoTracking().FirstOrDefault();
foreach (var item in _comments)
{
item.ApartmentId = apartmentWithComments.Id;
}
context.AddRange(_comments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var service = new CommentAdministrationService(context, _mapper);
var commentsInBase = await context.Comments.AsNoTracking().ToListAsync();
var apartmentWithoutComments = context.Apartments.Where(_ => _.Id != apartmentWithComments.Id).FirstOrDefault();
var resultPositive = await service.GetAllCommentsByApartmentIdAsync(new PagedRequest <string>(apartmentWithComments.Id.ToString()));
var resultNegative = await service.GetAllCommentsByApartmentIdAsync(new PagedRequest <string>(apartmentWithoutComments.Id.ToString()));
foreach (var item in commentsInBase)
{
resultPositive.Data.Data
.Where(_ => _.Id == item.Id.ToString())
.FirstOrDefault()
.Should().NotBeNull();
}
resultNegative.Data.Data.Should().BeEmpty();
}
}
private UserController SetupDefaultController()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
using (var context = new ApartmentContext(options))
{
context.Users.Add(new User {
Id = 1,
Username = "******",
Password = "******",
PasswordSalt = Convert.FromBase64String("SEfcsflTemzwn2t/MP00Mw=="),
Role = Role.Admin
});
context.Users.Add(new User {
Id = 2,
Username = "******",
Password = "******",
PasswordSalt = Convert.FromBase64String("tYwvfcbNoAFjLOgwhYpGaQ=="),
Role = Role.Realtor
});
context.Users.Add(new User {
Id = 3,
Username = "******",
Password = "******",
PasswordSalt = Convert.FromBase64String("BAV88E56WMdNcAU5y7ZDfw=="),
Role = Role.Client
});
context.SaveChanges();
}
var appSettings = new AppSettings {
Secret = "This is a test Secret string"
};
var appSettingOptions = new Mock <IOptions <AppSettings> >();
appSettingOptions.SetupGet(a => a.Value).Returns(appSettings);
var mapper = new Mock <IMapper>();
var controller = new UserController(
new ApartmentContext(options),
appSettingOptions.Object,
mapper.Object);
return(controller);
}
public async void CreateApartmentAsync_Positive_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "CreateApartmentAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
context.AddRange(_users);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var service = new ApartmentUserService(context, _mapper);
User user = await context.Users.FirstOrDefaultAsync();
AddAddress address = new AddAddress()
{
CountryId = context.Countries.FirstOrDefault().Id.ToString(),
City = "MyCity",
Street = "Street",
Home = "Home",
NumberOfApartment = 1
};
AddApartment apartmentOk = new AddApartment()
{
Address = address,
Area = 54,
IsOpen = true,
Price = 15M,
Title = "Apartment",
Text = "AddedApartment",
NumberOfRooms = 2
};
var resultPositive = await service.CreateApartmentAsync(apartmentOk, user.Id.ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Country.Id.Should().BeEquivalentTo(address.CountryId);
resultPositive.Data.Address.Street.Should().BeEquivalentTo(address.Street);
resultPositive.Data.Apartment.Title.Should().BeEquivalentTo(apartmentOk.Title);
}
}
public async void UpdateCommentAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "UpdateCommentAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
context.AddRange(_comments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var comment = await context.Comments.AsNoTracking().FirstOrDefaultAsync();
var service = new CommentAdministrationService(context, _mapper);
CommentDTOAdministration updateComment = new CommentDTOAdministration()
{
Id = comment.Id.ToString(),
Title = "newTitle",
Text = "newText"
};
CommentDTOAdministration failComment = new CommentDTOAdministration()
{
Id = new Guid().ToString(),
Title = "newTitle",
Text = "newText"
};
var resultPositive = await service.UpdateCommentAsync(updateComment);
var resultNegative = await service.UpdateCommentAsync(failComment);
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Title.Should().BeEquivalentTo(updateComment.Title);
resultPositive.Data.Title.Should().NotBeEquivalentTo(comment.Title);
resultNegative.IsSuccess.Should().BeFalse();
}
}
