public async void Delete()
        {
            var mock  = new ServiceMockFacade <ILessonRepository>();
            var model = new ApiLessonRequestModel();

            mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.CompletedTask);
            var service = new LessonService(mock.LoggerMock.Object,
                                            mock.RepositoryMock.Object,
                                            mock.ModelValidatorMockFactory.LessonModelValidatorMock.Object,
                                            mock.BOLMapperMockFactory.BOLLessonMapperMock,
                                            mock.DALMapperMockFactory.DALLessonMapperMock,
                                            mock.BOLMapperMockFactory.BOLLessonXStudentMapperMock,
                                            mock.DALMapperMockFactory.DALLessonXStudentMapperMock,
                                            mock.BOLMapperMockFactory.BOLLessonXTeacherMapperMock,
                                            mock.DALMapperMockFactory.DALLessonXTeacherMapperMock);

            ActionResponse response = await service.Delete(default(int));

            response.Should().NotBeNull();
            mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <int>()));
            mock.ModelValidatorMockFactory.LessonModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
        }
        public async void All()
        {
            var mock    = new ServiceMockFacade <ILessonRepository>();
            var records = new List <Lesson>();

            records.Add(new Lesson());
            mock.RepositoryMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
            var service = new LessonService(mock.LoggerMock.Object,
                                            mock.RepositoryMock.Object,
                                            mock.ModelValidatorMockFactory.LessonModelValidatorMock.Object,
                                            mock.BOLMapperMockFactory.BOLLessonMapperMock,
                                            mock.DALMapperMockFactory.DALLessonMapperMock,
                                            mock.BOLMapperMockFactory.BOLLessonXStudentMapperMock,
                                            mock.DALMapperMockFactory.DALLessonXStudentMapperMock,
                                            mock.BOLMapperMockFactory.BOLLessonXTeacherMapperMock,
                                            mock.DALMapperMockFactory.DALLessonXTeacherMapperMock);

            List <ApiLessonResponseModel> response = await service.All();

            response.Should().HaveCount(1);
            mock.RepositoryMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
        }
        public async void All()
        {
            var mock    = new ServiceMockFacade <IFamilyRepository>();
            var records = new List <Family>();

            records.Add(new Family());
            mock.RepositoryMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
            var service = new FamilyService(mock.LoggerMock.Object,
                                            mock.RepositoryMock.Object,
                                            mock.ModelValidatorMockFactory.FamilyModelValidatorMock.Object,
                                            mock.BOLMapperMockFactory.BOLFamilyMapperMock,
                                            mock.DALMapperMockFactory.DALFamilyMapperMock,
                                            mock.BOLMapperMockFactory.BOLStudentMapperMock,
                                            mock.DALMapperMockFactory.DALStudentMapperMock,
                                            mock.BOLMapperMockFactory.BOLStudentXFamilyMapperMock,
                                            mock.DALMapperMockFactory.DALStudentXFamilyMapperMock);

            List <ApiFamilyResponseModel> response = await service.All();

            response.Should().HaveCount(1);
            mock.RepositoryMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
        }
        public async void Create()
        {
            var mock  = new ServiceMockFacade <IFamilyRepository>();
            var model = new ApiFamilyRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Family>())).Returns(Task.FromResult(new Family()));
            var service = new FamilyService(mock.LoggerMock.Object,
                                            mock.RepositoryMock.Object,
                                            mock.ModelValidatorMockFactory.FamilyModelValidatorMock.Object,
                                            mock.BOLMapperMockFactory.BOLFamilyMapperMock,
                                            mock.DALMapperMockFactory.DALFamilyMapperMock,
                                            mock.BOLMapperMockFactory.BOLStudentMapperMock,
                                            mock.DALMapperMockFactory.DALStudentMapperMock,
                                            mock.BOLMapperMockFactory.BOLStudentXFamilyMapperMock,
                                            mock.DALMapperMockFactory.DALStudentXFamilyMapperMock);

            CreateResponse <ApiFamilyResponseModel> response = await service.Create(model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.FamilyModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiFamilyRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Create(It.IsAny <Family>()));
        }
        public async void Students_Exists()
        {
            var mock    = new ServiceMockFacade <IFamilyRepository>();
            var records = new List <Student>();

            records.Add(new Student());
            mock.RepositoryMock.Setup(x => x.Students(default(int), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
            var service = new FamilyService(mock.LoggerMock.Object,
                                            mock.RepositoryMock.Object,
                                            mock.ModelValidatorMockFactory.FamilyModelValidatorMock.Object,
                                            mock.BOLMapperMockFactory.BOLFamilyMapperMock,
                                            mock.DALMapperMockFactory.DALFamilyMapperMock,
                                            mock.BOLMapperMockFactory.BOLStudentMapperMock,
                                            mock.DALMapperMockFactory.DALStudentMapperMock,
                                            mock.BOLMapperMockFactory.BOLStudentXFamilyMapperMock,
                                            mock.DALMapperMockFactory.DALStudentXFamilyMapperMock);

            List <ApiStudentResponseModel> response = await service.Students(default(int));

            response.Should().NotBeEmpty();
            mock.RepositoryMock.Verify(x => x.Students(default(int), It.IsAny <int>(), It.IsAny <int>()));
        }
        public async void Create()
        {
            var mock  = new ServiceMockFacade <IUnitMeasureRepository>();
            var model = new ApiUnitMeasureRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <UnitMeasure>())).Returns(Task.FromResult(new UnitMeasure()));
            var service = new UnitMeasureService(mock.LoggerMock.Object,
                                                 mock.RepositoryMock.Object,
                                                 mock.ModelValidatorMockFactory.UnitMeasureModelValidatorMock.Object,
                                                 mock.BOLMapperMockFactory.BOLUnitMeasureMapperMock,
                                                 mock.DALMapperMockFactory.DALUnitMeasureMapperMock,
                                                 mock.BOLMapperMockFactory.BOLBillOfMaterialMapperMock,
                                                 mock.DALMapperMockFactory.DALBillOfMaterialMapperMock,
                                                 mock.BOLMapperMockFactory.BOLProductMapperMock,
                                                 mock.DALMapperMockFactory.DALProductMapperMock);

            CreateResponse <ApiUnitMeasureResponseModel> response = await service.Create(model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.UnitMeasureModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiUnitMeasureRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Create(It.IsAny <UnitMeasure>()));
        }
        public async void ProductsByWeightUnitMeasureCode_Exists()
        {
            var mock    = new ServiceMockFacade <IUnitMeasureRepository>();
            var records = new List <Product>();

            records.Add(new Product());
            mock.RepositoryMock.Setup(x => x.ProductsByWeightUnitMeasureCode(default(string), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
            var service = new UnitMeasureService(mock.LoggerMock.Object,
                                                 mock.RepositoryMock.Object,
                                                 mock.ModelValidatorMockFactory.UnitMeasureModelValidatorMock.Object,
                                                 mock.BOLMapperMockFactory.BOLUnitMeasureMapperMock,
                                                 mock.DALMapperMockFactory.DALUnitMeasureMapperMock,
                                                 mock.BOLMapperMockFactory.BOLBillOfMaterialMapperMock,
                                                 mock.DALMapperMockFactory.DALBillOfMaterialMapperMock,
                                                 mock.BOLMapperMockFactory.BOLProductMapperMock,
                                                 mock.DALMapperMockFactory.DALProductMapperMock);

            List <ApiProductResponseModel> response = await service.ProductsByWeightUnitMeasureCode(default(string));

            response.Should().NotBeEmpty();
            mock.RepositoryMock.Verify(x => x.ProductsByWeightUnitMeasureCode(default(string), It.IsAny <int>(), It.IsAny <int>()));
        }
        public async void Create()
        {
            var mock  = new ServiceMockFacade <ILessonRepository>();
            var model = new ApiLessonRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Lesson>())).Returns(Task.FromResult(new Lesson()));
            var service = new LessonService(mock.LoggerMock.Object,
                                            mock.RepositoryMock.Object,
                                            mock.ModelValidatorMockFactory.LessonModelValidatorMock.Object,
                                            mock.BOLMapperMockFactory.BOLLessonMapperMock,
                                            mock.DALMapperMockFactory.DALLessonMapperMock,
                                            mock.BOLMapperMockFactory.BOLLessonXStudentMapperMock,
                                            mock.DALMapperMockFactory.DALLessonXStudentMapperMock,
                                            mock.BOLMapperMockFactory.BOLLessonXTeacherMapperMock,
                                            mock.DALMapperMockFactory.DALLessonXTeacherMapperMock);

            CreateResponse <ApiLessonResponseModel> response = await service.Create(model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.LessonModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiLessonRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Create(It.IsAny <Lesson>()));
        }
