Exemple #1
0
        public void ModelRepositoryGetAllTest()
        {
            //Arrange
            IncludeAllMappings.include();
            var vModel = new VehicleModelDomain()
            {
                Name = "ModelRepositoryUpdateTest", Abrv = "ModelRepositoryUpdateTest", VehicleModelId = Guid.NewGuid(), VehicleMakeId = Guid.Parse("03f3a155-c7a2-e611-9c16-b88687075332")
            };
            var context        = new VehicleContext();
            var repository     = new Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
            var testRepository = new ModelRepository(repository);

            Task.Run(async() =>
            {
                var response = await testRepository.Add(vModel);

                Assert.AreEqual(1, response);
            }).GetAwaiter().GetResult();

            //Act
            Task.Run(async() =>
            {
                var result = await testRepository.Add(vModel);
                //Assert
                Assert.IsNotNull(result);
            }).GetAwaiter().GetResult();
        }
Exemple #2
0
        public void ModelServiceReadAllTest()
        {
            //Arange
            IncludeAllMappings.include();
            var context         = new VehicleContext();
            var repository      = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
            var makeRepository  = new MakeRepository(repository);
            var modelRepository = new ModelRepository(repository);
            var makeService     = new MakeService(makeRepository, modelRepository);
            var testService     = new ModelService(modelRepository);

            //Add make
            var vMake = new VehicleMakeDomain()
            {
                Name = "ModelServiceReadAllTest", Abrv = "ModelServiceReadAllTest", VehicleModel = null
            };

            Task.Run(async() =>
            {
                var response = await makeService.Add(vMake);
                Assert.AreEqual(1, response);
            }).GetAwaiter().GetResult();

            IVehicleMakeDomain targetMake = null;

            //Get make
            Task.Run(async() =>
            {
                var response = await makeService.ReadAll();
                Assert.IsNotNull(response);
                targetMake = response.LastOrDefault();
            }).GetAwaiter().GetResult();

            //Create model
            var vModel = new VehicleModelDomain()
            {
                Name = "ModelServiceReadAllTest", Abrv = "ModelServiceReadAllTest", VehicleMakeId = targetMake.VehicleMakeId
            };

            //Add model
            Task.Run(async() =>
            {
                var response = await testService.Add(vModel);
                Assert.AreEqual(1, response);
            }).GetAwaiter().GetResult();

            Task.Run(async() =>
            {
                //Act
                var result = await testService.ReadAll();
                //Assert
                Assert.IsNotNull(result);
            }).GetAwaiter().GetResult();
        }
Exemple #3
0
        public void ModelRepositoryGetTest()
        {
            //Arrange
            //Init repo
            IncludeAllMappings.include();
            var context        = new VehicleContext();
            var repository     = new Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
            var testRepository = new ModelRepository(repository);
            var makeRepository = new MakeRepository(repository);

            //Create maker
            var vMake = new VehicleMakeDomain()
            {
                Name = "ModelRepositoryGetTest", Abrv = "ModelRepositoryGetTest"
            };

            Task.Run(async() =>
            {
                var response = await makeRepository.Add(vMake);
                Assert.AreEqual(1, response);
            }).GetAwaiter().GetResult();

            //Get maker
            IEnumerable <IVehicleMakeDomain> getAllMakers = null;
            IVehicleMakeDomain targetMaker = null;

            Task.Run(async() =>
            {
                getAllMakers = await makeRepository.GetAll();
                Assert.IsNotNull(getAllMakers);

                foreach (var item in getAllMakers)
                {
                    targetMaker = item;
                }
            }).GetAwaiter().GetResult();

            //Create model
            var vModel = new VehicleModelDomain()
            {
                Name = "ModelRepositoryGetTest", Abrv = "ModelRepositoryGetTest", VehicleMakeId = targetMaker.VehicleMakeId
            };

            //Add model
            Task.Run(async() =>
            {
                var response = await testRepository.Add(vModel);

                Assert.AreEqual(1, response);
            }).GetAwaiter().GetResult();

            //Get model
            IEnumerable <IVehicleModelDomain> getAll;
            IVehicleModelDomain targetModel = null;

            Task.Run(async() =>
            {
                getAll = await testRepository.GetAll();
                Assert.IsNotNull(getAll);

                foreach (var item in getAll)
                {
                    targetModel = item;
                }

                var result = await testRepository.Get(targetModel.VehicleModelId);
                //Assert
                Assert.AreEqual(targetModel.VehicleModelId, result.VehicleModelId);
            }).GetAwaiter().GetResult();
        }