public async Task DeleteBar_Should_Delete_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(DeleteBar_Should_Delete_Correct));
var country = new Country {
Id = Guid.NewGuid(), Name = "Bulagria",
};
var bar = new Bar {
Id = Guid.NewGuid(), Name = "Cosmos", CountryId = country.Id
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.SaveChangesAsync();
}
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
var result = await sut.DeleteBar(bar.Id);
Assert.AreEqual(true, result.IsDeleted);
}
}
public void ReturnCollectionOfCorrectBars()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCollectionOfCorrectBars));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new BarServices(assertContext);
var bar1 = new Bar
{
Name = "FF1"
};
var bar2 = new Bar
{
Name = "FF2"
};
assertContext.Bars.Add(bar1);
assertContext.Bars.Add(bar2);
assertContext.SaveChanges();
var result = sut.GetMultipleBarsByNameAsync("F").GetAwaiter().GetResult();
Assert.IsTrue(result.Count == 2 && result.Contains(bar1) && result.Contains(bar2));
}
}
public void ReturnCorrectBarsWithNameParam()
{
var options = TestUtilities.GetOptions(nameof(ReturnCorrectBarsWithNameParam));
string name = "test";
string address = "TestAddr";
string phoneNumber = "number";
var bar = new Bar
{
Id = -1,
Name = "kon",
Address = address,
PhoneNumber = phoneNumber,
};
var bar2 = new Bar
{
Id = -2,
Name = name,
Address = address,
PhoneNumber = phoneNumber,
};
using (var arrangeContext = new CocktailDB(options))
{
arrangeContext.Bars.AddAsync(bar).GetAwaiter();
arrangeContext.Bars.AddAsync(bar2).GetAwaiter();
arrangeContext.SaveChangesAsync().GetAwaiter();
}
using (var assertContext = new CocktailDB(options))
{
var sut = new BarServices(assertContext);
var collection = sut.SearchBarsByMultipleCriteriaAsync("kon", null, null, false).GetAwaiter().GetResult();
Assert.IsNotNull(collection);
Assert.AreEqual(1, collection.Count);
}
}
public async Task AddIngredientsToCocktail_Throws_When_NoCocktailFound()
{
//Arrange
var options = Utils.GetOptions(nameof(AddIngredientsToCocktail_Throws_When_NoCocktailFound));
var ingredient = new Ingredient {
Id = Guid.NewGuid(), Name = "Vodka"
};
var ingredient2 = new Ingredient {
Id = Guid.NewGuid(), Name = "Rum"
};
var cocktailId = Guid.NewGuid();
ICollection <Guid> ingredientsId = new List <Guid> {
ingredient.Id, ingredient2.Id
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Ingredients.AddRangeAsync(ingredient, ingredient2);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.AddCocktailsToBar(cocktailId, ingredientsId));
}
}
public void ReturnCollectionOf10NewestBarsOrderedAscending()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCollectionOf10NewestBarsOrderedAscending));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new BarServices(assertContext);
var bar1 = new Bar
{
Name = "FF1",
CreatedOn = DateTime.Now
};
var bar2 = new Bar
{
Name = "FF2",
CreatedOn = DateTime.Now
};
assertContext.Bars.Add(bar1);
assertContext.Bars.Add(bar2);
assertContext.SaveChanges();
var result = sut.LoadNewestBars().GetAwaiter().GetResult();
Assert.IsTrue(result.Count == 2 && result[0] == bar1 && result[1] == bar2);
}
}
public async Task Invoke_SetImageMethod_WhenBarDtoImageIsValid()
{
var options = TestUtils.GetOptions(nameof(Invoke_SetImageMethod_WhenBarDtoImageIsValid));
var fileService = new Mock <IFileUploadService>();
fileService.Setup(f => f.SetUniqueImagePathForBar(null));
using (var assertContext = new CMContext(options))
{
assertContext.Bars.Add(new Bar {
Id = "1", Name = "BashBar", Website = "abv.bg", Address = new Address {
City = "Sofia", Id = "1"
}
});
await assertContext.SaveChangesAsync();
var sut = new BarServices(assertContext, fileService.Object);
var barDto =
new BarDTO
{
Id = barId,
Name = barName,
ImageUrl = "abv.bg",
Website = barWebsite,
BarImage = new Mock <IFormFile>().Object,
};
await sut.Update(barDto);
fileService.Verify(x => x.SetUniqueImagePathForBar(barDto.BarImage), Times.AtLeastOnce);
}
}
public void ReturnCorrectBar()
{
var options = TestUtils.GetOptions(nameof(ReturnCorrectBar));
var testBar = new Bar
{
Id = 1,
Name = "Test",
Address = "Test",
PhoneNumber = "Test",
};
// Act
using (var actContext = new CocktailDB(options))
{
var sut = new BarServices(actContext);
actContext.Bars.Add(testBar);
actContext.SaveChangesAsync().GetAwaiter();
}
// Assert
using (var assertContext = new CocktailDB(options))
{
var id = 1;
var sut = new BarServices(assertContext);
var result = sut.GetBarAsync(id).GetAwaiter().GetResult();
Assert.IsTrue(assertContext.Bars.Contains(testBar));
Assert.AreEqual(testBar.Id, result.Id);
}
}
public async Task Return_UpdatedBarName_WhenEverythingIsOk()
{
var options = TestUtils.GetOptions(nameof(Return_UpdatedBarName_WhenEverythingIsOk));
var fileService = new Mock <IFileUploadService>();
using (var assertContext = new CMContext(options))
{
assertContext.Bars.Add(new Bar {
Id = "1", Name = "BashBar", Website = "abv.bg", Address = new Address {
City = "Sofia", Id = "1"
}
});
await assertContext.SaveChangesAsync();
var sut = new BarServices(assertContext, fileService.Object);
var result = await sut.Update(
new BarDTO
{
Id = "1",
Name = barName,
Website = barWebsite,
BarImage = new Mock <IFormFile>().Object,
});
Assert.AreEqual(barName, result);
}
}
public async Task UpdateBarProperties_AndSaveItToDb_WhenValidValuesPassed()
{
var options = TestUtils.GetOptions(nameof(UpdateBarProperties_AndSaveItToDb_WhenValidValuesPassed));
var fileService = new Mock <IFileUploadService>();
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext, fileService.Object);
var file = new Mock <IFormFile>().Object;
assertContext.Bars.Add(new Bar {
Id = "1", Name = "BashBar", Website = "abv.bg", Address = new Address {
City = "Sofia", Id = "1"
}
});
await assertContext.SaveChangesAsync();
var result = await sut.Update(
new BarDTO
{
Id = "1",
Name = barName,
Website = barWebsite,
BarImage = file,
});
Assert.AreEqual(barName, assertContext.Bars.First().Name);
Assert.AreEqual(barWebsite, assertContext.Bars.First().Website);
}
}
public async Task CreateBar_Throws_When_NameIsNull()
{
//Arrange
var options = Utils.GetOptions(nameof(CreateBar_Throws_When_NameIsNull));
var bar = new Bar
{
Id = Guid.NewGuid(),
Name = "Cosmos"
};
var barDTO = new BarDTO
{
Id = Guid.NewGuid(),
Name = null
};
using (var arranegContext = new CMContext(options))
{
await arranegContext.Bars.AddAsync(bar);
await arranegContext.SaveChangesAsync();
}
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateBar(barDTO));
}
}
public async Task GetBar_Throws_When_IdIsNull()
{
//Arrange
var options = Utils.GetOptions(nameof(GetBar_Throws_When_IdIsNull));
var bar = new Bar
{
Id = Guid.Parse("cda3e6b5-c77c-4682-a7ff-73987919a059"),
Name = "Cosmos",
Address = "Sofia",
Rating = 2,
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.GetBar(null));
}
}
public void CorrectlyEditBar()
{
var options = TestUtils.GetOptions(nameof(CorrectlyEditBar));
var resultName = "test1";
var resultAddress = "Mill Street";
var resultPhoneNumber = "testNumber";
var bar = new Bar
{
Id = 1,
Name = "asd",
Address = "asd",
PhoneNumber = "add",
IsHidden = false,
};
using (var actContext = new CocktailDB(options))
{
var sut = new BarServices(actContext);
actContext.Bars.AddAsync(bar).GetAwaiter();
actContext.SaveChangesAsync().GetAwaiter();
sut.EditBarAsync(bar, resultName, resultAddress, resultPhoneNumber, null, true).GetAwaiter();
}
using (var asertContext = new CocktailDB(options))
{
var sut = new BarServices(asertContext);
var resultBar = sut.GetBarAsync(bar.Id).GetAwaiter().GetResult();
Assert.AreEqual(resultBar.Name, resultName);
Assert.AreEqual(resultBar.Address, resultAddress);
Assert.AreEqual(resultBar.PhoneNumber, resultPhoneNumber);
Assert.IsTrue(resultBar.IsHidden);
}
}
public async Task UpdateDefaultImage_WhenBarDtoImagePathIsNull()
{
var options = TestUtils.GetOptions(nameof(UpdateDefaultImage_WhenBarDtoImagePathIsNull));
var fileService = new Mock <IFileUploadService>();
fileService.Setup(f => f.SetUniqueImagePathForBar(null)).Returns("/images/defaultBarImage.jpg");
using (var assertContext = new CMContext(options))
{
assertContext.Bars.Add(new Bar {
Id = "1", Name = "BashBar", Website = "abv.bg", Address = new Address {
City = "Sofia", Id = "1"
}
});
await assertContext.SaveChangesAsync();
var expectedPath = "/images/defaultBarImage.jpg";
var sut = new BarServices(assertContext, fileService.Object);
var result = await sut.Update(
new BarDTO
{
Id = "1",
Name = barName,
Website = barWebsite,
});
Assert.AreEqual(expectedPath, assertContext.Bars.First().Image);
}
}
public void ReturnCollectionOfCorrectBars()
{
var options = TestUtilities.GetOptions(nameof(ReturnCollectionOfCorrectBars));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new BarServices(assertContext);
var bar = new Bar
{
Id = 1,
Name = "test",
Address = "asasas",
PhoneNumber = "asd",
};
var bar1 = new Bar
{
Id = 2,
Name = "test1",
Address = "asasas",
PhoneNumber = "asd",
};
assertContext.Bars.Add(bar);
assertContext.Bars.Add(bar1);
assertContext.SaveChanges();
var result = sut.GetCollectionAsync().GetAwaiter().GetResult();
Assert.IsTrue(result.Count == 2 && result.Contains(bar) && result.Contains(bar1));
}
}
public async Task MakeInstance_OfTypeBarService_IfValidValuesPassed()
{
var options = TestUtils.GetOptions(nameof(MakeInstance_OfTypeBarService_IfValidValuesPassed));
var barService = new BarServices(new CMContext(options), new Mock <IFileUploadService>().Object);
Assert.IsInstanceOfType(barService, typeof(BarServices));
}
public async Task ThrowCorrectMagicExeption_WhenBarDoesNotExist()
{
var options = TestUtils.GetOptions(nameof(ThrowCorrectMagicExeption_WhenBarDoesNotExist));
var fileService = new Mock <IFileUploadService>();
using (var arrangeContext = new CMContext(options))
{
//1
arrangeContext.Cocktails.Add(new Cocktail {
Id = "1", Name = "cocktail"
});
arrangeContext.Bars.Add(
new Bar
{
Id = "3",
Name = "Target",
Image = "Snimka",
Website = "abv.bg",
Address = new Address
{
Id = "3",
BarId = "3",
Country = new Country
{
Id = "3",
Name = "Bulgaria"
}
},
BarCocktails = new List <BarCocktail>
{
new BarCocktail
{
BarId = "3",
CocktailId = "1"
}
}
,
BarRating = 3
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext, fileService.Object);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.GetBar("4")
);
Assert.AreEqual("Bar cannot be null!", ex.Message);
}
}
public void ThrowWhenParametersAreNull()
{
var options = TestUtilities.GetOptions(nameof(ReturnFirstCorrectName));
using (var assertContext = new CocktailDB(options))
{
var sut = new BarServices(assertContext);
Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.GetAsync(null));
}
}
public async Task AddCocktailToBar_Throws_When_Cocktail_IsAreadyListed()
{
//Arrange
var options = Utils.GetOptions(nameof(AddCocktailToBar_Throws_When_Cocktail_IsAreadyListed));
var bar = new Bar
{
Id = Guid.NewGuid(),
Name = "Cosmos",
Country = new Country
{
Id = Guid.NewGuid(),
Name = "Bulgaria"
}
};
var cocktail = new Cocktail
{
Id = Guid.NewGuid(),
Name = "Manhattan",
};
var cocktailDTO = new CocktailDTO
{
Id = cocktail.Id,
Name = cocktail.Name,
};
var barCocktail = new BarCocktail
{
BarId = bar.Id,
CocktailId = cocktail.Id,
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.BarCocktails.AddAsync(barCocktail);
await arrangeContext.SaveChangesAsync();
}
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(() => sut.AddCocktailToBar(bar.Id, cocktailDTO.Id));
}
}
public async Task Return_InstanceOfTypeDto_WhenValidIdPassed()
{
var options = TestUtils.GetOptions(nameof(Return_InstanceOfTypeDto_WhenValidIdPassed));
var fileService = new Mock <IFileUploadService>();
using (var arrangeContext = new CMContext(options))
{
//1
arrangeContext.Cocktails.Add(new Cocktail {
Id = "1", Name = "cocktail"
});
arrangeContext.Bars.Add(
new Bar
{
Id = "3",
Name = "Target",
Image = "Snimka",
Website = "abv.bg",
Address = new Address
{
Id = "3",
BarId = "3",
Country = new Country
{
Id = "3",
Name = "Bulgaria"
}
},
BarCocktails = new List <BarCocktail>
{
new BarCocktail
{
BarId = "3",
CocktailId = "1"
}
}
,
BarRating = 3
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext, fileService.Object);
var result = await sut.GetBarByID("3");
Assert.IsInstanceOfType(result, typeof(BarDTO));
}
}
public void ThrowWhenBarIsNull()
{
var options = TestUtils.GetOptions(nameof(ThrowWhenBarIsNull));
using (var assertContext = new CocktailDB(options))
{
var sut = new BarServices(assertContext);
Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateBarAsync(null)
);
}
}
public void ReturnFalseIfSuchBarDoesntExist()
{
var options = TestUtilities.GetOptions(nameof(ReturnFalseIfSuchBarDoesntExist));
//act & assert
using (var assertContext = new CocktailDB(options))
{
var sut = new BarServices(assertContext);
Assert.IsFalse(sut.BarWithThatNameExists("test").GetAwaiter().GetResult());
}
}
public async Task RemoveCocktailFromBar_Throws_When_Cocktail_NotFound_AtThisBar()
{
//Arrange
var options = Utils.GetOptions(nameof(RemoveCocktailFromBar_Throws_When_Cocktail_NotFound_AtThisBar));
var bar = new Bar
{
Id = Guid.Parse("86cb5331-0035-4a52-b99b-08df779358e3"),
Name = "Cosmos",
Country = new Country
{
Id = Guid.Parse("fb837576-a066-43a1-9812-3c1eac4d449c"),
Name = "Bulgaria"
}
};
var cocktail = new Cocktail
{
Id = Guid.Parse("bb4b4175-81c5-4828-bca4-3660f796eb3f"),
Name = "Manhattan",
};
var cocktailDTO = new CocktailDTO
{
Id = cocktail.Id,
Name = cocktail.Name,
};
var barCocktail = new BarCocktail
{
Id = Guid.Parse("ca28a84e-1885-4d1b-aee9-3ab4f9ade0f7"),
CocktailId = cocktail.Id
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.BarCocktails.AddAsync(barCocktail);
await arrangeContext.SaveChangesAsync();
}
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(() => sut.RemoveCocktailFromBar(bar.Id, cocktailDTO.Id));
}
}
public async Task GetCocktailsForBar_Returns_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(GetCocktailsForBar_Returns_Correct));
var bar = new Bar
{
Id = Guid.NewGuid(),
Name = "Cosmos",
Address = "Sofia",
Rating = 2,
Country = new Country {
Name = "Bulgaria"
}
};
var cocktail = new Cocktail {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var cocktail2 = new Cocktail {
Id = Guid.NewGuid(), Name = "Cosmopolitan"
};
var barCocktail = new BarCocktail {
BarId = bar.Id, CocktailId = cocktail.Id
};
var barCocktail2 = new BarCocktail {
BarId = bar.Id, CocktailId = cocktail2.Id
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Cocktails.AddRangeAsync(cocktail, cocktail2);
await arrangeContext.BarCocktails.AddRangeAsync(barCocktail, barCocktail2);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
var result = await sut.GetCocktailsForBar(bar.Id);
Assert.AreEqual(2, result.Count());
Assert.AreEqual(barCocktail.CocktailId, result.ToList()[0].CocktailId);
Assert.AreEqual(barCocktail.BarId, result.ToList()[0].BarId);
Assert.AreEqual(barCocktail2.BarId, result.ToList()[1].BarId);
Assert.AreEqual(barCocktail2.BarId, result.ToList()[1].BarId);
Assert.IsInstanceOfType(result, typeof(ICollection <BarCocktailDTO>));
}
}
public void ReturnEmptyCollectionIfNoBarsExist()
{
var options = TestUtilities.GetOptions(nameof(ReturnEmptyCollectionIfNoBarsExist));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new BarServices(assertContext);
var result = sut.GetCollectionAsync().GetAwaiter().GetResult();
Assert.IsTrue(result.Count == 0);
}
}
public async Task ThrowMagicExeption_WhenNullBarDto_IsPassed()
{
var options = TestUtils.GetOptions(nameof(ThrowMagicExeption_WhenNullBarDto_IsPassed));
var fileService = new Mock <IFileUploadService>();
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext, fileService.Object);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.Update(null));
}
}
public async Task AddCocktailToBar_Adds_Correctly_When_Params_Are_Valid()
{
//Arrange
var options = Utils.GetOptions(nameof(AddCocktailToBar_Adds_Correctly_When_Params_Are_Valid));
var bar = new Bar
{
Id = Guid.NewGuid(),
Name = "Cosmos",
Country = new Country
{
Id = Guid.NewGuid(),
Name = "Bulgaria"
}
};
var cocktail = new Cocktail
{
Id = Guid.NewGuid(),
Name = "Manhattan",
};
var cocktailDTO = new CocktailDTO
{
Id = cocktail.Id,
Name = cocktail.Name,
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
var result = await sut.AddCocktailToBar(bar.Id, cocktailDTO.Id);
Assert.AreEqual(1, assertContext.BarCocktails.Count());
Assert.AreEqual(1, result.BarCocktails.Count());
Assert.AreEqual(true, result.BarCocktails.ToList()[0].IsListed);
Assert.IsInstanceOfType(result, typeof(BarDTO));
}
}
public async Task ReturnNumberOfNotDeletedBars()
{
var barFactoryMock = new Mock <IBarFactory>();
var barCocktailFactoryMock = new Mock <IBarCocktailFactory>();
var imagaUrlTest = "https://www.google.com/";
var bar1TestName = "Name1Test";
var bar2TestName = "Name2Test";
var addressTest = new Address
{
Name = "AddressTest",
City = new City {
Name = "SofiaTest"
},
Latitude = 1.1,
Longitude = 1.1
};
var bar1Test = new Bar
{
Name = bar1TestName,
ImagePath = imagaUrlTest,
Address = addressTest,
};
var bar2Test = new Bar
{
Name = bar2TestName,
ImagePath = imagaUrlTest,
Address = addressTest,
IsDeleted = true
};
var options = TestUtilities.GetOptions(nameof(ReturnNumberOfNotDeletedBars));
using (var arrangeContext = new CocktailMagicianDb(options))
{
arrangeContext.Bars.Add(bar1Test);
arrangeContext.Bars.Add(bar2Test);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CocktailMagicianDb(options))
{
var sut = new BarServices(assertContext, barFactoryMock.Object, barCocktailFactoryMock.Object);
var count = await sut.AllBarsCountAsync();
Assert.AreEqual(1, count);
}
}
public async Task ThrowMagicExeption_IfNullValue_Bar_Passed()
{
var options = TestUtils.GetOptions(nameof(ThrowMagicExeption_IfNullValue_Bar_Passed));
var fileService = new Mock <IFileUploadService>();
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext, fileService.Object);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.AddCocktailToBar(null, null));
}
}
public void ReturnEmptyCollectionIfThereAreNoBars()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ReturnEmptyCollectionIfThereAreNoBars));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new BarServices(assertContext);
var result = sut.LoadNewestBars().GetAwaiter().GetResult();
Assert.IsTrue(result.Count == 0);
}
}
public async Task UpdateAll_ManyToManyConnectionsToCocktails_OfBar_InDb()
{
var options = TestUtils.GetOptions(nameof(UpdateAll_ManyToManyConnectionsToCocktails_OfBar_InDb));
var fileService = new Mock <IFileUploadService>();
using (var assertContext = new CMContext(options))
{
assertContext.Bars.Add(new Bar {
Id = "1", Name = "BashBar", Website = "abv.bg", Address = new Address {
City = "Sofia", Id = "1"
}
});
await assertContext.SaveChangesAsync();
var sut = new BarServices(assertContext, fileService.Object);
var result = await sut.Update(
new BarDTO
{
Id = barId,
Name = barName,
Website = barWebsite,
BarImage = new Mock <IFormFile>().Object,
Cocktails = new List <CocktailDto>
{
new CocktailDto
{
Id = "1",
Name = "cocktail",
},
new CocktailDto
{
Id = "2",
Name = "cocktail2",
}
}
});
Assert.AreEqual(2, assertContext.BarCocktails.Count());
Assert.AreEqual("1", assertContext.BarCocktails
.First(x => x.CocktailId == "1").CocktailId);
Assert.AreEqual("2", assertContext.BarCocktails
.First(x => x.CocktailId == "2").CocktailId);
Assert.AreEqual("1", assertContext.BarCocktails
.First(x => x.CocktailId == "2").BarId);
Assert.AreEqual("1", assertContext.BarCocktails
.First(x => x.CocktailId == "1").BarId);
}
}