Beispiel #9
0
        public async void SalesOrderHeaderSalesReasons_Exists()
        {
            var mock    = new ServiceMockFacade <ISalesOrderHeaderRepository>();
            var records = new List <SalesOrderHeaderSalesReason>();

            records.Add(new SalesOrderHeaderSalesReason());
            mock.RepositoryMock.Setup(x => x.SalesOrderHeaderSalesReasons(default(int), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
            var service = new SalesOrderHeaderService(mock.LoggerMock.Object,
                                                      mock.RepositoryMock.Object,
                                                      mock.ModelValidatorMockFactory.SalesOrderHeaderModelValidatorMock.Object,
                                                      mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
                                                      mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock,
                                                      mock.BOLMapperMockFactory.BOLSalesOrderDetailMapperMock,
                                                      mock.DALMapperMockFactory.DALSalesOrderDetailMapperMock,
                                                      mock.BOLMapperMockFactory.BOLSalesOrderHeaderSalesReasonMapperMock,
                                                      mock.DALMapperMockFactory.DALSalesOrderHeaderSalesReasonMapperMock);

            List <ApiSalesOrderHeaderSalesReasonResponseModel> response = await service.SalesOrderHeaderSalesReasons(default(int));

            response.Should().NotBeEmpty();
            mock.RepositoryMock.Verify(x => x.SalesOrderHeaderSalesReasons(default(int), It.IsAny <int>(), It.IsAny <int>()));
        }
        public async void Delete()
        {
            var mock  = new ServiceMockFacade <IUnitMeasureRepository>();
            var model = new ApiUnitMeasureRequestModel();

            mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <string>())).Returns(Task.CompletedTask);
            var service = new UnitMeasureService(mock.LoggerMock.Object,
                                                 mock.RepositoryMock.Object,
                                                 mock.ModelValidatorMockFactory.UnitMeasureModelValidatorMock.Object,
                                                 mock.BOLMapperMockFactory.BOLUnitMeasureMapperMock,
                                                 mock.DALMapperMockFactory.DALUnitMeasureMapperMock,
                                                 mock.BOLMapperMockFactory.BOLBillOfMaterialMapperMock,
                                                 mock.DALMapperMockFactory.DALBillOfMaterialMapperMock,
                                                 mock.BOLMapperMockFactory.BOLProductMapperMock,
                                                 mock.DALMapperMockFactory.DALProductMapperMock);

            ActionResponse response = await service.Delete(default(string));

            response.Should().NotBeNull();
            mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <string>()));
            mock.ModelValidatorMockFactory.UnitMeasureModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <string>()));
        }
        public async void All()
        {
            var mock    = new ServiceMockFacade <IUnitMeasureRepository>();
            var records = new List <UnitMeasure>();

            records.Add(new UnitMeasure());
            mock.RepositoryMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
            var service = new UnitMeasureService(mock.LoggerMock.Object,
                                                 mock.RepositoryMock.Object,
                                                 mock.ModelValidatorMockFactory.UnitMeasureModelValidatorMock.Object,
                                                 mock.BOLMapperMockFactory.BOLUnitMeasureMapperMock,
                                                 mock.DALMapperMockFactory.DALUnitMeasureMapperMock,
                                                 mock.BOLMapperMockFactory.BOLBillOfMaterialMapperMock,
                                                 mock.DALMapperMockFactory.DALBillOfMaterialMapperMock,
                                                 mock.BOLMapperMockFactory.BOLProductMapperMock,
                                                 mock.DALMapperMockFactory.DALProductMapperMock);

            List <ApiUnitMeasureResponseModel> response = await service.All();

            response.Should().HaveCount(1);
            mock.RepositoryMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
        }
        public async void Delete()
        {
            var mock  = new ServiceMockFacade <IProductModelRepository>();
            var model = new ApiProductModelRequestModel();

            mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.CompletedTask);
            var service = new ProductModelService(mock.LoggerMock.Object,
                                                  mock.RepositoryMock.Object,
                                                  mock.ModelValidatorMockFactory.ProductModelModelValidatorMock.Object,
                                                  mock.BOLMapperMockFactory.BOLProductModelMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductMapperMock,
                                                  mock.DALMapperMockFactory.DALProductMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductModelProductDescriptionCultureMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelProductDescriptionCultureMapperMock);

            ActionResponse response = await service.Delete(default(int));

            response.Should().NotBeNull();
            mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <int>()));
            mock.ModelValidatorMockFactory.ProductModelModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
        }
