public async void GetMultipleResourceUsage()
{
var options = TestUtil.GetMemDbOptions("GetsMultipleResourceUsage");
Tenant tenant;
BillingPeriod period;
using (var db = new AptMgmtDbContext(options))
{
var repo = (ITenant) new TenantRepository(db);
tenant = TestUtil.NewTenant(db);
TestUtil.UseResource(db, tenant.TenantId, 5, ResourceType.Power);
TestUtil.UseResource(db, tenant.TenantId, 10, ResourceType.Water);
period = TestUtil.NewBillingPeriod(db);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IBill) new BillRepository(db);
var allUsage = await repo.GetResourceUsage(tenant.TenantId, period);
Assert.Equal(2, allUsage.Count());
var powerUsage = allUsage.Where(u => u.ResourceType == ResourceType.Power).FirstOrDefault();
Assert.Equal(5, powerUsage.Usage);
var waterUsage = allUsage.Where(u => u.ResourceType == ResourceType.Water).FirstOrDefault();
Assert.Equal(10, waterUsage.Usage);
}
}
public async void EditsPersonalInfo()
{
var options = TestUtil.GetMemDbOptions("EditsTenantInfo");
AptMgmtPortalAPI.DTO.TenantInfoDTO tenant;
using (var db = new AptMgmtDbContext(options))
{
var repo = (ITenant) new TenantRepository(db);
var tenantInfo = new AptMgmtPortalAPI.DTO.TenantInfoDTO();
tenantInfo.FirstName = "original first name";
tenant = await repo.AddTenant(tenantInfo);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (ITenant) new TenantRepository(db);
var newName = "new first name";
var tenantInfo = new AptMgmtPortalAPI.DTO.TenantInfoDTO();
tenantInfo.FirstName = newName;
var newInfo = await repo.UpdateTenantInfo(tenant.TenantId, tenantInfo);
Assert.Equal(newName, newInfo.FirstName);
}
}
public async void BuildsDTO()
{
var options = TestUtil.GetMemDbOptions("OpensMaintenanceRequest");
AptMgmtPortalAPI.DTO.MaintenanceRequestDTO dto;
AptMgmtPortalAPI.Entity.MaintenanceRequest req;
using (var db = new AptMgmtDbContext(options))
{
var mock = new Mock <ILogger <UserRepository> >();
ILogger <UserRepository> logger = mock.Object;
User user = TestUtil.NewUser(db);
var repo = (IUser) new UserRepository(logger, db);
req = new AptMgmtPortalAPI.Entity.MaintenanceRequest();
req.MaintenanceRequestId = 999;
req.OpeningUserId = user.UserId;
db.Add(req);
db.SaveChanges();
dto = await AptMgmtPortalAPI.DTO.MaintenanceRequestDTO.Build(req, repo);
}
Assert.Equal(req.MaintenanceRequestId, dto.MaintenanceRequestId);
}
public async void EditsUserInfo()
{
var options = TestUtil.GetMemDbOptions("EditsUserInfo");
var mock = new Mock <ILogger <UserRepository> >();
AptMgmtPortalAPI.Entity.User user;
using (var db = new AptMgmtDbContext(options))
{
var repo = (IUser) new UserRepository(mock.Object, db);
var userInfoandTenant = TestUtil.UserInfoAndTenantForUserRepo(db);
user = await repo.NewUser(userInfo : userInfoandTenant.Item1);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IUser) new UserRepository(mock.Object, db);
var newName = "new first name";
var userInfo = new AptMgmtPortalAPI.DTO.UserDTO
{
UserId = user.UserId,
FirstName = newName,
LoginName = user.LoginName,
Password = user.Password
};
var newInfo = await repo.UpdateUserInfo(userInfo);
Assert.Equal(newName, newInfo.FirstName);
}
}
public async void GetsSingleBill()
{
var options = TestUtil.GetMemDbOptions("GetsSingleBill");
const double rate = 3;
Tenant tenant;
BillingPeriod period;
using (var db = new AptMgmtDbContext(options))
{
var repo = (ITenant) new TenantRepository(db);
tenant = TestUtil.NewTenant(db);
TestUtil.UseResource(db, tenant.TenantId, 5, ResourceType.Power);
TestUtil.UseResource(db, tenant.TenantId, 5, ResourceType.Power);
period = TestUtil.NewBillingPeriod(db);
TestUtil.NewResourceRate(db, rate, ResourceType.Power, period);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IBill) new BillRepository(db);
var bill = await repo.GetBill(tenant.TenantId, ResourceType.Power, period);
Assert.Equal(rate * 10, bill.Owed());
}
}
public async void PaysBillWithRawId()
{
var options = TestUtil.GetMemDbOptions("PaysBillWithRawId");
const double rate = 1;
Tenant tenant;
BillingPeriod period;
using (var db = new AptMgmtDbContext(options))
{
var repo = (IBill) new BillRepository(db);
tenant = TestUtil.NewTenant(db);
TestUtil.UseResource(db, tenant.TenantId, 5, ResourceType.Power);
TestUtil.UseResource(db, tenant.TenantId, 5, ResourceType.Power);
period = TestUtil.NewBillingPeriod(db);
TestUtil.NewResourceRate(db, rate, ResourceType.Power, period);
var payment = repo.PayBill(tenant.TenantId, 3, ResourceType.Power, period.BillingPeriodId);
db.SaveChanges();
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IBill) new BillRepository(db);
var bill = await repo.GetBill(tenant.TenantId, ResourceType.Power, period);
Assert.Equal(3, bill.Paid);
Assert.Equal(rate * 7, bill.Owed());
Assert.Equal(rate, bill.Rate);
}
}
public async void Login()
{
var options = TestUtil.GetMemDbOptions("TestLoginMethod");
var mock = new Mock <ILogger <UserRepository> >();
AptMgmtPortalAPI.Entity.User user;
using (var db = new AptMgmtDbContext(options))
{
var repo = (IUser) new UserRepository(mock.Object, db);
var userInfoandTenant = TestUtil.UserInfoAndTenantForUserRepo(db);
user = await repo.NewUser(userInfo : userInfoandTenant.Item1);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IUser) new UserRepository(mock.Object, db);
var userLogin = new User
{
LoginName = "testuser",
Password = "******"
};
var checkLogin = await repo.Login(userLogin.LoginName, userLogin.Password);
Assert.Equal(user.LoginName, checkLogin.LoginName);
Assert.Equal(user.Password, checkLogin.Password);
}
}
public async void GetsResourceRates()
{
var options = TestUtil.GetMemDbOptions("GetsResourceRate");
const double powerRate = 3;
const double waterRate = 5;
BillingPeriod period;
ResourceUsageRate powerRateObj;
ResourceUsageRate waterRateObj;
using (var db = new AptMgmtDbContext(options))
{
period = TestUtil.NewBillingPeriod(db);
powerRateObj = TestUtil.NewResourceRate(db, powerRate, ResourceType.Power, period);
waterRateObj = TestUtil.NewResourceRate(db, waterRate, ResourceType.Water, period);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IBill) new BillRepository(db);
var rates = await repo.GetResourceUsageRates(period);
var powerRateFromDb = rates.Where(r => r.ResourceType == ResourceType.Power)
.Select(r => r)
.First();
Assert.Equal(powerRateObj.Rate, powerRateFromDb.Rate);
var waterRateFromDb = rates.Where(r => r.ResourceType == ResourceType.Water)
.Select(r => r)
.First();
Assert.Equal(waterRateObj.Rate, waterRateFromDb.Rate);
}
}
public async void SignsAgreement()
{
var options = TestUtil.GetMemDbOptions("SignsAgreement");
Tenant tenant;
Agreement agreement;
AptMgmtPortalAPI.DataModel.Agreement signedAgreement;
using (var db = new AptMgmtDbContext(options))
{
var repo = (IAgreement) new AgreementRepository(db);
tenant = TestUtil.NewTenant(db);
agreement = TestUtil.NewAgreement(db, "test-agreement1");
signedAgreement = await repo.SignAgreement(tenant.TenantId,
agreement.AgreementId,
DateTime.Now,
DateTime.Now);
}
using (var db = new AptMgmtDbContext(options))
{
Assert.Equal("test-agreement1", signedAgreement.Title);
var repo = (IAgreement) new AgreementRepository(db);
var signedAgreements = await repo.GetSignedAgreements(tenant.TenantId);
Assert.Single(signedAgreements);
Assert.Equal("test-agreement1", signedAgreements.FirstOrDefault().Title);
}
}
public async void GetsResourceUsage()
{
var options = TestUtil.GetMemDbOptions("GetsResourceUsage");
Tenant tenant;
BillingPeriod period;
using (var db = new AptMgmtDbContext(options))
{
var repo = (ITenant) new TenantRepository(db);
tenant = TestUtil.NewTenant(db);
TestUtil.UseResource(db, tenant.TenantId, 5, ResourceType.Power);
TestUtil.UseResource(db, tenant.TenantId, 5, ResourceType.Power);
period = TestUtil.NewBillingPeriod(db);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IBill) new BillRepository(db);
var usage = await repo.GetResourceUsage(tenant.TenantId, ResourceType.Power, period);
Assert.Equal(10, usage.Usage);
}
}
public async void OpensMaintenanceRequest()
{
var options = TestUtil.GetMemDbOptions("OpensMaintenanceRequest");
User user;
MaintenanceRequest maintRequest;
using (var db = new AptMgmtDbContext(options))
{
user = TestUtil.NewUser(db);
var repo = (IMaintenance) new MaintenanceRepository(db);
var requestData = new AptMgmtPortalAPI.DataModel.MaintenanceRequestModel();
requestData.OpenNotes = "notes";
requestData.UnitNumber = "unit";
requestData.MaintenanceRequestType = MaintenanceRequestType.Plumbing;
maintRequest = await repo.OpenMaintenanceRequest(user.UserId, requestData);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IMaintenance) new MaintenanceRepository(db);
var requests = await repo.GetOpenMaintenanceRequests("unit");
Assert.Single(requests);
Assert.Equal(maintRequest.MaintenanceRequestId, requests.FirstOrDefault().MaintenanceRequestId);
}
}
public static Tenant NewTenant(AptMgmtDbContext context)
{
var tenant = new Tenant();
context.Add(tenant);
context.SaveChanges();
return(tenant);
}
public static User NewUser(AptMgmtDbContext context)
{
var user = new User();
context.Add(user);
context.SaveChanges();
return(user);
}
public static Unit NewUnit(AptMgmtDbContext context)
{
var unit = new Unit();
unit.UnitNumber = "3111";
unit.TenantId = TestUtil.NewTenant(context).TenantId;
context.Add(unit);
context.SaveChanges();
return(unit);
}
public static User NewUserWithAnAPIKey(AptMgmtDbContext context)
{
var user = new User
{
ApiKey = "test-key100"
};
context.Add(user);
context.SaveChanges();
return(user);
}
public static Tenant NewTenant(AptMgmtDbContext context)
{
var tenant = new Tenant();
tenant.FirstName = "testFirstName";
tenant.Email = "*****@*****.**";
tenant.UserId = TestUtil.NewUser(context).UserId;
context.Add(tenant);
context.SaveChanges();
return(tenant);
}
public static AptMgmtPortalAPI.DTO.UserDTO NewUserDtoWithCredential(AptMgmtDbContext context)
{
var userDto = new AptMgmtPortalAPI.DTO.UserDTO
{
FirstName = "original first name",
LoginName = "testUser",
Password = "******"
};
return(userDto);
}
public static AgreementTemplate NewAgreement(AptMgmtDbContext context, string title)
{
var agreement = new AgreementTemplate();
agreement.Title = title;
context.Add(agreement);
context.SaveChanges();
return(agreement);
}
public static Unit NewUnit(AptMgmtDbContext context, string unitNumber)
{
var unit = new Unit();
unit.UnitNumber = unitNumber;
context.Add(unit);
context.SaveChanges();
return(unit);
}
public static Payment NewPayment(AptMgmtDbContext context, int tenantId)
{
var payment = new Payment();
payment.TenantId = tenantId;
context.Add(payment);
context.SaveChanges();
return(payment);
}
public async void CancelsMaintenanceRequest()
{
var options = TestUtil.GetMemDbOptions("CancelsMaintenanceRequest");
var unitNumber = "test unit";
User user;
Tenant tenant;
MaintenanceRequest maintRequest;
Unit unit;
using (var db = new AptMgmtDbContext(options))
{
user = TestUtil.NewUser(db);
var maintenanceRepo = (IMaintenance) new MaintenanceRepository(db);
var requestData = new AptMgmtPortalAPI.DataModel.MaintenanceRequestModel();
requestData.OpenNotes = "notes";
requestData.UnitNumber = unitNumber;
requestData.MaintenanceRequestType = MaintenanceRequestType.Plumbing;
maintRequest = await maintenanceRepo.OpenMaintenanceRequest(user.UserId, requestData);
tenant = TestUtil.NewTenant(db);
tenant.UserId = user.UserId;
db.SaveChanges();
// Maintenance requests are assigned to units, but may be opened by any user of
// the application. This means the occupying tenant may open a maintenance request,
// but only if they have a UserId, and a Manager may also open a maintenance request
// on behalf of a Tenant of User.
//
// In order to cancel a maintenance request, we must have a way to determine if
// the User is indeed the Tenant of the request. This is accomplished by checking
// if the user is occupying the unit, and if so, they will be permitted to cancel
// the request.
var tenantRepo = (ITenant) new TenantRepository(db);
unit = TestUtil.NewUnit(db, unitNumber);
await tenantRepo.AssignToUnit(tenant.TenantId, unitNumber);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IMaintenance) new MaintenanceRepository(db);
var canceled = await repo.CancelMaintenanceRequest(user.UserId,
maintRequest.MaintenanceRequestId,
"test cancel");
Assert.NotNull(canceled.TimeClosed);
var requests = await repo.GetOpenMaintenanceRequests(unit.UnitNumber);
Assert.Empty(requests);
}
}
public async void GetsPaymentsOfResourceType()
{
var options = TestUtil.GetMemDbOptions("GetsPaymentsOfResourceType");
Tenant tenant;
Payment payment;
BillingPeriod period;
using (var db = new AptMgmtDbContext(options))
{
period = TestUtil.NewBillingPeriod(db);
tenant = TestUtil.NewTenant(db);
var repo = (ITenant) new TenantRepository(db);
payment = TestUtil.NewPayment(db, tenant.TenantId);
payment.ResourceType = ResourceType.Power;
payment.BillingPeriodId = period.BillingPeriodId;
payment.Amount = 12;
// We will query for power payment (above). This should not appear.
var waterPayment = TestUtil.NewPayment(db, tenant.TenantId);
waterPayment.ResourceType = ResourceType.Water;
waterPayment.BillingPeriodId = period.BillingPeriodId;
waterPayment.Amount = 6;
// This is a power payment, but is for a different period.
var outOfPeriodPayment = TestUtil.NewPayment(db, tenant.TenantId);
outOfPeriodPayment.ResourceType = ResourceType.Power;
outOfPeriodPayment.Amount = 10;
var oldPeriod = TestUtil.NewBillingPeriod(db);
oldPeriod.PeriodStart = DateTime.Now - new TimeSpan(22, 0, 0, 0);
oldPeriod.PeriodEnd = DateTime.Now - new TimeSpan(20, 0, 0, 0);
outOfPeriodPayment.BillingPeriodId = oldPeriod.BillingPeriodId;
db.SaveChanges();
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (IBill) new BillRepository(db);
var paymentsFromDb = await repo.GetPayments(tenant.TenantId, ResourceType.Power, period);
Assert.Single(paymentsFromDb);
var powerPayment = paymentsFromDb.Single();
Assert.Equal(12, powerPayment.Amount);
}
}
public static DbContextOptions <AptMgmtDbContext> GetMemDbOptions(string dbName)
{
var sqlite = new SqliteConnection("Filename=:memory:");
sqlite.Open();
var options = new DbContextOptionsBuilder <AptMgmtDbContext>()
.UseSqlite(sqlite)
.Options;
using (var db = new AptMgmtDbContext(options))
{
db.Database.Migrate();
}
return(options);
}
public static BillingPeriod NewBillingPeriod(AptMgmtDbContext context)
{
var period = new BillingPeriod();
var timeSpan = new TimeSpan(0, 0, 5);
// All test data is 2 years into the future.
var testPeriod = new TimeSpan(730, 0, 0, 0);
period.PeriodStart = DateTime.Now + testPeriod - timeSpan;
period.PeriodEnd = DateTime.Now + testPeriod + timeSpan;
context.Add(period);
context.SaveChanges();
return(period);
}
public async void DeleteUnit()
{
var options = TestUtil.GetMemDbOptions("DeleteUnit");
Unit unit = new Unit();
using (var db = new AptMgmtDbContext(options))
{
unit = TestUtil.NewUnit(db);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (ITenant) new TenantRepository(db);
var unitDel = await repo.DeleteUnit(unit.TenantId ?? default);
Assert.True(unitDel);
}
}
public async void GetUnitById()
{
var options = TestUtil.GetMemDbOptions("UnitFromId");
Unit unit;
using (var db = new AptMgmtDbContext(options))
{
unit = TestUtil.NewUnit(db);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (ITenant) new TenantRepository(db);
var unitById = await repo.GetUnit(unit.UnitId);
Assert.Equal(unitById.UnitId, unit.UnitId);
}
}
public async void QueryUnitByNumber()
{
var options = TestUtil.GetMemDbOptions("UnitByNumber");
Unit unit;
using (var db = new AptMgmtDbContext(options))
{
unit = TestUtil.NewUnit(db);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (ITenant) new TenantRepository(db);
var unitByNumber = await repo.QueryUnitByNumber(unit.UnitNumber);
Assert.Equal(unitByNumber.UnitNumber, unit.UnitNumber);
}
}
public static ResourceUsageRate NewResourceRate(AptMgmtDbContext context,
double rate,
ResourceType resource,
BillingPeriod period)
{
var newRate = new ResourceUsageRate();
newRate.PeriodStart = period.PeriodStart;
newRate.PeriodEnd = period.PeriodEnd;
newRate.Rate = rate;
newRate.ResourceType = resource;
context.Add(newRate);
context.SaveChanges();
return(newRate);
}
public async void TenantFromUserId()
{
var options = TestUtil.GetMemDbOptions("TenantFromUserId");
Tenant tenant;
using (var db = new AptMgmtDbContext(options))
{
tenant = TestUtil.NewTenant(db);
}
using (var db = new AptMgmtDbContext(options))
{
var repo = (ITenant) new TenantRepository(db);
var getTenant = await repo.TenantFromUserId(tenant.UserId ?? default);
Assert.Equal(tenant.UserId, getTenant.UserId);
}
}
public static Agreement SignAgreement(AptMgmtDbContext context, int agreementId, int tenantId)
{
// All test data is 2 years into the future.
var testPeriod = new TimeSpan(730, 0, 0, 0);
var signedAgreement = new Agreement();
signedAgreement.TenantId = tenantId;
signedAgreement.AgreementTemplateId = agreementId;
signedAgreement.SignedDate = DateTime.Now;
signedAgreement.StartDate = DateTime.Now + testPeriod - new TimeSpan(0, 0, 5);
signedAgreement.EndDate = DateTime.Now + testPeriod + new TimeSpan(0, 0, 5);
context.Add(signedAgreement);
context.SaveChanges();
return(signedAgreement);
}
