public async Task CorrectlyUnHideBar()
{
//arrange
int testId = 12;
string testBarName1 = "TestName1";
var mockCountryService = new Mock <ICountryService>().Object;
var mockCityService = new Mock <ICityService>().Object;
var mockCocktailService = new Mock <ICocktailService>().Object;
var mockNotificationService = new Mock <INotificationService>().Object;
var options = TestUtilities.GetOptions(nameof(CorrectlyUnHideBar));
using (var arrangeContext = new CocktailDatabaseContext(options))
{
arrangeContext.Bars.Add(new Bar()
{
Name = testBarName1, Id = testId, Hidden = 0
});
arrangeContext.SaveChanges();
}
using (var assertContext = new CocktailDatabaseContext(options))
{
var sut = new BarService(assertContext, mockCountryService, mockCityService, mockCocktailService, mockNotificationService);
await sut.UnhideBarAsync(testId);
Assert.AreEqual(0, assertContext.Bars.First().Hidden);
}
}
public async Task CreateBarAsync_Correct()
{
//Arrange
var barName = "Just another bar";
var options = Utils.GetOptions(nameof(CreateBarAsync_Correct));
var city = new City()
{
Id = Guid.Parse("cc44371d-594f-4c47-a82b-e606bede8d3b"),
Name = "Varna"
};
var barDTO = new BarDTO()
{
Id = Guid.Parse("92a05c62-6f33-4dc9-bcc1-c9c946bf693a"),
Name = barName,
Phone = "0898878465",
CityId = Guid.Parse("cc44371d-594f-4c47-a82b-e606bede8d3b"), //Varna
Address = "62 Prof. Marin Drinov Str.",
};
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarService(assertContext);
var result = await sut.CreateBarAsync(barDTO);
Assert.AreEqual(barName, result.Name);
Assert.IsInstanceOfType(result, typeof(BarDTO));
}
}
public async Task ThrowWhen_NoBarFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_NoBarFound));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
var bar = new Bar
{
Id = testGuid,
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
Phone = "111-333-666",
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <Bar>())).Returns(It.IsAny <BarDto>);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.EditAsync(testGuid2, "newTestName", "newTestInfo", "newTestAddress", "111-333-6667"));
}
}
public async Task ReturnCorrectCountOfDtos()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectCountOfDtos));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
var testGuid3 = Guid.NewGuid();
var bar1 = new Bar
{
Id = testGuid,
Name = "testBar1",
};
var bar2 = new Bar
{
Id = testGuid2,
Name = "testBar2",
};
var bar3 = new Bar
{
Id = testGuid3,
Name = "testBar3",
};
var list = new List <BarDto>()
{
new BarDto {
Id = testGuid, Name = "testBar1"
}, new BarDto {
Id = testGuid2, Name = "testBar2"
}, new BarDto {
Id = testGuid3, Name = "testBar3"
}
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <ICollection <Bar> >())).Returns(list);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar1);
await arrangeContext.Bars.AddAsync(bar2);
await arrangeContext.Bars.AddAsync(bar3);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await sut.GetTopBarsAsync(3);
Assert.AreEqual(3, result.Count());
}
}
public async Task Delete_Bar_Correctly()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(Delete_Bar_Correctly));
var mockDateTimeProvider = new Mock <IDateTimeProvider>();
var mockBarDtoMapper = new Mock <IDtoMapper <Bar, BarDTO> >();
var newBar = new Bar
{
Id = 1,
Name = "TestBar",
};
using (var arrangeContext = new CocktailMagicianContext(options))
{
await arrangeContext.Bars.AddAsync(newBar);
await arrangeContext.SaveChangesAsync();
var barService = new BarService(arrangeContext, mockBarDtoMapper.Object, mockDateTimeProvider.Object);
var result = await barService.DeleteBarAsync(1);
}
//Act and Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var deletedBar = await assertContext.Bars.FirstAsync();
Assert.IsTrue(deletedBar.IsDeleted);
}
}
public async Task ThrowWhen_BarNotFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_BarNotFound));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
mapperMock.Setup(x => x.MapFrom(It.IsAny <Bar>())).Returns(It.IsAny <BarDto>);
var bar1 = new Bar
{
Id = testGuid,
Name = "testBar1",
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar1);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.GetBarAsync(testGuid2));
}
}
public async Task Create_Bar()
{
//arrange
string barName = "testName";
byte[] coverPhoto = new byte[0];
var mockCountryService = new Mock <ICountryService>().Object;
var mockCityService = new Mock <ICityService>().Object;
var mockCocktailService = new Mock <ICocktailService>().Object;
var mockNotificationService = new Mock <INotificationService>().Object;
var options = TestUtilities.GetOptions(nameof(Create_Bar));
using (var assertContext = new CocktailDatabaseContext(options))
{
var sut = new BarService(assertContext, mockCountryService, mockCityService, mockCocktailService, mockNotificationService);
await sut.AddBarAsync(barName, "se taq", "se taq", "se taq", "se taq", coverPhoto);
}
using (var assertContext = new CocktailDatabaseContext(options))
{
Assert.AreEqual(1, assertContext.Bars.Count());
var bar = await assertContext.Bars.FirstOrDefaultAsync(u => u.Name == barName);
Assert.IsNotNull(bar);
}
}
public IActionResult ModalRecetaBar(string idReceta)
{
Receta receta = new Receta();
BarService barService = new BarService();
Int32 recetaID = 0;
try
{
recetaID = Int32.Parse(idReceta);
}
catch (Exception)
{
recetaID = 121;
}
receta = barService.getRecetaByIdBar(recetaID);
List <Ingrediente> ingredientes = new List <Ingrediente>();
barService = null;
barService = new BarService();
ingredientes = barService.getIngredientesByIdRecetaBar(receta.IdReceta);
ViewData["DatosB"] = recetaID;
ViewData["recetaB"] = receta;
ViewData["ingredientesB"] = ingredientes;
return(View());
}
public async Task ReturnCorrectBarCount()
{
//arrange
int count = 2;
string testBarName1 = "TestName1";
string testBarName2 = "TestName2";
var mockCountryService = new Mock <ICountryService>().Object;
var mockCityService = new Mock <ICityService>().Object;
var mockCocktailService = new Mock <ICocktailService>().Object;
var mockNotificationService = new Mock <INotificationService>().Object;
var options = TestUtilities.GetOptions(nameof(ReturnCorrectBarCount));
using (var arrangeContext = new CocktailDatabaseContext(options))
{
arrangeContext.Bars.Add(new Bar()
{
Name = testBarName1
});
arrangeContext.Bars.Add(new Bar()
{
Name = testBarName2
});
arrangeContext.SaveChanges();
}
using (var assertContext = new CocktailDatabaseContext(options))
{
var sut = new BarService(assertContext, mockCountryService, mockCityService, mockCocktailService, mockNotificationService);
var barsCount = await sut.BarsCountAsync();
Assert.AreEqual(count, barsCount);
}
}
public async Task DeleteBarAsync_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(DeleteBarAsync_Correct));
var id = Guid.Parse("92a05c62-6f33-4dc9-bcc1-c9c946bf693a");
var city = new City()
{
Id = Guid.Parse("cc44371d-594f-4c47-a82b-e606bede8d3b"),
Name = "Varna"
};
var bar = new Bar()
{
Id = id,
Name = "Just another bar",
Phone = "0898878465",
CityId = Guid.Parse("cc44371d-594f-4c47-a82b-e606bede8d3b"), //Varna
Address = "62 Prof. Marin Drinov Str.",
};
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Bars.Add(bar);
await arrangeContext.SaveChangesAsync();
}
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarService(assertContext);
var result = await sut.DeleteBarAsync(id);
Assert.IsTrue(result);
}
}
public async Task ThrowArgumentNullException_WhenNoBarsExist()
{
//arrange
int testId = 9;
int testIdFail = 8;
string testBarName1 = "TestName1";
string testBarName2 = "TestName2";
var mockCountryService = new Mock <ICountryService>().Object;
var mockCityService = new Mock <ICityService>().Object;
var mockCocktailService = new Mock <ICocktailService>().Object;
var mockNotificationService = new Mock <INotificationService>().Object;
var options = TestUtilities.GetOptions(nameof(ThrowArgumentNullException_WhenNoBarsExist));
//using (var arrangeContext = new CocktailDatabaseContext(options))
//{
// arrangeContext.Bars.Add(new Bar() { Name = testBarName1, Id = testId });
// arrangeContext.Bars.Add(new Bar() { Name = testBarName2 });
// arrangeContext.SaveChanges();
//}
using (var assertContext = new CocktailDatabaseContext(options))
{
var sut = new BarService(assertContext, mockCountryService, mockCityService, mockCocktailService, mockNotificationService);
var bars = await sut.GetNewestBarsAsync();
}
}
public async Task MultiBarServerTest()
{
List <IBar> bars = BarMocks.UpMove(1000, (double)100).ToList();
BarPipeServer server = new BarPipeServer();
int i = 0;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
foreach (var bar in bars)
{
bar.BarId = 0;
bar.Period = 100;
BarService.AddBar(symbol, bar);
}
stopwatch.Stop();
Debug.WriteLine($"this took {stopwatch.ElapsedMilliseconds}");
Thread.Sleep(15000);
}
public async Task Return_ProperBarCount()
{
//Arrange
var mockIDateTimeProvider = new Mock <IDateTimeProvider>();
var mockIBarReviewService = new Mock <IBarReviewService>();
var mockIBarMapper = new Mock <IBarMapper>();
mockIBarMapper.Setup(b => b.MapToBarDTO(It.IsAny <Bar>()))
.Returns <Bar>(b => new BarDTO {
Name = b.Name
});
var options = Utils.GetOptions(nameof(Return_ProperBarCount));
Utils.GetInMemoryDataBase(options);
//Act & Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new BarService(mockIDateTimeProvider.Object, assertContext, mockIBarMapper.Object, mockIBarReviewService.Object);
var result = await sut.GetAllBarsAsync();
int barsCount = assertContext.Bars.Count();
Assert.AreEqual(barsCount, result.Count);
}
}
public async Task ThrowArgumentException_When_BarAlreadyExists()
{
var testBarName = "TestBarName";
var options = TestUtilities.GetOptions(nameof(ThrowArgumentException_When_BarAlreadyExists));
var barCreateRequest = new BarCreateRequest()
{
Name = testBarName
};
using (var arrangeContext = new AppDBContext(options))
{
await arrangeContext.Bars.AddAsync(new BarEntity()
{
Name = testBarName
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new AppDBContext(options))
{
var sut = new BarService(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.Create(barCreateRequest));
}
}
public async Task AddCocktailsToBar_When_BarIsCreated()
{
var testBarName = "TestBarName";
var testBarAddress = "TestBarAddress";
var options = TestUtilities.GetOptions(nameof(AddCocktailsToBar_When_BarIsCreated));
using (var actContext = new AppDBContext(options))
{
var sut = new BarService(actContext);
var barCreateRequest = new BarCreateRequest()
{
Name = testBarName,
Address = testBarAddress,
Cocktails = new List <int>()
{
1, 2, 3
}
};
var bar = sut.Create(barCreateRequest);
await actContext.SaveChangesAsync();
var barEntity = await actContext.Bars.FirstOrDefaultAsync(x => x.Name == testBarName);
Assert.AreEqual(3, barEntity.BarCocktails.Count());
}
}
public async Task SaveBarInDatabase()
{
var testBarName = "TestBarName";
var testBarAddress = "TestBarAddress";
var options = TestUtilities.GetOptions(nameof(SaveBarInDatabase));
using (var actContext = new AppDBContext(options))
{
var sut = new BarService(actContext);
var bar = await sut.Create(new BarCreateRequest()
{
Name = testBarName,
Address = testBarAddress,
Cocktails = new List <int>()
{
1, 2, 3
}
});
await actContext.SaveChangesAsync();
}
using (var assertContext = new AppDBContext(options))
{
var barEntity = await assertContext.Bars.FirstOrDefaultAsync(b => b.Name == testBarName);
Assert.IsNotNull(barEntity);
Assert.AreEqual(1, assertContext.Bars.Count());
}
}
public async Task ReturnEmpty_IfNoMatchesFound()
{
//Arrange
var mockIDateTimeProvider = new Mock <IDateTimeProvider>();
var mockIBarReviewService = new Mock <IBarReviewService>();
var mockIBarMapper = new Mock <IBarMapper>();
mockIBarMapper
.Setup(x => x.MapToBarDTO(It.IsAny <Bar>()))
.Returns <Bar>(b => new BarDTO {
Id = b.Id, Name = b.Name
});
var filter = "ZzzZ";
var orderBy = "name";
var direction = "asc";
var options = Utils.GetOptions(nameof(ReturnEmpty_IfNoMatchesFound));
Utils.GetInMemoryDataBase(options);
//Act & Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new BarService(mockIDateTimeProvider.Object, assertContext, mockIBarMapper.Object, mockIBarReviewService.Object);
var result = await sut.ListAllBarsAsync(0, 10, filter, orderBy, direction);
Assert.AreEqual(0, result.Count);
}
}
public async Task ReturnValid_StringFilter()
{
//Arrange
var mockIDateTimeProvider = new Mock <IDateTimeProvider>();
var mockIBarReviewService = new Mock <IBarReviewService>();
var mockIBarMapper = new Mock <IBarMapper>();
mockIBarMapper
.Setup(x => x.MapToBarDTO(It.IsAny <Bar>()))
.Returns <Bar>(b => new BarDTO {
Id = b.Id, Name = b.Name
});
var filter = "lOr";
var orderBy = "name";
var direction = "asc";
var options = Utils.GetOptions(nameof(ReturnValid_StringFilter));
Utils.GetInMemoryDataBase(options);
//Act & Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new BarService(mockIDateTimeProvider.Object, assertContext, mockIBarMapper.Object, mockIBarReviewService.Object);
var result = await sut.ListAllBarsAsync(0, 10, filter, orderBy, direction);
var expectedBar = result.FirstOrDefault(x => x.Name == "Lorka");
Assert.AreEqual(1, result.Count);
Assert.AreEqual("Lorka", expectedBar.Name);
}
}
private BarService CreateBarService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new BarService(userId);
return(service);
}
public async Task CreateCorrectInstance_Of_Type_BarDto()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CreateCorrectInstance_Of_Type_BarDto));
var mockDateTimeProvider = new Mock <IDateTimeProvider>();
var mockBarDtoMapper = new Mock <IDtoMapper <Bar, BarDTO> >();
var newBarDto = new BarDTO
{
Id = 1,
Name = "TestBar",
Info = "TestInfo",
Address = "TestAddress",
PhotoPath = "TestPath",
};
mockBarDtoMapper.Setup(x => x.MapDto(It.IsAny <Bar>())).Returns(newBarDto);
//Act and Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new BarService(assertContext, mockBarDtoMapper.Object, mockDateTimeProvider.Object);
var result = await sut.CreateBarAsync(newBarDto);
Assert.IsInstanceOfType(result, typeof(BarDTO));
Assert.AreEqual(1, result.Id);
Assert.AreEqual("TestBar", result.Name);
Assert.AreEqual("TestInfo", result.Info);
Assert.AreEqual("TestAddress", result.Address);
Assert.AreEqual("TestPath", result.PhotoPath);
}
}
public async Task CorrectlyRemoveCocktailsWhen_ParamsAreValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyRemoveCocktailsWhen_ParamsAreValid));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var cocktailGuid = Guid.NewGuid();
var bar1 = new Bar
{
Id = testGuid,
Name = "testBar1",
};
var barDto1 = new BarDto
{
Id = testGuid,
Name = "testBar1",
};
var list = new List <string> {
"Boza"
};
var cocktail = new Cocktail {
Id = cocktailGuid, Name = "Boza"
};
var barCocktail = new BarCocktail {
BarId = bar1.Id, CocktailId = cocktailGuid
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <Bar>())).Returns(barDto1);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar1);
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.BarCocktails.AddAsync(barCocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await sut.RemoveCocktailsAsync(barDto1, list);
var barCocktailEntity = await assertContext.BarCocktails.FirstAsync();
Assert.IsInstanceOfType(result, typeof(BarDto));
Assert.AreEqual("testBar1", result.Name);
Assert.AreEqual(true, barCocktailEntity.IsDeleted);
}
}
public async Task ReturnCorectTypeOfInstance()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorectTypeOfInstance));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var guid = Guid.NewGuid();
var entityDto = new BarDto
{
Id = guid,
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
ImagePath = "testImagePath",
Phone = "111-333-666"
};
var bar = new Bar
{
Id = guid,
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
ImagePath = "testImagePath",
Phone = "111-333-666"
};
var cocktail = new Cocktail
{
Id = Guid.NewGuid(),
Name = "testCocktail",
Info = "testCocktailInfo",
};
var list = new List <string>()
{
"testCocktail"
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await sut.AddCocktailsAsync(entityDto, list);
Assert.IsInstanceOfType(result, typeof(BarDto));
}
}
public void SetUp()
{
barContext = new BarContext();
InitData(barContext);
barService = new BarService(barContext);
}
public void Can_register_using_factory_delegate()
{
var container = new UnityContainer();
var myService = new BarService();
container.Configure(x => x.Register<IBarService>(c => myService));
Assert.That(container.Resolve<IBarService>(), Is.SameAs(myService));
}
public async Task ThrowWhen_NobarFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_NobarFound));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var guid = Guid.NewGuid();
var entityDto = new BarDto
{
Id = Guid.NewGuid(),
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
ImagePath = "testImagePath",
Phone = "111-333-666"
};
var bar = new Bar
{
Id = guid,
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
ImagePath = "testImagePath",
Phone = "111-333-666"
};
var cocktail = new Cocktail
{
Id = Guid.NewGuid(),
Name = "testCocktail",
Info = "testCocktailInfo",
};
var list = new List <string>()
{
"testCocktail"
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.AddCocktailsAsync(entityDto, list));
}
}
public void Can_register_a_func_with_parameters()
{
var container = new UnityContainer();
var myService = new BarService();
container.Configure(x => x.Register<Func<int, IBarService>>(c => i => myService));
Assert.That(container.Resolve<Func<int, IBarService>>()(1), Is.SameAs(myService));
}
public int DoSomethingUsesViewModelHere(int arg)
{
if (arg > 3)
{
var service = new BarService();
return(service.Method(arg - 3));
}
return(-1);
}
public async Task Should_UpdateBarCorrectly()
{
//arrange
string barName = "testName";
string barNewName = "testNewName";
int barId = 13;
int cocktailId = 6;
int cityId = 7;
string cityName = "CityName";
int countryId = 7;
string countryName = "CountryName";
string address = "testAddress";
string description = "testdescription";
var mockCountryService = new Mock <ICountryService>();
mockCountryService.Setup(p => p.CheckIfCountryExistsAsync(countryName))
.Returns(Task.FromResult(true));
mockCountryService.Setup(p => p.GetCountryByNameAsync(countryName))
.Returns(Task.FromResult(new Country()
{
Name = countryName, Id = countryId
}));
var mockCityService = new Mock <ICityService>();
mockCityService.Setup(p => p.CheckIfCityExistsAsync(cityName))
.Returns(Task.FromResult(true));
mockCityService.Setup(p => p.GetCityByNameAsync(cityName))
.Returns(Task.FromResult(new City()
{
Name = cityName, Id = cityId
}));
var mockCocktailService = new Mock <ICocktailService>().Object;
var mockNotificationService = new Mock <INotificationService>().Object;
var options = TestUtilities.GetOptions(nameof(Should_UpdateBarCorrectly));
using (var arrangeContext = new CocktailDatabaseContext(options))
{
arrangeContext.Bars.Add(new Bar()
{
Name = barName, Id = barId
});;
arrangeContext.SaveChanges();
}
using (var assertContext = new CocktailDatabaseContext(options))
{
var sut = new BarService(assertContext, mockCountryService.Object, mockCityService.Object, mockCocktailService, mockNotificationService);
await sut.UpdateBarAsync(barId, barNewName, address, description, countryName, cityName, null);
Assert.AreEqual(barNewName, assertContext.Bars.First().Name);
Assert.AreEqual(address, assertContext.Bars.First().Address);
Assert.AreEqual(description, assertContext.Bars.First().Description);
Assert.AreEqual(cityId, assertContext.Bars.First().CityId);
Assert.AreEqual(countryId, assertContext.Bars.First().CountryId);
}
}
public void Can_register_a_func_with_parameters()
{
var container = new UnityContainer();
var myService = new BarService();
container.Configure(x => x.Register <Func <int, IBarService> >(c => i => myService));
Assert.That(container.Resolve <Func <int, IBarService> >()(1), Is.SameAs(myService));
}
public void Can_register_using_factory_delegate()
{
var container = new UnityContainer();
var myService = new BarService();
container.Configure(x => x.Register <IBarService>(c => myService));
Assert.That(container.Resolve <IBarService>(), Is.SameAs(myService));
}
public async Task ReturnInstanceOfCollectionTypeBarDto()
{
var options = TestUtilities.GetOptions(nameof(ReturnInstanceOfCollectionTypeBarDto));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
var bar1 = new Bar
{
Id = testGuid,
Name = "testBar1",
};
var bar2 = new Bar
{
Id = testGuid2,
Name = "testBar2",
};
var list = new List <BarDto>()
{
new BarDto {
Id = testGuid, Name = "testBar1"
}, new BarDto {
Id = testGuid2, Name = "testBar2"
}
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <ICollection <Bar> >())).Returns(list);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar1);
await arrangeContext.Bars.AddAsync(bar2);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await sut.GetAllBarsAsync();
Assert.IsInstanceOfType(result, typeof(ICollection <BarDto>));
Assert.AreEqual(2, result.Count());
Assert.AreEqual(bar1.Name, result.First().Name);
Assert.AreEqual(bar1.Id, result.First().Id);
Assert.AreEqual(bar2.Name, result.Last().Name);
Assert.AreEqual(bar2.Id, result.Last().Id);
}
}
public async Task ReturnCorrectCollection_WhenParamsAreValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectCollection_WhenParamsAreValid));
var mockDateTimeProvider = new Mock <IDateTimeProvider>();
var mockBarDtoMapper = new Mock <IDtoMapper <Bar, BarDTO> >();
var newBar1 = new Bar
{
Id = 1,
Name = "TestBar1",
};
var newBar2 = new Bar
{
Id = 2,
Name = "TestBar2",
};
var newBar3 = new Bar
{
Id = 3,
Name = "TestBar3",
};
var list = new List <BarDTO>
{
new BarDTO {
Id = 1, Name = "TestBar1"
}, new BarDTO {
Id = 2, Name = "TestBar2"
}
};
mockBarDtoMapper.Setup(x => x.MapDto(It.IsAny <ICollection <Bar> >())).Returns(list);
using (var arrangeContext = new CocktailMagicianContext(options))
{
await arrangeContext.Bars.AddAsync(newBar1);
await arrangeContext.Bars.AddAsync(newBar2);
await arrangeContext.Bars.AddAsync(newBar3);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new BarService(assertContext, mockBarDtoMapper.Object, mockDateTimeProvider.Object);
var result = await sut.GetBarsForPeginationAsync(2, 1);
Assert.IsInstanceOfType(result, typeof(ICollection <BarDTO>));
Assert.AreEqual(2, result.Count);
Assert.AreEqual(1, result.First().Id);
Assert.AreEqual("TestBar1", result.First().Name);
Assert.AreEqual(2, result.Last().Id);
Assert.AreEqual("TestBar2", result.Last().Name);
}
}