Beispiel #13
0
        public async void Create()
        {
            var mock  = new ServiceMockFacade <ISalesOrderHeaderRepository>();
            var model = new ApiSalesOrderHeaderRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <SalesOrderHeader>())).Returns(Task.FromResult(new SalesOrderHeader()));
            var service = new SalesOrderHeaderService(mock.LoggerMock.Object,
                                                      mock.RepositoryMock.Object,
                                                      mock.ModelValidatorMockFactory.SalesOrderHeaderModelValidatorMock.Object,
                                                      mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
                                                      mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock,
                                                      mock.BOLMapperMockFactory.BOLSalesOrderDetailMapperMock,
                                                      mock.DALMapperMockFactory.DALSalesOrderDetailMapperMock,
                                                      mock.BOLMapperMockFactory.BOLSalesOrderHeaderSalesReasonMapperMock,
                                                      mock.DALMapperMockFactory.DALSalesOrderHeaderSalesReasonMapperMock);

            CreateResponse <ApiSalesOrderHeaderResponseModel> response = await service.Create(model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.SalesOrderHeaderModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiSalesOrderHeaderRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Create(It.IsAny <SalesOrderHeader>()));
        }
Beispiel #14
0
        public async void Delete()
        {
            var mock  = new ServiceMockFacade <ISalesOrderHeaderRepository>();
            var model = new ApiSalesOrderHeaderRequestModel();

            mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.CompletedTask);
            var service = new SalesOrderHeaderService(mock.LoggerMock.Object,
                                                      mock.RepositoryMock.Object,
                                                      mock.ModelValidatorMockFactory.SalesOrderHeaderModelValidatorMock.Object,
                                                      mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
                                                      mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock,
                                                      mock.BOLMapperMockFactory.BOLSalesOrderDetailMapperMock,
                                                      mock.DALMapperMockFactory.DALSalesOrderDetailMapperMock,
                                                      mock.BOLMapperMockFactory.BOLSalesOrderHeaderSalesReasonMapperMock,
                                                      mock.DALMapperMockFactory.DALSalesOrderHeaderSalesReasonMapperMock);

            ActionResponse response = await service.Delete(default(int));

            response.Should().NotBeNull();
            mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <int>()));
            mock.ModelValidatorMockFactory.SalesOrderHeaderModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
        }
        public async void Create()
        {
            var mock  = new ServiceMockFacade <IProductModelRepository>();
            var model = new ApiProductModelRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <ProductModel>())).Returns(Task.FromResult(new ProductModel()));
            var service = new ProductModelService(mock.LoggerMock.Object,
                                                  mock.RepositoryMock.Object,
                                                  mock.ModelValidatorMockFactory.ProductModelModelValidatorMock.Object,
                                                  mock.BOLMapperMockFactory.BOLProductModelMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductMapperMock,
                                                  mock.DALMapperMockFactory.DALProductMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductModelProductDescriptionCultureMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelProductDescriptionCultureMapperMock);

            CreateResponse <ApiProductModelResponseModel> response = await service.Create(model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.ProductModelModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiProductModelRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Create(It.IsAny <ProductModel>()));
        }
        public async void ProductModelProductDescriptionCulturesByProductModelID_Exists()
        {
            var mock    = new ServiceMockFacade <IProductModelRepository>();
            var records = new List <ProductModelProductDescriptionCulture>();

            records.Add(new ProductModelProductDescriptionCulture());
            mock.RepositoryMock.Setup(x => x.ProductModelProductDescriptionCulturesByProductModelID(default(int), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
            var service = new ProductModelService(mock.LoggerMock.Object,
                                                  mock.RepositoryMock.Object,
                                                  mock.ModelValidatorMockFactory.ProductModelModelValidatorMock.Object,
                                                  mock.BOLMapperMockFactory.BOLProductModelMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductMapperMock,
                                                  mock.DALMapperMockFactory.DALProductMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductModelProductDescriptionCultureMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelProductDescriptionCultureMapperMock);

            List <ApiProductModelProductDescriptionCultureResponseModel> response = await service.ProductModelProductDescriptionCulturesByProductModelID(default(int));

            response.Should().NotBeEmpty();
            mock.RepositoryMock.Verify(x => x.ProductModelProductDescriptionCulturesByProductModelID(default(int), It.IsAny <int>(), It.IsAny <int>()));
        }
        public async void Get()
        {
            var mock   = new ServiceMockFacade <IStudentRepository>();
            var record = new Student();

            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(record));
            var service = new StudentService(mock.LoggerMock.Object,
                                             mock.RepositoryMock.Object,
                                             mock.ModelValidatorMockFactory.StudentModelValidatorMock.Object,
                                             mock.BOLMapperMockFactory.BOLStudentMapperMock,
                                             mock.DALMapperMockFactory.DALStudentMapperMock,
                                             mock.BOLMapperMockFactory.BOLLessonXStudentMapperMock,
                                             mock.DALMapperMockFactory.DALLessonXStudentMapperMock,
                                             mock.BOLMapperMockFactory.BOLLessonXTeacherMapperMock,
                                             mock.DALMapperMockFactory.DALLessonXTeacherMapperMock,
                                             mock.BOLMapperMockFactory.BOLStudentXFamilyMapperMock,
                                             mock.DALMapperMockFactory.DALStudentXFamilyMapperMock);

            ApiStudentResponseModel response = await service.Get(default(int));

            response.Should().NotBeNull();
            mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>()));
        }
