public async Task GetAllCompanyTrucksByUserIdAsync_WithIncorectUserId_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
var order = new Order()
{
Id = "orderId",
IsDeleted = false,
ExpireTime = DateTime.UtcNow.AddDays(7),
Truck = new Truck(),
SteuUser = new SteuUser()
{
Id = "asdasd",
Company = new Company()
{
Id = "companyId",
},
},
};
await repository.AddAsync(order);
await repository.SaveChangesAsync();
await Assert.ThrowsAsync <ArgumentNullException>(()
=> service.GetAllCompanyTrucksByUserIdAsync(1, 10, "userId"));
}
public async Task GetTruckDetailsByIdAsync_WithCorrectData_ShouldReturnDetailsTruckViewModel()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
var order = new Order()
{
Id = "orderId",
IsDeleted = false,
ExpireTime = DateTime.UtcNow.AddDays(7),
Truck = new Truck(),
SteuUser = new SteuUser()
{
Id = "asdasd",
FirstName = "Pesho",
},
};
await repository.AddAsync(order);
await repository.SaveChangesAsync();
var actualresutlt = await service.GetTruckDetailsByIdAsync <DetailsTruckViewModel>("orderId");
Assert.Equal("Pesho", actualresutlt.SteuUserFirstName);
}
public async Task GetCountOfTrucksAsync_WithData_ShouldReturnCount()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
var order = new Order()
{
Id = "orderId",
IsDeleted = false,
ExpireTime = DateTime.UtcNow.AddDays(7),
Truck = new Truck(),
SteuUser = new SteuUser()
{
Id = "userId",
},
};
await repository.AddAsync(order);
await repository.SaveChangesAsync();
var actualResult = await service.GetCountOfTrucksAsync();
Assert.Equal(1, actualResult);
}
public async Task EditTruckAsync_WithIncorectOrderId_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
await repository.AddAsync(new Order()
{
Id = "asdasd",
Truck = new Truck(),
});
await context.SaveChangesAsync();
EditTruckViewModel model = new EditTruckViewModel()
{
Id = "asd",
CountryFrom = "Bulgaria",
TownFrom = "Sofia",
CountryTo = "Croatia",
TownTo = "Zagreb",
TruckTypeName = "Normal",
Priority = "Normal",
Circle = false,
ExpireTime = DateTime.UtcNow,
LoadTime = DateTime.UtcNow,
MaxVolume = 100,
MaxLoad = 20000,
Price = 12312231,
Referer = "dasada",
InputModel = new TruckEditViewModel(),
};
await Assert.ThrowsAsync <ArgumentNullException>(() => service.EditTruckAsync(model));
}
public async Task CreateTruckAsyncTest_WithCorrectData_ShouldReturnTruck()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
AddTrucksInputModel model = new AddTrucksInputModel()
{
CountryFrom = "Bulgaria",
TownFrom = "Sofia",
CountryTo = "Croatia",
TownTo = "Zagreb",
TruckTypeName = "Normal",
SteuUserId = "asdasd",
Priority = "Normal",
Circle = false,
ExpireTime = DateTime.UtcNow,
InputModel = new TruckCreateViewModel(),
LoadTime = DateTime.UtcNow,
MaxVolume = 100,
MaxLoad = 20000,
Price = 12312231,
Referer = "dasada",
};
await service.CreateTruckAsync(model, "asdasd");
var actualResult = await repository.All().ToListAsync();
Assert.Single(actualResult);
}
public async Task CreateTruckAsyncTest_WithNullModelPropery_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
AddTrucksInputModel model = new AddTrucksInputModel()
{
CountryFrom = null,
TownFrom = "Sofia",
CountryTo = "Croatia",
TownTo = "Zagreb",
TruckTypeName = "Normal",
SteuUserId = "asdasd",
Priority = "Normal",
Circle = false,
ExpireTime = DateTime.UtcNow,
InputModel = new TruckCreateViewModel(),
LoadTime = DateTime.UtcNow,
MaxVolume = 100,
MaxLoad = 20000,
Price = 12312231,
Referer = "dasada",
};
await Assert.ThrowsAsync <ArgumentNullException>(()
=> service.CreateTruckAsync(model, "asdasd"));
}
public async Task GetTruckDetailsByIdAsync_WithNullOrderId_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
var order = new Order()
{
Id = "orderId",
IsDeleted = false,
ExpireTime = DateTime.UtcNow.AddDays(7),
Truck = new Truck(),
SteuUser = new SteuUser()
{
Id = "asdasd",
FirstName = "Pesho",
},
};
await repository.AddAsync(order);
await repository.SaveChangesAsync();
await Assert.ThrowsAsync <ArgumentNullException>(()
=> service.GetTruckDetailsByIdAsync <DetailsTruckViewModel>(null));
}
public async Task GetAllCompanyTrucksByUserIdAsync_WithNonUserTrucks_ShouldReturnEmptyList()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
var order = new Order()
{
Id = "orderId",
IsDeleted = false,
ExpireTime = DateTime.UtcNow.AddDays(7),
Truck = new Truck(),
SteuUser = new SteuUser()
{
Id = "userId",
Company = new Company()
{
Id = "company",
},
},
};
await repository.AddAsync(order);
await repository.SaveChangesAsync();
var actualResult = await service.GetAllCompanyTrucksByUserIdAsync(1, 10, "asdasd");
Assert.Empty(actualResult);
}
public async Task GetCountOfTrucksAsync_WithOutData_ShouldReturnZero()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var actualResult = await service.GetCountOfTrucksAsync();
Assert.Equal(0, actualResult);
}
public async Task GetAllAvaibleTrucksAsync_WithoutData_ShouldReturnEmptyList()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var actualResult = await service.GetAllAvaibleTrucksAsync(1, 10);
Assert.Empty(actualResult);
}
private static TrucksService IntializeLoadService(SteuDbContext context)
{
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Order>(context);
var userService = new Mock <IUsersService>();
userService.Setup(x => x.GetUserByIdAsync("asdasd"))
.ReturnsAsync(new SteuUser()
{
UserName = "******",
FirstName = "Pesho",
Id = "asdasd",
Company = new Company()
{
Id = "companyId",
},
});
var countriesService = new Mock <ICountriesService>();
var townService = new Mock <ITownsService>();
var truckTypesService = new Mock <ITruckTypesService>();
truckTypesService.Setup(x => x.GetTruckTypeByNameAsync("Normal"))
.Returns(Task.FromResult(new TruckType()
{
Name = "Normal"
}));
var priorityTypesService = new Mock <IPriorityTypesService>();
priorityTypesService.Setup(x => x.GetPriorityTypeByNameAsync("Normal"))
.Returns(Task.FromResult(new PriorityType()
{
Name = "Normal"
}));
var mapper = new Mock <IMapper>();
mapper.Setup(
x => x.Map <DetailsTruckViewModel>(It.IsAny <Order>()))
.Returns(new DetailsTruckViewModel()
{
SteuUserFirstName = "Pesho"
});
var addressesService = new Mock <IAddressesService>();
var service = new TrucksService(
repository,
addressesService.Object,
mapper.Object,
priorityTypesService.Object,
truckTypesService.Object,
userService.Object);
return(service);
}
public async Task DeleteTruckByIdAsyncTest_WithIncorrectData_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
var order = new Order()
{
Id = "asdasd",
};
await repository.AddAsync(order);
await repository.SaveChangesAsync();
await Assert.ThrowsAsync <ArgumentNullException>(()
=> service.DeleteTruckByIdAsync("asd"));
}
public async Task GetAllAvaibleTrucksAsync_WithCorrectData_ShouldReturnListOfTrucks()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
await repository.AddAsync(new Order()
{
Id = "asdasd",
Truck = new Truck(),
ExpireTime = DateTime.UtcNow.AddDays(7),
IsDeleted = false,
});
await context.SaveChangesAsync();
var actualResult = await service.GetAllAvaibleTrucksAsync(1, 10);
Assert.Single(actualResult);
}
public async Task DeleteTruckByIdAsyncTest_WithCorrectData_ShouldTruckIsDeletedTrue()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
var order = new Order()
{
Id = "asdasd",
};
await repository.AddAsync(order);
await repository.SaveChangesAsync();
var orders = await context.Orders.ToListAsync();
await service.DeleteTruckByIdAsync("asdasd");
Assert.True(orders[0].IsDeleted);
}
public async Task EditTruckAsync_WithCorrectData_ShouldEditTruck()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
await repository.AddAsync(new Order()
{
Id = "asdasd",
Truck = new Truck(),
});
await context.SaveChangesAsync();
EditTruckViewModel model = new EditTruckViewModel()
{
Id = "asdasd",
CountryFrom = "Bulgaria",
TownFrom = "Sofia",
CountryTo = "Croatia",
TownTo = "Zagreb",
TruckTypeName = "Normal",
Priority = "Normal",
Circle = false,
ExpireTime = DateTime.UtcNow,
LoadTime = DateTime.UtcNow,
MaxVolume = 100,
MaxLoad = 20000,
Price = 12312231,
Referer = "dasada",
InputModel = new TruckEditViewModel(),
};
await service.EditTruckAsync(model);
var actualResult = await repository.All().ToListAsync();
Assert.Equal(12312231, actualResult[0].Price);
}
public async Task GetAllAvaibleTrucksBySearchAsync_WhithNonExistingLoad_ShoulRetunEmptyList()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TrucksService service = IntializeLoadService(context);
var repository = new EfDeletableEntityRepository <Order>(context);
await repository.AddAsync(new Order()
{
AddressFrom = new Address()
{
Country = new Country()
{
Name = "Bulgaria"
},
Town = new Town()
{
Name = "Sofia"
},
},
ExpireTime = DateTime.UtcNow.AddDays(7),
IsDeleted = false,
Truck = new Truck(),
});
await context.SaveChangesAsync();
SearchTruckInputModel model = new SearchTruckInputModel()
{
CountryTo = "Bulgaria",
};
var actualResult =
await service.GetAllAvaibleTrucksBySearchAsync <AllAvaibleTrucksBySearchViewModel>(model);
Assert.Empty(actualResult);
}
public void SetUp()
{
_productRepository = A.Fake <IProductRepository>();
_trucksService = new TrucksService(_productRepository);
A.CallTo(() => _productRepository.GetProductById(17)).Returns(TestProduct);
}
