public async Task TestCreateInvalidUser()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
IPService iPService = new IPService(context);
ACMUser user = new ACMUser {
UserName = "******", FullName = "gosho"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
IpDTO model = new IpDTO(null, "123.123.123...");
await Assert.ThrowsAsync <ACMException>(() => iPService.Create(model));
}
public async Task TestCreateInvalidUser()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
HomeownerSevice homeownerSevice = new HomeownerSevice(context);
ACMUser user = new ACMUser {
Email = "*****@*****.**"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
await Assert.ThrowsAsync <ACMException>(()
=> homeownerSevice.Create("beer", "NOT [email protected]"));
}
public async Task TestDeleteMeetingGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
MeetingsService meetingsService = new MeetingsService(context);
string id = await CreateAMeeting(context);
string id2 = await CreateAMeeting(context);
bool output = await meetingsService.DeleteMeeting(id);
Assert.True(output);
Assert.Single(context.Meetings.ToList());
Assert.Equal(3, context.Votes.ToList().Count);
Assert.True(context.Meetings.Any(x => x.Id == id2));
}
public async Task TestGenerateCodeGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
UserService userService = new UserService(context);
ACMUser user = new ACMUser {
UserName = "******"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
string code = await userService.GenerateCode("gosho");
Assert.True(context.Users.Any(x => x.ExpectedCode == code));
}
public async Task TestIsCodeValidFalse()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
CodeService codeService = new CodeService(context);
RegistrationCode code = new RegistrationCode {
Code = "code1"
};
await context.RegistrationCodes.AddAsync(code);
await context.SaveChangesAsync();
bool output = codeService.IsCodeValid("code2");
Assert.False(output);
}
public async Task TestIsUserValidinvalidUser()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
UserService userService = new UserService(context);
ACMUser user = new ACMUser {
Email = "gosho"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
bool output = userService.IsUserValid("Not gosho");
Assert.False(output);
}
public async Task TestGetApartmentNumberInvalidUser()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
UserService userService = new UserService(context);
ACMUser user = new ACMUser {
Email = "gosho", AppartentNumber = 1
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
Action act = () => userService.GetApartmentNumber("Not gosho");
Assert.Throws <ACMException>(act);
}
public async Task TestIsCodeValidInvalidCode()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
UserService userService = new UserService(context);
ACMUser user = new ACMUser {
UserName = "******", ExpectedCode = "1"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
bool output = userService.IsCodeValid("2", "gosho");
Assert.False(output);
}
public async Task TestGetApartmentNumberGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
UserService userService = new UserService(context);
ACMUser user = new ACMUser {
Email = "gosho", AppartentNumber = 1
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
int output = userService.GetApartmentNumber("gosho");
Assert.True(context.Users.Any(x => x.AppartentNumber == output));
}
public async Task TestAdminDeleteIdeaGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
HomeownerSevice homeownerSevice = new HomeownerSevice(context);
Idea idea = new Idea {
Id = "1"
};
await context.AddAsync(idea);
await context.SaveChangesAsync();
bool output = await homeownerSevice.AdminDeleteIdea("1");
Assert.True(output);
Assert.Empty(context.Ideas.ToList());
}
public async Task TestGetOneUserGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
UserService userService = new UserService(context);
ACMUser user = new ACMUser {
Email = "gosho"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
ACMUser output = userService.GetOneUser("gosho");
Assert.NotNull(output);
Assert.Equal("gosho", output.Email);
}
public async Task TestDeleteSpendingInvalidId()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
SpendingService spendingService = new SpendingService(context);
Spending spending = new Spending
{
Amount = 10,
Text = "beer",
IsPayed = true
};
await context.Spendings.AddAsync(spending);
await context.SaveChangesAsync();
await Assert.ThrowsAsync <ACMException>(()
=> spendingService.DeleteSpending(spending.Id + "Random string"));
}
public async Task TestCreateARegistrationCodeGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
CodeService codeService = new CodeService(context);
Apartment apartment1 = new Apartment {
Number = 1
};
await context.Apartments.AddAsync(apartment1);
await context.SaveChangesAsync();
CodeDTO code = await codeService.CreateARegistrationCode("1");
Assert.Single(context.RegistrationCodes.ToList());
Assert.Equal(1, context.RegistrationCodes.FirstOrDefault().Apartment.Number);
Assert.Equal(code.Code, context.RegistrationCodes.FirstOrDefault().Code);
}
public async Task TestCreateSpending()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
SpendingService spendingService = new SpendingService(context);
SpendingDTO model = new SpendingDTO
{
Amount = 10,
Text = "beer",
IsPayed = true
};
string id = await spendingService.CreateSpending(model);
Assert.Single(context.Spendings.ToList());
Assert.True(context.Spendings.Any(x => x.Id == id));
Assert.Equal("beer", context.Spendings.Where(x => x.Id == id).FirstOrDefault().Text);
Assert.Equal(10, context.Spendings.Where(x => x.Id == id).FirstOrDefault().Amount);
Assert.True(context.Spendings.Where(x => x.Id == id).FirstOrDefault().IsPayed);
}
public async Task TestAddIpGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
IPService iPService = new IPService(context);
ACMUser user = new ACMUser {
UserName = "******", FullName = "gosho"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
string output = await iPService.AddNewIp("*****@*****.**", "123.123.123...");
Assert.Single(context.IPs.ToList());
Assert.True(context.IPs.Any(x => x.Id == output));
Assert.Equal("*****@*****.**", context.IPs.FirstOrDefault().User.UserName);
Assert.Equal("123.123.123...", context.IPs.FirstOrDefault().IpString);
}
public async Task TestBillOneApartmentGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
BillService billService = new BillService(context);
Apartment apartment1 = new Apartment {
Number = 1
};
await context.Apartments.AddAsync(apartment1);
await context.SaveChangesAsync();
string billId = await billService.BillOneApartment("1", "beer", 10);
Assert.Equal(1, context.Bills.Count());
Assert.Equal(billId, context.Bills.ToList()[0].Id);
Assert.Equal(10, context.Bills.ToList()[0].Amount);
Assert.Equal("beer", context.Bills.ToList()[0].Text);
}
public async Task TestGetAllMeetingsGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
MeetingsService meetingsService = new MeetingsService(context);
string id1 = await CreateAMeeting(context);
string id2 = await CreateAMeeting(context);
List <MeetingsListDTO> output = meetingsService.GetAllMeetings();
Assert.Equal(2, output.Count);
Assert.Equal(3, output[0].NumberOfVotes);
Assert.Equal("beer", output[0].Text);
Assert.Equal(id2, output[0].Id);
Assert.Equal(3, output[1].NumberOfVotes);
Assert.Equal("beer", output[1].Text);
Assert.Equal(id1, output[1].Id);
}
public async Task TestDeleteSpendingGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
SpendingService spendingService = new SpendingService(context);
Spending spending = new Spending
{
Amount = 10,
Text = "beer",
IsPayed = true
};
await context.Spendings.AddAsync(spending);
await context.SaveChangesAsync();
bool output = await spendingService.DeleteSpending(spending.Id);
Assert.True(output);
Assert.Empty(context.Spendings.ToList());
}
public async Task TestDeleteBillWithInvalidId()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
BillService billService = new BillService(context);
Apartment apartment1 = new Apartment {
Number = 1
};
Bill bill = new Bill {
Amount = 10, Apartment = apartment1, Text = "beer"
};
await context.Apartments.AddAsync(apartment1);
await context.Bills.AddAsync(bill);
await context.SaveChangesAsync();
await Assert.ThrowsAsync <ACMException>(() => billService.DeleteBill(bill.Id + "Random String"));
Assert.Equal(1, context.Bills.Count());
}
public async Task TestGetOneMeetingGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
MeetingsService meetingsService = new MeetingsService(context);
string id = await CreateAMeeting(context);
MeetingDetailsDTO output = meetingsService.GetOneMeeting(id);
Assert.Equal(id, output.Id);
Assert.Equal("beer", output.Text);
Assert.Equal("text1", output.Votes[0].Text);
Assert.Equal(1, output.Votes[0].Yes);
Assert.Equal(1, output.Votes[0].No);
Assert.Equal("text2", output.Votes[1].Text);
Assert.Equal(2, output.Votes[1].Yes);
Assert.Equal(2, output.Votes[1].No);
Assert.Equal("text3", output.Votes[2].Text);
Assert.Equal(3, output.Votes[2].Yes);
Assert.Equal(3, output.Votes[2].No);
}
public async Task TestGetWallOfShameListGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
BillService billService = new BillService(context);
Apartment apartment1 = new Apartment {
Number = 1
};
Apartment apartment2 = new Apartment {
Number = 2
};
Bill bill1 = new Bill
{
Amount = 10,
Apartment = apartment1,
Text = "beer",
IsPayed = false,
};
Bill bill2 = new Bill
{
Amount = 1,
Apartment = apartment1,
Text = "beer2",
IsPayed = false,
};
await context.Apartments.AddAsync(apartment1);
await context.Apartments.AddAsync(apartment2);
await context.Bills.AddAsync(bill1);
await context.Bills.AddAsync(bill2);
await context.SaveChangesAsync();
List <WallOfShameElementDTO> list = billService.GetWallOfShameList();
Assert.Single(list);
Assert.Equal(11, list[0].Amount);
Assert.Equal(2, list[0].NumberOfUnpaidBills);
Assert.Equal(1, list[0].ApartmentNumber);
}
public async Task TestGetOneSpendingGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
SpendingService spendingService = new SpendingService(context);
Spending spending = new Spending
{
Amount = 10,
Text = "beer",
IsPayed = true
};
await context.Spendings.AddAsync(spending);
await context.SaveChangesAsync();
SpendingDTO output = spendingService.GetOneSpending(spending.Id);
Assert.Equal(spending.Id, output.Id);
Assert.Equal(10, output.Amount);
Assert.Equal("beer", output.Text);
Assert.True(output.IsPayed);
}
public async Task TestDeleteBillWithGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
BillService billService = new BillService(context);
Apartment apartment1 = new Apartment {
Number = 1
};
Bill bill = new Bill {
Amount = 10, Apartment = apartment1, Text = "beer"
};
await context.Apartments.AddAsync(apartment1);
await context.Bills.AddAsync(bill);
await context.SaveChangesAsync();
bool output = await billService.DeleteBill(bill.Id);
Assert.True(output);
Assert.Equal(0, context.Bills.Count());
}
public async Task TestFinancialSummaryEmptyBills()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
SummaryService summaryService = new SummaryService(context);
Apartment apartment1 = new Apartment { Number = 1 };
Apartment apartment2 = new Apartment { Number = 2 };
Apartment apartment3 = new Apartment { Number = 3 };
Apartment apartment4 = new Apartment { Number = 4 };
Spending spending1 = new Spending { Amount = 100, Text = "beer1", IsPayed = true };
Spending spending2 = new Spending { Amount = 200, Text = "beer2", IsPayed = true };
Spending spending3 = new Spending { Amount = 300, Text = "beer3", IsPayed = false };
Spending spending4 = new Spending { Amount = 400, Text = "beer4", IsPayed = false };
await context.Apartments.AddAsync(apartment1);
await context.Apartments.AddAsync(apartment2);
await context.Apartments.AddAsync(apartment3);
await context.Apartments.AddAsync(apartment4);
await context.Spendings.AddAsync(spending1);
await context.Spendings.AddAsync(spending2);
await context.Spendings.AddAsync(spending3);
await context.Spendings.AddAsync(spending4);
await context.SaveChangesAsync();
FinancialSummaryDTO output = summaryService.FinancialSummary();
Assert.Equal(4, output.GoodHomeowners.Count);
Assert.Empty(output.BadHomeowners);
Assert.Equal(2, output.PaidSpendings.Count);
Assert.Equal(100, output.PaidSpendings[1].Amount);
Assert.Equal("beer1", output.PaidSpendings[1].Text);
Assert.Equal(200, output.PaidSpendings[0].Amount);
Assert.Equal("beer2", output.PaidSpendings[0].Text);
Assert.Equal(2, output.UnpaidSpendings.Count);
Assert.Equal(300, output.UnpaidSpendings[1].Amount);
Assert.Equal("beer3", output.UnpaidSpendings[1].Text);
Assert.Equal(400, output.UnpaidSpendings[0].Amount);
Assert.Equal("beer4", output.UnpaidSpendings[0].Text);
Assert.Equal(0, output.Paid);
Assert.Equal(0, output.ToBePaid);
Assert.Equal(300, output.Spend);
Assert.Equal(700, output.ToBeSpend);
Assert.Equal(-1000, output.CurrentBalance);
}
public async Task TestFinancialSummaryEmptySpendings()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
SummaryService summaryService = new SummaryService(context);
Apartment apartment1 = new Apartment { Number = 1 };
Apartment apartment2 = new Apartment { Number = 2 };
Apartment apartment3 = new Apartment { Number = 3 };
Apartment apartment4 = new Apartment { Number = 4 };
Bill bill1 = new Bill { Amount = 10, Apartment = apartment1, IsPayed = true };
Bill bill2 = new Bill { Amount = 20, Apartment = apartment2, IsPayed = true };
Bill bill3 = new Bill { Amount = 30, Apartment = apartment3, IsPayed = false };
Bill bill4 = new Bill { Amount = 40, Apartment = apartment4, IsPayed = false };
await context.Apartments.AddAsync(apartment1);
await context.Apartments.AddAsync(apartment2);
await context.Apartments.AddAsync(apartment3);
await context.Apartments.AddAsync(apartment4);
await context.Bills.AddAsync(bill1);
await context.Bills.AddAsync(bill2);
await context.Bills.AddAsync(bill3);
await context.Bills.AddAsync(bill4);
await context.SaveChangesAsync();
FinancialSummaryDTO output = summaryService.FinancialSummary();
Assert.Equal(2, output.GoodHomeowners.Count);
Assert.Equal(1, output.GoodHomeowners[0].ApartmentNumber);
Assert.Equal(0, output.GoodHomeowners[0].Amount);
Assert.Equal(2, output.GoodHomeowners[1].ApartmentNumber);
Assert.Equal(0, output.GoodHomeowners[1].Amount);
Assert.Equal(2, output.BadHomeowners.Count);
Assert.Equal(3, output.BadHomeowners[1].ApartmentNumber);
Assert.Equal(30, output.BadHomeowners[1].Amount);
Assert.Equal(4, output.BadHomeowners[0].ApartmentNumber);
Assert.Equal(40, output.BadHomeowners[0].Amount);
Assert.Empty(output.PaidSpendings);
Assert.Empty(output.UnpaidSpendings);
Assert.Equal(30, output.Paid);
Assert.Equal(70, output.ToBePaid);
Assert.Equal(0, output.Spend);
Assert.Equal(0, output.ToBeSpend);
Assert.Equal(100, output.CurrentBalance);
}
public async Task TestIsNewIpFalse()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
IPService iPService = new IPService(context);
ACMUser user = new ACMUser {
UserName = "******", FullName = "gosho"
};
IP iP = new IP
{
IpString = "123.123.123...",
User = user
};
await context.Users.AddAsync(user);
await context.IPs.AddAsync(iP);
await context.SaveChangesAsync();
bool output = iPService.IsNewIp(user.UserName, "123.123.123...");
Assert.False(output);
}
public async Task TestPayBillBadId()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
BillService billService = new BillService(context);
Apartment apartment1 = new Apartment {
Number = 1
};
Bill bill1 = new Bill
{
Amount = 10,
Apartment = apartment1,
Text = "beer",
IsPayed = false,
};
await context.Apartments.AddAsync(apartment1);
await context.Bills.AddAsync(bill1);
await context.SaveChangesAsync();
await Assert.ThrowsAsync <ACMException>(() => billService.PayBill(bill1.Id + "Random string"));
}
public async Task TestGetAppartmentsWithGoodData()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
ApartmentService apartmentService = new ApartmentService(context);
Apartment apartment1 = new Apartment {
Number = 1
};
Apartment apartment2 = new Apartment {
Number = 2
};
await context.Apartments.AddAsync(apartment1);
await context.Apartments.AddAsync(apartment2);
await context.SaveChangesAsync();
List <Models.ApartmentListElementDTO> list = apartmentService.GetAppartments();
Assert.Equal(2, list.Count);
Assert.Equal("1", list[0].Number);
Assert.Equal("2", list[1].Number);
}
public async Task TestGetWallOfShameListAllBillsArePaid()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
BillService billService = new BillService(context);
Apartment apartment1 = new Apartment {
Number = 1
};
Apartment apartment2 = new Apartment {
Number = 2
};
Bill bill1 = new Bill
{
Amount = 10,
Apartment = apartment1,
Text = "beer",
IsPayed = true,
};
Bill bill2 = new Bill
{
Amount = 1,
Apartment = apartment1,
Text = "beer2",
IsPayed = true,
};
await context.Apartments.AddAsync(apartment1);
await context.Apartments.AddAsync(apartment2);
await context.Bills.AddAsync(bill1);
await context.Bills.AddAsync(bill2);
await context.SaveChangesAsync();
List <WallOfShameElementDTO> list = billService.GetWallOfShameList();
Assert.Empty(list);
}
public async Task TestEditSpedningInvalidId()
{
ACMDbContext context = ACMDbContextInMemoryFactory.InitializeContext();
SpendingService spendingService = new SpendingService(context);
Spending spending = new Spending
{
Amount = 10,
Text = "beer",
IsPayed = true
};
await context.Spendings.AddAsync(spending);
await context.SaveChangesAsync();
SpendingDTO model = new SpendingDTO
{
Amount = 100,
Text = "alot of beer",
IsPayed = false,
Id = spending.Id + "Random string"
};
await Assert.ThrowsAsync <ACMException>(() => spendingService.EditSpending(model));
}