Beispiel #18
0
        public async void Get()
        {
            var mock   = new ServiceMockFacade <IBusinessEntityRepository>();
            var record = new BusinessEntity();

            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(record));
            var service = new BusinessEntityService(mock.LoggerMock.Object,
                                                    mock.RepositoryMock.Object,
                                                    mock.ModelValidatorMockFactory.BusinessEntityModelValidatorMock.Object,
                                                    mock.BOLMapperMockFactory.BOLBusinessEntityMapperMock,
                                                    mock.DALMapperMockFactory.DALBusinessEntityMapperMock,
                                                    mock.BOLMapperMockFactory.BOLBusinessEntityAddressMapperMock,
                                                    mock.DALMapperMockFactory.DALBusinessEntityAddressMapperMock,
                                                    mock.BOLMapperMockFactory.BOLBusinessEntityContactMapperMock,
                                                    mock.DALMapperMockFactory.DALBusinessEntityContactMapperMock,
                                                    mock.BOLMapperMockFactory.BOLPersonMapperMock,
                                                    mock.DALMapperMockFactory.DALPersonMapperMock);

            ApiBusinessEntityResponseModel response = await service.Get(default(int));

            response.Should().NotBeNull();
            mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>()));
        }
        public async void Update()
        {
            var mock  = new ServiceMockFacade <ITeacherSkillRepository>();
            var model = new ApiTeacherSkillRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <TeacherSkill>())).Returns(Task.FromResult(new TeacherSkill()));
            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(new TeacherSkill()));
            var service = new TeacherSkillService(mock.LoggerMock.Object,
                                                  mock.RepositoryMock.Object,
                                                  mock.ModelValidatorMockFactory.TeacherSkillModelValidatorMock.Object,
                                                  mock.BOLMapperMockFactory.BOLTeacherSkillMapperMock,
                                                  mock.DALMapperMockFactory.DALTeacherSkillMapperMock,
                                                  mock.BOLMapperMockFactory.BOLRateMapperMock,
                                                  mock.DALMapperMockFactory.DALRateMapperMock,
                                                  mock.BOLMapperMockFactory.BOLTeacherXTeacherSkillMapperMock,
                                                  mock.DALMapperMockFactory.DALTeacherXTeacherSkillMapperMock);

            UpdateResponse <ApiTeacherSkillResponseModel> response = await service.Update(default(int), model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.TeacherSkillModelValidatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiTeacherSkillRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Update(It.IsAny <TeacherSkill>()));
        }
