public GetImageTests()
{
defaultServiceId = "default";
mockedService = new Mock <IStockImageService>();
mockedService.Setup(s => s.Id).Returns(defaultServiceId);
provider = new StockImageProvider(mockedService.Object);
}
public void ItExists()
{
// Act
var provider = new StockImageProvider();
// Assert
Assert.NotNull(provider);
}
public void HasServices()
{
// Act
var provider = new StockImageProvider();
// Assert
Assert.NotNull(provider.Services);
Assert.IsAssignableFrom <IEnumerable <IStockImageService> >(provider.Services);
Assert.NotEmpty(provider.Services);
}
public void DoesNotHaveServicesDisabledByType()
{
// DisablingByTypeService has an attribute:
//[DisableService(typeof(DisabledByTypeService))]
// Act
var provider = new StockImageProvider();
// Assert
Assert.Contains(provider.Services, s => s.Id == DisablingByTypeService.UniqueId);
Assert.DoesNotContain(provider.Services, s => s.Id == DisabledByTypeService.UniqueId);
}
public void RemovesDuplicateServices()
{
// Arrange
// Using one of our fakes, doesn't matter which one, as long as the IDs are the same
var service = new DisabledByIdService();
var duplicateService = new DisabledByIdService();
// Act
var provider = new StockImageProvider(service, duplicateService);
// Assert
Assert.Single(provider.Services);
Assert.Contains(provider.Services, s => s.Id == service.Id);
}
public void ThrowsWhenNoValidService()
{
// Arrange
var emptyProvider = new StockImageProvider(new IStockImageService[] { });
// Act
var exception = Record.ExceptionAsync(async() => await emptyProvider.GetRandomImage());
// Assert
Assert.NotNull(exception);
Assert.NotNull(exception.Result);
Assert.IsAssignableFrom <NoValidServiceException>(exception.Result);
Assert.Equal("No available services support random images.", exception.Result.Message);
}
public void AcceptsSpecificServices()
{
// Arrange
// Using two of our fakes, doesn't matter which ones
var firstService = new DisabledByIdService();
var secondService = new DisabledByTypeService();
// Act
var provider = new StockImageProvider(firstService, secondService);
// Assert
Assert.Equal(2, provider.Services.Count());
Assert.Contains(provider.Services, s => s.Id == firstService.Id);
Assert.Contains(provider.Services, s => s.Id == secondService.Id);
}
public async Task CallsCorrectService()
{
// Arrange
const string imageId = "XXXXXXXX";
mockedService.Setup(s => s.GetImage(It.IsAny <string>())).ReturnsAsync((StockImageModel)null);
var otherService = new Mock <IStockImageService>();
otherService.Setup(s => s.Id).Returns("other");
otherService.Setup(s => s.GetImage(It.IsAny <string>())).ReturnsAsync((StockImageModel)null);
var imageProvider = new StockImageProvider(otherService.Object, mockedService.Object);
// Act
await imageProvider.GetImage(imageId, defaultServiceId);
// Assert
mockedService.Verify(s => s.GetImage(It.IsAny <string>()), Times.Once);
otherService.Verify(s => s.GetImage(It.IsAny <string>()), Times.Never);
}
public async Task OnlyCallsServicesWithRandomEnabled()
{
// Arrange
mockedService.Setup(s => s.Id).Returns("1");
mockedService.Setup(s => s.GetRandomImage()).ReturnsAsync((StockImageModel)null);
var randomDisabledService = new Mock <IStockImageService>();
randomDisabledService.Setup(s => s.Id).Returns("2");
randomDisabledService.Setup(s => s.RandomImageEnabled).Returns(false);
randomDisabledService.Setup(s => s.GetRandomImage()).ReturnsAsync((StockImageModel)null);
var random = Mock.Of <Random>(r => r.Next(It.IsAny <int>()) == 0);
var randomProvider = new StockImageProvider(randomDisabledService.Object, mockedService.Object);
// Act
await randomProvider.GetRandomImage(random);
// Assert
mockedService.Verify(s => s.GetRandomImage(), Times.Once);
randomDisabledService.Verify(s => s.GetRandomImage(), Times.Never);
}
public GetRandomImageTests()
{
mockedService = new Mock <IStockImageService>();
mockedService.Setup(s => s.RandomImageEnabled).Returns(true);
provider = new StockImageProvider(mockedService.Object);
}
