public void GetAllData_EmptyManufactures_0()
{
var result = new List <Manufacturer>
{
new Manufacturer
{
Id = 1,
Country = "1",
Name = "1n"
},
new Manufacturer
{
Id = 2,
Country = "2",
Name = "2n"
}
};
var mock = new Mock <IAsyncRepository>();
mock.Setup(s => s.GetAll <Manufacturer>())
.Returns <string>(_ =>
{
return(result);
});
var repository = mock.Object;
var service = new ManufacturerService(repository);
var allManufacturers = service.GetAllManufacturers();
Assert.Equal(result.Count, allManufacturers.Count);
}
public async Task SearchTest()
{
var movies = new List <Manufacturer>
{
new Manufacturer()
{
Name = "Dias"
},
new Manufacturer()
{
Name = "Said"
},
};
var fakeRepositoryMock = new Mock <IManufacturerRepository>();
fakeRepositoryMock.Setup(x => x.GetManufacturerWithPredicate(It.IsAny <Expression <Func <Manufacturer, bool> > >())).ReturnsAsync(movies);
var manufacturerService = new ManufacturerService(fakeRepositoryMock.Object);
var resultManufacturers = await manufacturerService.Search("Dias");
Assert.Collection(resultManufacturers, manufacturer =>
{
Assert.Equal("Dias", manufacturer.Name);
},
manufacturer =>
{
Assert.Equal("Said", manufacturer.Name);
});
}
public void GetAll_ShouldReturnAll_Manufacturers_SortedBy_Name()
{
//Arrange
MockRepository mockRepo = new MockRepository();
var manufacturers = new List <Manufacturer> {
new Manufacturer {
Name = "ZZZZ"
},
new Manufacturer {
Name = "AAAA"
},
new Manufacturer {
Name = "CCCC"
}
}.AsQueryable();
var contextMock = mockRepo.StrictMock <EF6DemoDataContext>();
var dbSetMock = mockRepo.StrictMock <MockableDbSet <Manufacturer> >();
contextMock.Expect(x => x.Manufacturers).Return(dbSetMock);
dbSetMock.Expect(x => x.Provider).Return(manufacturers.Provider);
dbSetMock.Expect(x => x.Expression).Return(manufacturers.Expression);
mockRepo.ReplayAll();
var service = new ManufacturerService(contextMock);
//Act
var result = service.GetAll();
//Assert
mockRepo.VerifyAll();
result.Count.Should().Be(3);
result[0].Name.Should().Be("AAAA");
result[1].Name.Should().Be("CCCC");
result[2].Name.Should().Be("ZZZZ");
}
public async Task GetManufacturersTest()
{
var manufacturers = new List <Manufacturer>
{
new Manufacturer()
{
Name = "Said", Address = "USA LA"
},
new Manufacturer()
{
Name = "Said", Address = "USA LA"
},
};
var fakeRepositoryMock = new Mock <IManufacturerRepository>();
fakeRepositoryMock.Setup(x => x.GetManufacturers()).ReturnsAsync(manufacturers);
var manufacturerService = new ManufacturerService(fakeRepositoryMock.Object);
var resultManufacturers = await manufacturerService.GetManufacturers();
Assert.Collection(resultManufacturers, manufacturer =>
{
Assert.Equal("Said", manufacturer.Name);
},
manufacturer =>
{
Assert.Equal("USA LA", manufacturer.Address);
});
}
public void DeleteManufacturer(int id)
{
manufacturers = new List <Manufacturer>()
{
new Manufacturer {
ManufacturerId = 1
},
new Manufacturer {
ManufacturerId = 2
},
new Manufacturer {
ManufacturerId = 3
},
};
Assert.Equal(3, manufacturers.Count);
Assert.True(manufacturers.Exists(m => m.ManufacturerId == id));
IManufacturerService service = new ManufacturerService(repoMock.Object, null);
Manufacturer manufacturer = service.DeleteManufacturer(id);
Assert.Equal(2, manufacturers.Count);
Assert.False(manufacturers.Exists(m => m.ManufacturerId == id));
repoMock.Verify(repo => repo.RemoveManufacturer(It.IsAny <int>()), Times.Once);
}
public static List <Manufacturer> GetManufacturers()
{
var entityService = new ManufacturerService();
var results = entityService.GetAll().OfType <Manufacturer>().OrderBy(m => m.Name).ToList();
return(results);
}
public async Task <IHttpActionResult> Get(int id)
{
ManufacturerService manufacturerService = CreateManufacturerService();
var manufacturer = await manufacturerService.GetManufacturerById(id);
return(Ok(manufacturer));
}
public void CreateManufacturer_ManufacturerWithIdAlreadyExists_ExpectInvalidOperationException(int manuId)
{
manufacturers = new List <Manufacturer>
{
new Manufacturer {
ManufacturerId = 1
},
new Manufacturer {
ManufacturerId = 2
},
new Manufacturer {
ManufacturerId = 3
}
};
Manufacturer manufacturer = new Manufacturer {
ManufacturerId = manuId
};
IManufacturerService service = new ManufacturerService(repoMock.Object, null);
var ex = Assert.Throws <InvalidOperationException>(() =>
{
service.CreateManufacturer(manufacturer);
});
Assert.Equal("Manufacturer ID can not match car which already exists", ex.Message);
Assert.True(manufacturers.Count == 3);
Assert.True(manufacturers.Where(m => m.ManufacturerId == manuId).ToList().Count == 1);
repoMock.Verify(repo => repo.AddManufacturer(It.IsAny <Manufacturer>()), Times.Never);
}
public async Task <IHttpActionResult> Get()
{
ManufacturerService manufacturerService = CreateManufacturerService();
var manufacturers = await manufacturerService.GetManufacturer();
return(Ok(manufacturers));
}
public void DeleteManufacturer_NoManufacturerWithId_ExpectInvalidOperationException(int id)
{
manufacturers = new List <Manufacturer>()
{
new Manufacturer {
ManufacturerId = 2
},
new Manufacturer {
ManufacturerId = 3
},
new Manufacturer {
ManufacturerId = 4
},
};
Assert.Equal(3, manufacturers.Count);
IManufacturerService service = new ManufacturerService(repoMock.Object, null);
Manufacturer manufacturer = null;
var ex = Assert.Throws <InvalidOperationException>(() =>
{
manufacturer = service.DeleteManufacturer(id);
});
Assert.Equal(3, manufacturers.Count);
Assert.Null(manufacturer);
Assert.Equal("Can not delete manufacturer as no manufacturer with this ID can be found", ex.Message);
repoMock.Verify(repo => repo.RemoveManufacturer(It.IsAny <int>()), Times.Never);
}
public async Task ManufacturerService_Should_Update_Manufacturer()
{
// Arrange
SetUpUnitOfWork();
var service = new ManufacturerService(_unitOfWork.Object, _mapper);
var entity = new ManufacturerDTO()
{
Name = "TestName",
};
var newEntity = new ManufacturerDTO()
{
Name = "NewTestName",
};
await service.CreateAsync(entity);
await _unitOfWork.Object.SaveAsync();
// Act
entity.Name = newEntity.Name;
await service.UpdateAsync(entity);
await _unitOfWork.Object.SaveAsync();
// Assert
Assert.NotNull(entity);
Assert.Equal(newEntity.Name, entity.Name);
}
public Service(ApplicationDbContext context)
{
//repository
BillingAddressRepository = new Repository <BillingAddress>(context);
CategoryRepository = new Repository <Category>(context);
ImageRepository = new Repository <Image>(context);
ReviewRepository = new Repository <Review>(context);
ManufacturerRepository = new Repository <Manufacturer>(context);
OrderRepository = new Repository <Order>(context);
OrderCountRepository = new Repository <OrderCount>(context);
OrderItemRepository = new Repository <OrderItem>(context);
ProductRepository = new Repository <Product>(context);
ProductCategoryMapping = new Repository <ProductCategoryMapping>(context);
ProductImageMapping = new Repository <ProductImageMapping>(context);
ProductManufacturerMapping = new Repository <ProductManufacturerMapping>(context);
ContactUsMessageRepository = new Repository <ContactUsMessage>(context);
VisitorCountRepository = new Repository <VisitorCount>(context);
//service
CategoryService = new CategoryService(context, CategoryRepository, ProductCategoryMapping);
ProductService = new ProductService(context, ProductRepository);
ImageManagerService = new ImageManagerService(ImageRepository, ProductImageMapping);
ManufacturerService = new ManufacturerService(context, ManufacturerRepository, ProductManufacturerMapping);
ReviewService = new ReviewService(context, ReviewRepository);
SpecificationService = new SpecificationService(context, SpecificationRepository, ProductSpecificationMapping);
ContactUsService = new ContactUsService(ContactUsMessageRepository);
OrderService = new OrderService(OrderRepository, OrderItemRepository, OrderCountService, context);
OrderCountService = new OrderCountService(OrderCountRepository);
VisitorCountService = new VisitorCountService(VisitorCountRepository, context);
}
public void DeleteManufacturer_IdIsNotPositive_ExpectArgumentException(int id)
{
manufacturers = new List <Manufacturer>()
{
new Manufacturer {
ManufacturerId = 1
},
new Manufacturer {
ManufacturerId = 2
},
new Manufacturer {
ManufacturerId = 3
},
};
Assert.Equal(3, manufacturers.Count);
IManufacturerService service = new ManufacturerService(repoMock.Object, null);
Manufacturer manufacturer = null;
var ex = Assert.Throws <ArgumentException>(() =>
{
manufacturer = service.DeleteManufacturer(id);
});
Assert.Equal(3, manufacturers.Count);
Assert.Null(manufacturer);
Assert.Equal("ID of the manufacturer to delete must be a positive integer", ex.Message);
repoMock.Verify(repo => repo.RemoveManufacturer(It.IsAny <int>()), Times.Never);
}
public async Task GetAllWithCars_should_return_all_available_manufacturers_with_empty_list_of_cars_when_no_cars_associated()
{
// arrange
var manufacturers = new[] { new Manufacturer {
Name = "subaru"
} };
SetupMockDbContext(manufacturers);
IEnumerable <ManufacturerWithCarsDto> returnedManufacturers;
using (var context = new ApplicationContext(_dbContextOptions))
{
var service = new ManufacturerService(context);
// act
returnedManufacturers = await service.GetAllWithCars();
}
// assert
returnedManufacturers.Should().HaveSameCount(manufacturers);
returnedManufacturers
.Should()
.BeEquivalentTo(manufacturers,
options => options.ExcludingMissingMembers());
returnedManufacturers.SelectMany(x => x.Cars).Should().BeEmpty();
}
public void GetManufacturerById_NoManufacturerFound_ExpectNullReferenceException(int id)
{
manufacturers = new List <Manufacturer>()
{
new Manufacturer {
ManufacturerId = 2, Name = "Toyota"
},
new Manufacturer {
ManufacturerId = 3, Name = "Peugeot"
},
new Manufacturer {
ManufacturerId = 4, Name = "Ford"
},
};
IManufacturerService service = new ManufacturerService(repoMock.Object, null);
Manufacturer manufacturer = null;
var ex = Assert.Throws <NullReferenceException>(() =>
{
manufacturer = service.GetManufacturerById(id);
});
Assert.Equal("Manufacturer with this ID not found", ex.Message);
Assert.Null(manufacturer);
repoMock.Verify(repo => repo.ReadManufacturerById(It.IsAny <int>()), Times.Once);
}
static void Main(string[] args)
{
var carController = new CarController();
var detailController = new DetailController();
var manufacturerController = new ManufacturerCollection();
var manufacturerService = new ManufacturerService();
var allDetailsController = detailController.GetAll();
//detailController.Add(null);
//detailController.Delete(24);
//var fifthDetail = detailController.GetById(9);
//detailController.Update(null);
//var allCarViewModels = carController.GetAll();
//carController.Add(null);
//carController.Delete(6);
//var secondCar = carController.GetCarById(1);
//carController.Update(null);
var allManuf = manufacturerController.GetAll();
var mostexpensive = manufacturerService.GetMostExpensive();
Console.ReadKey();
}
static void Main(string[] args)
{
var carController = new CarsController();
var detailController = new DetailsController();
var manufacturerController = new ManufacturerController();
var manufacturerService = new ManufacturerService();
//var allCars = carController.GetAll();
//var carById = carController.GetId(1);
var allDetails = detailController.GetAll();
//var detailById = detailController.GetId(2);
//detailController.Insert(null);
//detailController.Update(null);
//detailController.Delete(1002);
carController.Add(null);
//carController.Update(null);
//carController.Delete(6);
var allManufacturers = manufacturerController.GetAll();
//var richcars = manufacturerController.GetRich();
var mostexpensive = manufacturerService.GetMostExpensive();
Console.ReadKey();
}
public void UpdateManufacturerUsingUpsertTest()
{
TestManufacturer.ManufacturerName = TestManufacturerName + " updated";
ManufacturerService.Upsert(TestManufacturer, TestUserPrincipal);
var foundManufacturers = ManufacturerService.Search(TestManufacturerName + " updated").ToList();
Assert.AreEqual(1, foundManufacturers.Count);
Assert.AreEqual(foundManufacturers.First().ManufacturerName, TestManufacturer.ManufacturerName);
}
public void Constructor_Should_CreateManufacturerServices_IfParamsAreValid()
{
// Arrange & Act
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <Manufacturer> >();
var manufacturerService = new ManufacturerService(mockedDbSet.Object);
// Assert
Assert.That(manufacturerService, Is.InstanceOf <ManufacturerService>());
}
public void GetById_Should_NotBeCalled_IfNotCalledYolo()
{
// Arrange & Act
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <Manufacturer> >();
var manufacturerService = new ManufacturerService(mockedDbSet.Object);
// Assert
mockedDbSet.Verify(rep => rep.GetById(1), Times.Never);
}
public void GetAllManufacturers_Should_NotBeCalled_IfItIsNeverCalled()
{
// Arrange & Act
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <Manufacturer> >();
var manufacturerService = new ManufacturerService(mockedDbSet.Object);
// Assert
mockedDbSet.Verify(rep => rep.All(), Times.Never);
}
public void GetById_ShouldThrowNullReferenceException_IfManufacturerIsNull()
{
// Arrange & Act
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <Manufacturer> >();
var manufacturerService = new ManufacturerService(mockedDbSet.Object);
Mock <Manufacturer> manufacturerThatIsNull = null;
// Assert
Assert.Throws <NullReferenceException>(() => manufacturerService.GetById(manufacturerThatIsNull.Object.Id));
}
private void BindManufacturers()
{
var manufacturers = ManufacturerService.GetAllManufacturers();
if (manufacturers.Count > 0)
{
rptrManufacturers.DataSource = manufacturers;
rptrManufacturers.DataBind();
}
}
public async Task DeleteTest()
{
var fakeRepository = Mock.Of <IManufacturerRepository>();
var manufacturerService = new ManufacturerService(fakeRepository);
var manufacturer = new Manufacturer()
{
Name = "Dias", Address = "USA LA"
};
await manufacturerService.Delete(manufacturer);
}
public void CreateManufacturerService_RepositoryIsNull_ExpectArgumentException()
{
IManufacturerService service = null;
var ex = Assert.Throws <ArgumentException>(() =>
{
service = new ManufacturerService(null, null);
});
Assert.Equal("Manufacturer repository is missing", ex.Message);
Assert.Null(service);
}
public void GetById_Should_NotReturnManufacturer_IfThereIsNoManufacturerYolo()
{
// Arrange
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <Manufacturer> >();
var manufacturerService = new ManufacturerService(mockedDbSet.Object);
// Act
mockedDbSet.Setup(rep => rep.GetById(0)).Returns(() => null);
// Assert
Assert.IsNull(manufacturerService.GetById(0));
}
public AddUpdateGoodViewModel()
{
var cotext = new ShopContext();
categoryService = new CategoryService(new CategoryRepository(cotext), new UnitOfWork(cotext));
manufacturerService = new ManufacturerService(new ManufacturerRepository(cotext), new UnitOfWork(cotext));
InitCommands();
Categories = categoryService.GetAll().Select(x => x.CategoryName.ToString()).ToList();
Manufacturers = manufacturerService.GetAll().Select(x => x.ManufacturerName.ToString()).ToList();
}
public void SoftDeleteManufacturerTest()
{
var foundManufacturers = ManufacturerService.Search(TestManufacturerName).ToList();
Assert.AreEqual(1, foundManufacturers.Count);
ManufacturerService.SoftDelete(foundManufacturers.First().ManufacturerId, TestUserPrincipal);
var softDeletedManufacturer = ManufacturerService.Search(TestManufacturerName).ToList();
Assert.AreEqual(1, softDeletedManufacturer.Count);
Assert.IsTrue(softDeletedManufacturer.First().IsDeleted);
}
public MainViewModel(GoodService goodService, CategoryService categoryService, ManufacturerService manufacturerService)
{
this.goodService = goodService;
this.categoryService = categoryService;
this.manufacturerService = manufacturerService;
Categories = new ObservableCollection <CategoryDTO>(categoryService.GetAll());
Goods = new ObservableCollection <GoodDTO>(goodService.GetAll());
Manufacturers = new ObservableCollection <ManufacturerDTO>(manufacturerService.GetAll());
InitCommands();
}
public void GetAllManufacturers_Should_BeCalled_IfParamsAreValid()
{
// Arrange
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <Manufacturer> >();
var manufacturerService = new ManufacturerService(mockedDbSet.Object);
// Act
manufacturerService.GetAllManufacturers();
// Assert
mockedDbSet.Verify(rep => rep.All(), Times.Once);
}