Beispiel #20
0
        public async void Update()
        {
            var mock  = new ServiceMockFacade <IVendorRepository>();
            var model = new ApiVendorRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Vendor>())).Returns(Task.FromResult(new Vendor()));
            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(new Vendor()));
            var service = new VendorService(mock.LoggerMock.Object,
                                            mock.RepositoryMock.Object,
                                            mock.ModelValidatorMockFactory.VendorModelValidatorMock.Object,
                                            mock.BOLMapperMockFactory.BOLVendorMapperMock,
                                            mock.DALMapperMockFactory.DALVendorMapperMock,
                                            mock.BOLMapperMockFactory.BOLProductVendorMapperMock,
                                            mock.DALMapperMockFactory.DALProductVendorMapperMock,
                                            mock.BOLMapperMockFactory.BOLPurchaseOrderHeaderMapperMock,
                                            mock.DALMapperMockFactory.DALPurchaseOrderHeaderMapperMock);

            UpdateResponse <ApiVendorResponseModel> response = await service.Update(default(int), model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.VendorModelValidatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiVendorRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Update(It.IsAny <Vendor>()));
        }
Beispiel #21
0
        public async void Delete_Errors()
        {
            var mock          = new ServiceMockFacade <ITransactionRepository>();
            var model         = new ApiTransactionServerRequestModel();
            var validatorMock = new Mock <IApiTransactionServerRequestModelValidator>();

            validatorMock.Setup(x => x.ValidateDeleteAsync(It.IsAny <int>())).Returns(Task.FromResult(new FluentValidation.Results.ValidationResult(new List <ValidationFailure>()
            {
                new ValidationFailure("text", "test")
            })));
            var service = new TransactionService(mock.LoggerMock.Object,
                                                 mock.MediatorMock.Object,
                                                 mock.RepositoryMock.Object,
                                                 validatorMock.Object,
                                                 mock.DALMapperMockFactory.DALTransactionMapperMock);

            ActionResponse response = await service.Delete(default(int));

            response.Should().NotBeNull();
            response.Success.Should().BeFalse();
            validatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
            mock.MediatorMock.Verify(x => x.Publish(It.IsAny <TransactionDeletedNotification>(), It.IsAny <CancellationToken>()), Times.Never());
        }
