public async Task GetAllAsync_ShouldReturnNullBreweryIfModelHasNoNameAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnNullBreweryIfModelHasNoNameAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria",
Breweries = new List <Brewery>()
{
new Brewery()
}
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
var result = await sut.GetAllAsync();
//Assert
Assert.AreEqual(result, null);
}
}
public async Task UpdateAsync_ShouldReturnNullIfReviewNonExistantAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldReturnNullIfReviewNonExistantAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var reviewDTO = new ReviewDTO
{
Description = "Great",
Beer = new BeerDTO()
{
Name = "Carlsberg"
},
User = new UserDTO()
{
Name = "SuperMan"
}
};
//Act
var sut = new ReviewsService(context);
var result = await sut.UpdateAsync(1, reviewDTO);
//Assert
Assert.AreEqual(result, null);
}
}
public BOJob(Accountant accountant, Job job, BOContext _state)
: base(accountant, _state)
{
mObjectID = BOType.BOJob;
mDataProxy = job.Clone() as Job;
mDataSource = job;
}
public async Task DeleteAsync_ShouldDeleteCountryIfExist()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldDeleteCountryIfExist");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria"
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new CountriesService(context);
await sut.DeleteAsync(1);
var dbresult = await context.Countries.FirstOrDefaultAsync(c => c.Name == "Bulgaria");
//Assert
Assert.AreEqual(dbresult.Name, "Bulgaria");
Assert.AreEqual(dbresult.DeletedOn, dbresult.ModifiedOn);
Assert.AreEqual(dbresult.IsDeleted, true);
}
}
public BOLocation(Accountant acc, Location _obj, BOContext state)
: base(acc, state)
{
mObjectID = BOType.BOLocation;
mDataProxy = _obj.Clone() as Location;
mDataSource = _obj;
}
public async Task CreateAsync_ShouldUndeleteRecordIfExist()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldUndeleteRecordIfExist");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria",
DeletedOn = DateTime.UtcNow,
IsDeleted = true
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var countryDTO = new CountryDTO()
{
Name = "Bulgaria"
};
//Act
var sut = new CountriesService(context);
await sut.CreateAsync(countryDTO);
var dbresult = await context.Countries.FirstOrDefaultAsync(c => c.Name == "Bulgaria");
//Assert
Assert.AreEqual(dbresult.Name, "Bulgaria");
Assert.AreEqual(dbresult.DeletedOn, null);
Assert.AreEqual(dbresult.IsDeleted, false);
}
}
public async Task GetAllAsync_ShouldReturnIEnumerableCountryDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnIEnumerableCountryDTOAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria"
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new CountriesService(context);
var result = await sut.GetAllAsync();
//Assert
Assert.IsInstanceOfType(result, typeof(IEnumerable <CountryDTO>));
}
}
public async Task UpdateAsync_ShouldReturnNullIfCommentNonExistantAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldReturnNullIfCommentNonExistantAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var commentDTO = new CommentDTO
{
Description = "Gotham",
User = new UserDTO()
{
Name = "Batman"
},
Review = new ReviewDTO()
{
Description = "Description"
}
};
//Act
var sut = new CommentService(context);
var result = await sut.UpdateAsync(1, commentDTO);
//Assert
Assert.AreEqual(result, null);
}
}
public async Task DeleteAsync_ShouldReturnTrueIfCommentSucceded()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldReturnTrueIfCommentSucceded");
using (var context = new BOContext(options))
{
var comment = new Comment
{
Description = "Gotham",
User = new User()
{
Name = "Batman"
},
Review = new Review()
{
Description = "Description"
}
};
context.Comments.Add(comment);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new CommentService(context);
var result = await sut.DeleteAsync(1);
//Assert
Assert.AreEqual(result, true);
}
}
public async Task CreateAsync_ShouldReturnCommentDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnCommentDTOAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var commentDTO = new CommentDTO
{
Description = "Gotham",
User = new UserDTO()
{
Name = "Batman"
},
Review = new ReviewDTO()
{
Description = "Description"
}
};
//Act
var sut = new CommentService(context);
var result = await sut.CreateAsync(commentDTO);
//Assert
Assert.IsInstanceOfType(result, typeof(CommentDTO));
}
}
public async Task CreateAsync_ShouldReturnModifiedCommentDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnModifiedCommentDTOAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var commentDTO = new CommentDTO
{
Description = "Gotham",
User = new UserDTO()
{
Name = "Batman"
},
Review = new ReviewDTO()
{
Description = "Description"
}
};
//Act
var sut = new CommentService(context);
var result = await sut.CreateAsync(commentDTO);
var dbresult = await context.Comments.FindAsync(1);
//Assert
Assert.AreEqual(result.ID, dbresult.ID);
Assert.AreEqual(result.Description, dbresult.Description);
}
}
private static async Task SeedBeersAsync(BOContext context)
{
if (context.Beers.Any())
{
return;
}
var beerNames = new[] { "Carlsberg", "Shumensko", "Pirinsko" };
foreach (var beer in beerNames)
{
var b = new Beer()
{
Name = beer,
Country = await context.Countries.FirstOrDefaultAsync(c => c.Name == "Bulgaria"),
Brewery = await context.Breweries.FirstOrDefaultAsync(b => b.Name == "Carlsberg"),
ABV = 4,
Style = await context.BeerStyles.FindAsync(1),
CreatedOn = DateTime.UtcNow
};
b.CountryID = b.Country.ID;
b.BreweryID = b.Brewery.ID;
b.StyleID = b.Style.ID;
await context.Beers.AddAsync(b);
}
await context.SaveChangesAsync();
}
public void GetAllUsersShould_ReturnCorrectUser()
{
//Arrange
var options = InMemory.GetOptions("GetAllUsersShould_ReturnCorrectUser");
using (var context = new BOContext(options))
{
var cut = new User()
{
Id = 1,
Name = "SuperMan",
Password = "******",
ReviewList = new List <Review>(),
CommentList = new List <Comment>(),
DrankLists = new List <DrankList>(),
WishLists = new List <WishList>(),
};
context.Users.Add(cut);
context.SaveChanges();
}
using (var context = new BOContext(options))
{
//Act
var sut = new UsersService(context);
var result = sut.GetAllUsers().Result.ToList();
//Assert
Assert.AreEqual(result.Count, 1);
Assert.AreEqual(result[0].Name, "SuperMan");
}
}
public void DeleteUserShould_ReturnFalse_whenNotDeletedUser()
{
//Arrange
var options = InMemory.GetOptions("DeleteUserShould_ReturnFalse_whenNotDeletedUser");
using (var context = new BOContext(options))
{
var cut = new User()
{
Id = 1,
Name = "SuperMan",
Password = "******",
};
context.Users.Add(cut);
context.SaveChanges();
}
using (var context = new BOContext(options))
{
//Act
var sut = new UsersService(context);
var result = sut.DeleteUser(55).Result;
//Assert
var deletedUsers = context.Users.Where(u => u.IsDeleted == true).Count();
var activeUsers = context.Users.Where(u => u.IsDeleted == false).Count();
Assert.IsFalse(result);
Assert.AreEqual(0, deletedUsers);
Assert.AreEqual(1, activeUsers);
}
}
public BORecordJournalEntry(Accountant accountant, JournalRecord data, BOContext context)
: base(accountant, context)
{
mObjectID = BOType.BORecordJournalEntry;
mDataProxy = data.Clone() as JournalRecord;
mDataSource = data;
}
public async Task CreateAsync_ShouldReturnModifiedBeerStyleDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnModifiedBeerStyleDTOAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale",
Description = "This description"
};
//Act
var sut = new BeerStylesService(context);
var result = await sut.CreateAsync(styleDTO);
var dbresult = await context.BeerStyles.FirstOrDefaultAsync(c => c.Name == "Ale");
//Assert
Assert.AreEqual(result.ID, dbresult.ID);
Assert.AreEqual(result.Name, dbresult.Name);
}
}
public BOAccount(Accountant acc, Account account, BOContext state)
: base(acc, state)
{
mObjectID = BOType.BOAccount;
mDataProxy = account.Clone() as Account;
mDataSource = account;
}
public async Task GetAllAsync_ShouldReturnIEnumerableBeerStyleDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnIEnumerableBeerStyleDTOAsync");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description"
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BeerStylesService(context);
var result = await sut.GetAllAsync();
//Assert
Assert.IsInstanceOfType(result, typeof(IEnumerable <BeerStyleDTO>));
}
}
public async Task CreateAsync_ShouldReturnModifiedCountryDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnModifiedCountryDTOAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var countryDTO = new CountryDTO()
{
Name = "Bulgaria"
};
//Act
var sut = new CountriesService(context);
var result = await sut.CreateAsync(countryDTO);
var dbresult = await context.Countries.FirstOrDefaultAsync(c => c.Name == "Bulgaria");
//Assert
Assert.AreEqual(result.ID, dbresult.ID);
Assert.AreEqual(result.Name, dbresult.Name);
}
}
public async Task UpdateAsync_ShouldChangeNameOfStyleAndDescriptionAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldChangeNameOfStyleAndDescriptionAsync");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description"
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale2",
Description = "This description2"
};
//Act
var sut = new BeerStylesService(context);
await sut.UpdateAsync(1, styleDTO);
var dbresult = await context.BeerStyles.FindAsync(1);
//Assert
Assert.AreEqual(dbresult.Name, "Ale2");
Assert.AreEqual(dbresult.Description, "This description2");
}
}
public async Task UpdateAsync_ShouldChangeNameOfCountryAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldChangeNameOfCountryAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria"
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var countryDTO = new CountryDTO()
{
Name = "Belgium"
};
//Act
var sut = new CountriesService(context);
var result = await sut.UpdateAsync(1, countryDTO);
var dbresult = await context.Countries.FindAsync(1);
//Assert
Assert.AreEqual(dbresult.Name, "Belgium");
}
}
public async Task DeleteAsync_ShouldDeleteStyleIfExist()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldDeleteStyleIfExist");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description"
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BeerStylesService(context);
await sut.DeleteAsync(1);
var dbresult = await context.BeerStyles.FirstOrDefaultAsync(c => c.Name == "Ale");
//Assert
Assert.AreEqual(dbresult.Name, "Ale");
Assert.AreEqual(dbresult.DeletedOn, dbresult.ModifiedOn);
Assert.AreEqual(dbresult.IsDeleted, true);
}
}
public async Task DeleteAsync_ShouldReturnTrueIfSucceded()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldReturnTrueIfSucceded");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria"
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new CountriesService(context);
var result = await sut.DeleteAsync(1);
//Assert
Assert.AreEqual(result, true);
}
}
public async Task DeleteAsync_ShouldReturnTrueStyleIfSucceded()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldReturnTrueStyleIfSucceded");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description"
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BeerStylesService(context);
var result = await sut.DeleteAsync(1);
//Assert
Assert.AreEqual(result, true);
}
}
public async Task GetAllAsync_ShouldReturnIEnumerableReviewDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnIEnumerableReviewDTOAsync");
using (var context = new BOContext(options))
{
var review = new Review
{
Description = "Great",
Beer = new Beer()
{
Name = "Carlsberg"
},
User = new User()
{
Name = "SuperMan"
}
};
context.Reviews.Add(review);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new ReviewsService(context);
var result = await sut.GetAllAsync();
//Assert
Assert.IsInstanceOfType(result, typeof(IEnumerable <ReviewDTO>));
}
}
public BOSupplier(Accountant accountant, Supplier _obj, BOContext _state)
: base(accountant, _obj, _state)
{
mObjectID = BOType.BOSupplier;
mDataProxy = _obj.Clone() as Supplier;
mDataSource = _obj;
}
public async Task DeleteAsync_ShouldReturnTrueIfReviewSucceded()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldReturnTrueIfSucceded");
using (var context = new BOContext(options))
{
var review = new Review
{
Description = "Great",
Beer = new Beer()
{
Name = "Carlsberg"
},
User = new User()
{
Name = "SuperMan"
},
};
context.Reviews.Add(review);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new ReviewsService(context);
var result = await sut.DeleteAsync(1);
//Assert
Assert.AreEqual(result, true);
}
}
public BORole(Accountant acc, AuthRole data, BOContext context)
: base(acc, context)
{
mObjectID = BOType.BORole;
mDataSource = data;
mDataProxy = data.Clone() as AuthRole;
}
public BOItemSize(Accountant acc, ItemSize _obj, BOContext state)
: base(acc, state)
{
mObjectID = BOType.BOItemSize;
mDataSource = _obj;
mDataProxy = _obj.Clone() as ItemSize;
}
public async Task CreateAsync_ShouldRecordBreweryIfNotOnRecordAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldRecordBreweryIfNotOnRecordAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria"
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var breweryDTO = new BreweryDTO()
{
Name = "Brewery",
Country = "Bulgaria"
};
//Act
var sut = new BreweryServices(context);
await sut.CreateAsync(breweryDTO);
var dbresult = await context.Breweries.Include(b => b.Country).FirstOrDefaultAsync(c => c.Name == "Brewery");
//Assert
Assert.AreEqual(dbresult.Name, "Brewery");
}
}
