public async void Should_Return_Filtered_Vehicles()
{
// Arrange
var vehicles = DataProvider.GetVehicles();
var vehiclesMock = vehicles.AsQueryable().BuildMock();
var filter = new VehicleFilter
{
Manufacturer = "Ford"
};
var vehicleRepositoryMock = new Mock <IGenericRepository <Vehicle, int> >();
vehicleRepositoryMock.Setup(m => m.Get()).Returns(vehiclesMock.Object);
var vehicleController = new VehicleController(vehicleRepositoryMock.Object,
Mock.Of <IGenericRepository <VehicleModel, int> >(),
Mock.Of <IGenericRepository <Booking, int> >(),
Mock.Of <IGenericRepository <Insurance, int> >(),
MapperProvider.GetMapper());
// Act
var request = await vehicleController.Get(filter);
var result = request as OkObjectResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 200);
var dtos = result.Value as List <VehicleListItemDto>;
Assert.NotNull(dtos);
Assert.True(dtos.Count == 2);
}
public async void Should_Return_Vehicle_By_Id()
{
// Arrange
var vehicles = DataProvider.GetVehicles();
var bookingsMock = new List <Booking>().AsQueryable().BuildMock();
var vehicleRepositoryMock = new Mock <IGenericRepository <Vehicle, int> >();
vehicleRepositoryMock.Setup(m => m.GetById(It.IsAny <int>()))
.Returns <int>(id => Task.FromResult(vehicles.SingleOrDefault(v => v.Id == id)));
var bookingRepositoryMock = new Mock <IGenericRepository <Booking, int> >();
bookingRepositoryMock.Setup(m => m.Get())
.Returns(bookingsMock.Object);
var vehicleController = new VehicleController(vehicleRepositoryMock.Object,
Mock.Of <IGenericRepository <VehicleModel, int> >(),
bookingRepositoryMock.Object,
Mock.Of <IGenericRepository <Insurance, int> >(),
MapperProvider.GetMapper());
// Act
var request = await vehicleController.GetById(1);
var result = request as OkObjectResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 200);
}
private void SetupContainer()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new WebRequestLifestyle();
container.Register <IImageManager, ImageManager>();
container.Register <IFileNameHelper, FileNameHelper>();
container.Register <IRepository <Recipe>, GenericRepository <Recipe> >(Lifestyle.Scoped);
container.Register <IRepository <MealType>, GenericRepository <MealType> >(Lifestyle.Scoped);
container.Register <IRepository <Image>, GenericRepository <Image> >(Lifestyle.Scoped);
container.Register <IRepository <Author>, GenericRepository <Author> >(Lifestyle.Scoped);
container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
container.RegisterWebApiControllers(GlobalConfiguration.Configuration, Assembly.GetExecutingAssembly());
var mapperProvider = new MapperProvider();
container.RegisterSingleton(() => mapperProvider.GetMapper());
container.Verify();
GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
}
public void ComputePriceBasedOnBottle(
int buyerId,
int amount,
decimal expectedPrice
)
{
// arrange
using var mock = AutoMock.GetStrict(builder =>
builder.RegisterInstance(MapperProvider.GetMapper()));
mock.Mock <IBottleRepository>()
.Setup(repo => repo.GetBottleForPriceModel(100))
.Returns(Task.FromResult(GetBottle()));
var transaction = new TransactionForAdditionDto
{
BuyerId = buyerId,
Amount_ml = amount,
BottleId = 100
};
var operation = mock.Create <GetTransactionPriceOperation>();
// act
decimal actualPrice = operation.Run(transaction).Result;
// assert
Assert.AreEqual(expectedPrice, actualPrice, $"Computed price is different from expected price (expected: {expectedPrice}, actual: {actualPrice})");
}
protected TDestination TestMapping <TSource, TDestination>(TSource input, TDestination expected, Action <TDestination, TDestination> additionalAssert, params string[] exceptProperties)
{
// arrange
var mapper = MapperProvider.GetMapper();
// act
var actual = mapper.Map <TDestination>(input);
// assert
additionalAssert?.Invoke(expected, actual);
var propertiesToCheck =
typeof(TDestination)
.GetProperties()
.Where(p => !exceptProperties.Contains(p.Name));
foreach (var prop in propertiesToCheck)
{
Assert.AreEqual(prop.GetValue(expected), prop.GetValue(actual),
$"Unexpected value of property {typeof(TDestination).Name}.{prop.Name}");
}
// return mapping
return(actual);
}
public void NoMapping()
{
var provider = new MapperProvider();
provider.RegisterAssembly(Assembly.GetExecutingAssembly());
Assert.Throws <ArgumentOutOfRangeException>(() => provider.GetMapper <string>());
}
public void SingleMapping()
{
var provider = new MapperProvider();
provider.RegisterAssembly(Assembly.GetExecutingAssembly());
Assert.NotNull(provider.GetMapper <MapperProviderTests>());
}
public void MapperProvider_ProvidesMap()
{
// Arrange
var mappingProvider = new MapperProvider(null);
// Act
var mapping = mappingProvider.GetMapper();
// Assert
mapping.Should().NotBeNull();
mapping.ConfigurationProvider.Should().NotBeNull();
mapping.ConfigurationProvider.GetAllTypeMaps().Length.Should().Be(24);
}
protected TDestination TestMapping <TSource, TDestination>(TSource input, TDestination expected) where TDestination : IEquatable <TDestination>
{
// arrange
var mapper = MapperProvider.GetMapper();
// act
var actual = mapper.Map <TDestination>(input);
// assert
Assert.AreEqual(expected, actual);
// return mapping
return(actual);
}
public async void Should_Return_404_For_Bad_Id()
{
// Arrange
var vehicleModels = DataProvider.GetVehicleModels();
var vehicleModelRepositoryMock = new Mock <IGenericRepository <VehicleModel, int> >();
vehicleModelRepositoryMock.Setup(m => m.GetById(It.IsAny <int>()))
.Returns <int>(id => Task.FromResult(vehicleModels.SingleOrDefault(vm => vm.Id == id)));
var vehicleModelController = new VehicleModelController(vehicleModelRepositoryMock.Object,
Mock.Of <IGenericRepository <Vehicle, int> >(),
MapperProvider.GetMapper());
// Act
var request = await vehicleModelController.GetById(9001);
var result = request as NotFoundObjectResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 404);
}
public async void Should_Update_Vehicle()
{
// Arrange
var vehicles = DataProvider.GetVehicles();
var vehiclesMock = DataProvider.GetVehicles().AsQueryable().BuildMock();
var insurancesMock = new List <Insurance>().AsQueryable().BuildMock();
var updatedVehicle = new VehicleDto
{
Id = 1,
VehicleModelId = 3,
LocationCode = "333"
};
bool updated = false;
var vehicleRepositoryMock = new Mock <IGenericRepository <Vehicle, int> >();
vehicleRepositoryMock.Setup(m => m.Get()).Returns(vehiclesMock.Object);
vehicleRepositoryMock.Setup(m => m.Exists(It.IsAny <int>()))
.Returns <int>(id => Task.FromResult(vehicles.SingleOrDefault(v => v.Id == id) != null));
vehicleRepositoryMock.Setup(m => m.Update(It.IsAny <Vehicle>()))
.Returns(Task.FromResult(true))
.Callback((Vehicle vehicle) => { updated = true; });
var insuranceRepositoryMock = new Mock <IGenericRepository <Insurance, int> >();
insuranceRepositoryMock.Setup(m => m.Get()).Returns(insurancesMock.Object);
var vehicleController = new VehicleController(vehicleRepositoryMock.Object,
Mock.Of <IGenericRepository <VehicleModel, int> >(),
Mock.Of <IGenericRepository <Booking, int> >(),
insuranceRepositoryMock.Object,
MapperProvider.GetMapper());
// Act
var request = await vehicleController.Update(updatedVehicle.Id, updatedVehicle);
var result = request as OkResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 200);
Assert.True(updated);
}
public async void Should_Return_VehicleModels()
{
// Arrange
var vehicleModelsQueryable = DataProvider.GetVehicleModels().AsQueryable().BuildMock();
var vehicleModelRepositoryMock = new Mock <IGenericRepository <VehicleModel, int> >();
vehicleModelRepositoryMock.Setup(m => m.Get())
.Returns(vehicleModelsQueryable.Object);
var vehicleModelController = new VehicleModelController(vehicleModelRepositoryMock.Object,
Mock.Of <IGenericRepository <Vehicle, int> >(),
MapperProvider.GetMapper());
// Act
var request = await vehicleModelController.Get(new VehicleModelFilter());
var result = request as OkObjectResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 200);
var dtos = result.Value as List <VehicleModelDto>;
Assert.NotNull(dtos);
Assert.True(dtos.Count == 3);
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = mapperProvider.GetMapper<ProvinceMapper>();
province = GetProvince();
}
public DataFacade(MapperProvider mappperProvider)
{
this.countryMapper = mappperProvider.GetMapper<CountryMapper>();
this.provinceMapper = mappperProvider.GetMapper<ProvinceMapper>();
this.userMapper = mappperProvider.GetMapper<UserMapper>();
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = mapperProvider.GetMapper <CountryMapper>();
country = GetCountry();
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = mapperProvider.GetMapper<UserMapper>();
user = GetUser();
}
public async Task GetArticlesByTextFilter_ReturnsArticlesThatFitFilter(int count, string filter)
{
//Arrange
var data = new List <Article>
{
new Article {
Title = "Cats", Content = "Cats are awesome"
},
new Article {
Title = "Dogs", Content = "Dogs are human friends"
},
new Article {
Title = "HotDog", Content = "Today I going to eat hotdog"
},
new Article {
Title = "Bengal", Content = "Cat with tiger fur"
},
new Article {
Title = "Summer", Content = "This summer is hot"
}
}.AsQueryable().BuildMockDbSet();
var mockContext = new Mock <BlogDbContext>();
mockContext.Setup(c => c.Set <Article>()).Returns(data.Object);
var service = new ArticleService(new UnitOfWork(mockContext.Object), null, null, MapperProvider.GetMapper());
//Act
var filtered = await service.GetArticlesByTextFilter(filter);
//Assert
Assert.Equal(count, filtered.Count());
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = mapperProvider.GetMapper <ProvinceMapper>();
province = GetProvince();
}
private void RegisterMapping()
{
_objectContainer.RegisterInstanceAs(MapperProvider.GetMapper(
new MappingConfiguration()
));
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = mapperProvider.GetMapper<CountryMapper>();
country = GetCountry();
}
private static void RegisterMapping(ContainerBuilder builder)
{
builder.RegisterInstance(MapperProvider.GetMapper(
new MappingConfiguration()
));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddIdentityCore <User>(opt =>
{
opt.Password.RequireNonAlphanumeric = false;
})
.AddRoles <Role>()
.AddRoleManager <RoleManager <Role> >()
.AddSignInManager <SignInManager <User> >()
.AddRoleValidator <RoleValidator <Role> >()
.AddEntityFrameworkStores <DataContext>();
services.AddControllers();
services.AddMvc()
.AddFluentValidation(config => config.RegisterValidatorsFromAssemblyContaining <Models.User.UserModel>());
//Sqlite database
services.AddDbContext <DataContext>(
optBuilder => optBuilder.UseSqlite(
Configuration.GetConnectionString("SqliteConnection"),
b => b.MigrationsAssembly("WhiskyMan.API"))
);
services.AddSingleton(MapperProvider.GetMapper());
services.AddScoped <AuthService>();
services.AddScoped <DataContext>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IBottleRepository, BottleRepository>();
services.AddScoped <IDataContextWrapper, DataContextWrapper>();
services.AddScoped <IBottleDescriptionRepository, BottleDescriptionRepository>();
services.AddScoped <IUserManagerWrapper, UserManagerWrapper>();
services.AddScoped <ISignInManagerWrapper, SignInManagerWrapper>();
services.AddScoped <IRoleManagerWrapper, RoleManagerWrapper>();
services.AddScoped <UpdateRolesOperation>();
services.AddHttpContextAccessor();
services.AddScoped <IRequestBodyAccessor, RequestBodyAccessor>();
services.AddScoped <GetTransactionPriceOperation>();
services.AddScoped <ITransactionRepository, TransactionRepository>();
services.AddScoped <ITransactionFacade, TransactionFacade>();
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).
AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters()
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(
Encoding.UTF8.GetBytes(Configuration.GetSection("AppSettings:Token").Value)),
ValidateIssuer = false,
ValidateAudience = false
};
});
// policies
services.AddScoped <IAuthorizationHandler, AddOwnTransactionHandler>();
services.AddScoped <IAuthorizationHandler, ViewOwnUserInfoHandler>();
services.AddAuthorization(opt =>
{
opt.AddPolicy(TransactionPolicies.AddOwnTransaction, policy =>
policy.Requirements.Add(new AddOwnTransactionRequirement()));
opt.AddPolicy(UserPolicies.ViewOwnUserInfo, policy =>
policy.Requirements.Add(new ViewOwnUserInfoRequirement()));
});
}
public void Init()
{
mapperProvider = new MapperProvider();
sut = mapperProvider.GetMapper <UserMapper>();
user = GetUser();
}