Beispiel #22
0
        public async void Create_NoErrors()
        {
            var mock  = new ServiceMockFacade <IArtistRepository>();
            var model = new ApiArtistServerRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Artist>())).Returns(Task.FromResult(new Artist()));
            var service = new ArtistService(mock.LoggerMock.Object,
                                            mock.MediatorMock.Object,
                                            mock.RepositoryMock.Object,
                                            mock.ModelValidatorMockFactory.ArtistModelValidatorMock.Object,
                                            mock.DALMapperMockFactory.DALArtistMapperMock,
                                            mock.DALMapperMockFactory.DALBankAccountMapperMock,
                                            mock.DALMapperMockFactory.DALEmailMapperMock,
                                            mock.DALMapperMockFactory.DALTransactionMapperMock);

            CreateResponse <ApiArtistServerResponseModel> response = await service.Create(model);

            response.Should().NotBeNull();
            response.Success.Should().BeTrue();
            mock.ModelValidatorMockFactory.ArtistModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiArtistServerRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Create(It.IsAny <Artist>()));
            mock.MediatorMock.Verify(x => x.Publish(It.IsAny <ArtistCreatedNotification>(), It.IsAny <CancellationToken>()));
        }
        public async void Update()
        {
            var mock  = new ServiceMockFacade <ILocationRepository>();
            var model = new ApiLocationRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Location>())).Returns(Task.FromResult(new Location()));
            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <short>())).Returns(Task.FromResult(new Location()));
            var service = new LocationService(mock.LoggerMock.Object,
                                              mock.RepositoryMock.Object,
                                              mock.ModelValidatorMockFactory.LocationModelValidatorMock.Object,
                                              mock.BOLMapperMockFactory.BOLLocationMapperMock,
                                              mock.DALMapperMockFactory.DALLocationMapperMock,
                                              mock.BOLMapperMockFactory.BOLProductInventoryMapperMock,
                                              mock.DALMapperMockFactory.DALProductInventoryMapperMock,
                                              mock.BOLMapperMockFactory.BOLWorkOrderRoutingMapperMock,
                                              mock.DALMapperMockFactory.DALWorkOrderRoutingMapperMock);

            UpdateResponse <ApiLocationResponseModel> response = await service.Update(default(short), model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.LocationModelValidatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <short>(), It.IsAny <ApiLocationRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Update(It.IsAny <Location>()));
        }
Beispiel #24
0
        public async void Get()
        {
            var mock   = new ServiceMockFacade <IEmployeeRepository>();
            var record = new Employee();

            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(record));
            var service = new EmployeeService(mock.LoggerMock.Object,
                                              mock.RepositoryMock.Object,
                                              mock.ModelValidatorMockFactory.EmployeeModelValidatorMock.Object,
                                              mock.BOLMapperMockFactory.BOLEmployeeMapperMock,
                                              mock.DALMapperMockFactory.DALEmployeeMapperMock,
                                              mock.BOLMapperMockFactory.BOLEmployeeDepartmentHistoryMapperMock,
                                              mock.DALMapperMockFactory.DALEmployeeDepartmentHistoryMapperMock,
                                              mock.BOLMapperMockFactory.BOLEmployeePayHistoryMapperMock,
                                              mock.DALMapperMockFactory.DALEmployeePayHistoryMapperMock,
                                              mock.BOLMapperMockFactory.BOLJobCandidateMapperMock,
                                              mock.DALMapperMockFactory.DALJobCandidateMapperMock);

            ApiEmployeeResponseModel response = await service.Get(default(int));

            response.Should().NotBeNull();
            mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>()));
        }
Beispiel #25
0
        public async void Update()
        {
            var mock  = new ServiceMockFacade <ICurrencyRepository>();
            var model = new ApiCurrencyRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Currency>())).Returns(Task.FromResult(new Currency()));
            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <string>())).Returns(Task.FromResult(new Currency()));
            var service = new CurrencyService(mock.LoggerMock.Object,
                                              mock.RepositoryMock.Object,
                                              mock.ModelValidatorMockFactory.CurrencyModelValidatorMock.Object,
                                              mock.BOLMapperMockFactory.BOLCurrencyMapperMock,
                                              mock.DALMapperMockFactory.DALCurrencyMapperMock,
                                              mock.BOLMapperMockFactory.BOLCountryRegionCurrencyMapperMock,
                                              mock.DALMapperMockFactory.DALCountryRegionCurrencyMapperMock,
                                              mock.BOLMapperMockFactory.BOLCurrencyRateMapperMock,
                                              mock.DALMapperMockFactory.DALCurrencyRateMapperMock);

            UpdateResponse <ApiCurrencyResponseModel> response = await service.Update(default(string), model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.CurrencyModelValidatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <string>(), It.IsAny <ApiCurrencyRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Update(It.IsAny <Currency>()));
        }
        public async void Get()
        {
            var mock   = new ServiceMockFacade <IProductModelRepository>();
            var record = new ProductModel();

            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(record));
            var service = new ProductModelService(mock.LoggerMock.Object,
                                                  mock.RepositoryMock.Object,
                                                  mock.ModelValidatorMockFactory.ProductModelModelValidatorMock.Object,
                                                  mock.BOLMapperMockFactory.BOLProductModelMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductMapperMock,
                                                  mock.DALMapperMockFactory.DALProductMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductModelIllustrationMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelIllustrationMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductModelProductDescriptionCultureMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelProductDescriptionCultureMapperMock);

            ApiProductModelResponseModel response = await service.Get(default(int));

            response.Should().NotBeNull();
            mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>()));
        }
        public async void Create_Errors()
        {
            var mock          = new ServiceMockFacade <IBankAccountRepository>();
            var model         = new ApiBankAccountServerRequestModel();
            var validatorMock = new Mock <IApiBankAccountServerRequestModelValidator>();

            validatorMock.Setup(x => x.ValidateCreateAsync(It.IsAny <ApiBankAccountServerRequestModel>())).Returns(Task.FromResult(new FluentValidation.Results.ValidationResult(new List <ValidationFailure>()
            {
                new ValidationFailure("text", "test")
            })));
            var service = new BankAccountService(mock.LoggerMock.Object,
                                                 mock.MediatorMock.Object,
                                                 mock.RepositoryMock.Object,
                                                 validatorMock.Object,
                                                 mock.DALMapperMockFactory.DALBankAccountMapperMock);

            CreateResponse <ApiBankAccountServerResponseModel> response = await service.Create(model);

            response.Should().NotBeNull();
            response.Success.Should().BeFalse();
            validatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiBankAccountServerRequestModel>()));
            mock.MediatorMock.Verify(x => x.Publish(It.IsAny <BankAccountCreatedNotification>(), It.IsAny <CancellationToken>()), Times.Never());
        }
Beispiel #28
0
        public async void Update()
        {
            var mock  = new ServiceMockFacade <ICreditCardRepository>();
            var model = new ApiCreditCardRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <CreditCard>())).Returns(Task.FromResult(new CreditCard()));
            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(new CreditCard()));
            var service = new CreditCardService(mock.LoggerMock.Object,
                                                mock.RepositoryMock.Object,
                                                mock.ModelValidatorMockFactory.CreditCardModelValidatorMock.Object,
                                                mock.BOLMapperMockFactory.BOLCreditCardMapperMock,
                                                mock.DALMapperMockFactory.DALCreditCardMapperMock,
                                                mock.BOLMapperMockFactory.BOLPersonCreditCardMapperMock,
                                                mock.DALMapperMockFactory.DALPersonCreditCardMapperMock,
                                                mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
                                                mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock);

            UpdateResponse <ApiCreditCardResponseModel> response = await service.Update(default(int), model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.CreditCardModelValidatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiCreditCardRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Update(It.IsAny <CreditCard>()));
        }
        public async void All()
        {
            var mock    = new ServiceMockFacade <IProductModelRepository>();
            var records = new List <ProductModel>();

            records.Add(new ProductModel());
            mock.RepositoryMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
            var service = new ProductModelService(mock.LoggerMock.Object,
                                                  mock.RepositoryMock.Object,
                                                  mock.ModelValidatorMockFactory.ProductModelModelValidatorMock.Object,
                                                  mock.BOLMapperMockFactory.BOLProductModelMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductMapperMock,
                                                  mock.DALMapperMockFactory.DALProductMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductModelIllustrationMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelIllustrationMapperMock,
                                                  mock.BOLMapperMockFactory.BOLProductModelProductDescriptionCultureMapperMock,
                                                  mock.DALMapperMockFactory.DALProductModelProductDescriptionCultureMapperMock);

            List <ApiProductModelResponseModel> response = await service.All();

            response.Should().HaveCount(1);
            mock.RepositoryMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
        }
Beispiel #30
0
        public async void Create()
        {
            var mock  = new ServiceMockFacade <IEmployeeRepository>();
            var model = new ApiEmployeeRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Employee>())).Returns(Task.FromResult(new Employee()));
            var service = new EmployeeService(mock.LoggerMock.Object,
                                              mock.RepositoryMock.Object,
                                              mock.ModelValidatorMockFactory.EmployeeModelValidatorMock.Object,
                                              mock.BOLMapperMockFactory.BOLEmployeeMapperMock,
                                              mock.DALMapperMockFactory.DALEmployeeMapperMock,
                                              mock.BOLMapperMockFactory.BOLEmployeeDepartmentHistoryMapperMock,
                                              mock.DALMapperMockFactory.DALEmployeeDepartmentHistoryMapperMock,
                                              mock.BOLMapperMockFactory.BOLEmployeePayHistoryMapperMock,
                                              mock.DALMapperMockFactory.DALEmployeePayHistoryMapperMock,
                                              mock.BOLMapperMockFactory.BOLJobCandidateMapperMock,
                                              mock.DALMapperMockFactory.DALJobCandidateMapperMock);

            CreateResponse <ApiEmployeeResponseModel> response = await service.Create(model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.EmployeeModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiEmployeeRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Create(It.IsAny <Employee>()));
        }