C# Fixture.Register方法代码示例

        public void SynchronizeService_DiagnosisIsChanged_RevisesDiagnosisCorrectly()
        {
            // Setup
            var fixture = new Fixture().Customize(new AutoMoqCustomization());

            var encounter = new Mock<Encounter>();
            var procedure = new Mock<Procedure>();
            procedure.SetupGet(p => p.ProcedureType).Returns(ProcedureType.Activity);
            var diagnosis = fixture.CreateAnonymous<CodedConcept>();

            var service = new Mock<Service>();
            var serviceDiagnosis = fixture.CreateAnonymous<CodedConcept> ();
            service.SetupGet ( p => p.Diagnosis ).Returns ( serviceDiagnosis );
            service.SetupGet ( p => p.Encounter ).Returns ( encounter.Object );

            var serviceRepository = new Mock<IServiceRepository>();
            serviceRepository.Setup(p => p.GetByTrackingNumber(It.IsAny<long>())).Returns(service.Object);
            fixture.Register(() => serviceRepository.Object);

            var medicalProcedure = fixture.CreateAnonymous<MedicalProcedure>();
            var medicalProcedureTranslator = new Mock<IMedicalProcedureTranslator>();
            medicalProcedureTranslator.Setup(p => p.Translate(It.IsAny<Procedure>())).Returns(medicalProcedure);
            fixture.Register(() => medicalProcedureTranslator);

            var serviceFactory = new Mock<IServiceFactory>();
            fixture.Register(() => serviceFactory);

            var serviceSynchronizationService = fixture.CreateAnonymous<ServiceSynchronizationService>();

            // Exercise
            serviceSynchronizationService.SynchronizeService(encounter.Object, procedure.Object, diagnosis);

            // Verify
            service.Verify(p => p.ReviseDiagnosis(diagnosis));
        }

        public void SynchronizeEncounter_EncounterDoesNotExist_CreatesEncounterCorrectly()
        {
            // Setup
            var fixture = new Fixture().Customize(new AutoMoqCustomization());

            var patientAccount = new Mock<PatientAccount>();
            var visit = new Mock<Visit>();
            var serviceProvider = new Mock<Staff>();
            var placeOfService = new Mock<Location> ();
            visit.SetupGet ( p => p.ServiceLocation ).Returns ( placeOfService.Object );
            visit.SetupGet ( p => p.Staff ).Returns ( serviceProvider.Object );

            var encounterRepository = new Mock<IEncounterRepository>();
            encounterRepository.Setup(p => p.GetByTrackingNumber(It.IsAny<long>())).Returns<Encounter>(null);
            fixture.Register(() => encounterRepository.Object);

            var encounterFactory = new Mock<IEncounterFactory> ();
            encounterFactory.Setup (
                p =>
                p.CreateEncounter (
                    patientAccount.Object,
                    placeOfService.Object,
                    serviceProvider.Object,
                    visit.Object.Key,
                    It.IsAny<DateTime>() ) ).Returns ( new Mock<Encounter> ().Object );
            fixture.Register(() => encounterFactory.Object);

            var encounterSynchronizationService = fixture.CreateAnonymous<EncounterSynchronizationService>();

            // Exercise
            var encounter = encounterSynchronizationService.SynchronizeEncounter(patientAccount.Object, visit.Object);

            // Verify
            encounterFactory.Verify(p => p.CreateEncounter(patientAccount.Object, placeOfService.Object, serviceProvider.Object, visit.Object.Key, It.IsAny<DateTime>()));
        }

        public void IndexWillReturnViewModelWithCorrectProducts()
        {
            // Fixture setup
            var fixture = new Fixture().Customize(new CommerceWebCustomization());
            var featuredProducts =
                fixture.CreateMany<Product>().ToList();
            fixture.Register(() =>
                {
                    var repositoryStub =
                        new Mock<ProductRepository>();
                    repositoryStub.Setup(r =>
                        r.GetFeaturedProducts())
                        .Returns(featuredProducts);
                    return repositoryStub.Object;
                });

            var expectedProducts = (from p in featuredProducts
                                    select new Likeness<Product, ProductViewModel>(p).Without(d => d.SummaryText)).ToList();

            var sut =
                fixture.CreateAnonymous<HomeController>();
            // Exercise system
            var result = ((FeaturedProductsViewModel)sut
                .Index().ViewData.Model).Products.ToList();
            // Verify outcome
            Assert.True(expectedProducts.Cast<object>().SequenceEqual(result.Cast<object>()));
            // Teardown
        }

        public void Repo()
        {
            var mockRepo = new Mock<IRepository>();

            var fixture = new Fixture();
            fixture.Register<IRepository>(() => mockRepo.Object);
        }

        public void SynchronizePatientAccount_GivenPatientWithoutExistingBillingOffice_ThrowsArgumentException()
        {
            using (var serviceLocatorFixture = new ServiceLocatorFixture())
            {
                // Setup
                var fixture = new Fixture ().Customize ( new AutoMoqCustomization () );

                var billingOfficeRepository = new Mock<IBillingOfficeRepository> ();
                billingOfficeRepository.Setup ( p => p.GetByAgencyKey ( It.IsAny<long> () ) ).Returns ( () => null );
                fixture.Register ( () => billingOfficeRepository.Object );

                var agencyProfile = fixture.CreateAnonymous<AgencyProfile> ();

                var agency = new Mock<Agency> ();
                agency.SetupGet(p => p.Key).Returns(fixture.CreateAnonymous<long>());
                agency.SetupGet ( p => p.AgencyProfile ).Returns ( agencyProfile );

                var patient = new Mock<Patient> ();
                patient.SetupGet(p => p.Key).Returns(fixture.CreateAnonymous<long>());
                patient.SetupGet ( p => p.Agency ).Returns ( agency.Object );

                var patientAccountSynchronizationService = fixture.CreateAnonymous<PatientAccountSynchronizationService> ();

                // Exercise
                patientAccountSynchronizationService.SynchronizePatientAccount ( patient.Object );

                // Verify
            }
        }

        public void IssueReduced()
        {
            var fixture = new Fixture().Customize(new MultipleCustomization());
            fixture.Register<ItemBase>(fixture.CreateAnonymous<FunkyItem>);

            Assert.DoesNotThrow(() => fixture.CreateAnonymous<FunkyItem>());
        }

 public void FooIsDefaultEvenWhenFooIsFrozen()
 {
     var fixture = new Fixture();
     fixture.Register<IFoo>(
         fixture.Create<DummyFoo>);
     var b = fixture.Create<Bastard>();
     Assert.IsAssignableFrom<DefaultFoo>(b.Foo);
 }

 public void CreatePopulatedEnumerable()
 {
     var fixture = new Fixture();
     fixture.Register(() => fixture.CreateMany<int>());
     var integers =
         fixture.CreateAnonymous<IEnumerable<int>>();
     Assert.True(integers.Any());
 }

 public void CreatePopulatedListInterface()
 {
     var fixture = new Fixture();
     fixture.Register<IList<int>>(() => 
         fixture.CreateMany<int>().ToList());
     var list = fixture.CreateAnonymous<IList<int>>();
     Assert.True(list.Any());
 }

 public void CreatePopulatedList()
 {
     var fixture = new Fixture();
     fixture.Register(() =>
         fixture.CreateMany<int>().ToList());
     var list = fixture.Create<List<int>>();
     Assert.True(list.Any());
 }

 public void CreatePopulatedCollection()
 {
     var fixture = new Fixture();
     fixture.Register(() =>
         new Collection<int>(
             fixture.CreateMany<int>().ToList()));
     var collection = fixture.CreateAnonymous<Collection<int>>();
     Assert.True(collection.Any());
 }

        public static object Create(Type type)
        {
            var fixture = new Fixture();

            int index = 1;
            fixture.Register(() => "sample text " + index++);

            return new SpecimenContext(fixture).Resolve(type);
        }

        public void SimpleRegister()
        {
            Fixture fixture = new Fixture();
            fixture.Register<IMyInterface>(() => 
                new FakeMyInterface());
            MyClass sut = fixture.Create<MyClass>();

            Assert.NotNull(sut);
        }

        public void ImportEncounterFromVisit_BillingOfficeExistsAndCodingContextHasProceduresAndVisitHasNoProblem_SynchronizeEncounterCorrectly()
        {
            // Setup
            var fixture = new Fixture().Customize(new AutoMoqCustomization());

            var billingOffice = new Mock<BillingOffice>();
            var billingOfficeRepository = new Mock<IBillingOfficeRepository>();
            billingOfficeRepository.Setup(p => p.GetByAgencyKey(It.IsAny<long>())).Returns(billingOffice.Object);
            fixture.Register(() => billingOfficeRepository.Object);

            var patientAccount = new Mock<PatientAccount>();
            var patientAccountSynchronizationService = new Mock<IPatientAccountSynchronizationService>();
            patientAccountSynchronizationService.Setup(p => p.SynchronizePatientAccount(It.IsAny<Patient>())).Returns(patientAccount.Object);
            fixture.Register(() => patientAccountSynchronizationService.Object);

            var patient = new Mock<Patient>();
            var agency = new Mock<Agency>();
            patient.Setup(p => p.Agency).Returns(agency.Object);

            var visit = new Mock<Visit>();
            visit.SetupGet ( p => p.Problems ).Returns ( new List<VisitProblem> () );
            visit.Setup(v => v.ClinicalCase.Patient).Returns(patient.Object);

            var visitRepository = new Mock<IVisitRepository>();
            visitRepository.Setup(p => p.GetByKey((It.IsAny<long>()))).Returns(visit.Object);
            fixture.Register(() => visitRepository.Object);

            var codingContext = new Mock<CodingContext>();
            var procedures = new List<Procedure> { new Mock<Procedure> ().Object, new Mock<Procedure> ().Object};
            codingContext.SetupGet ( p => p.Procedures ).Returns ( () => procedures );
            var codeContextRepository = new Mock<ICodingContextRepository>();
            codeContextRepository.Setup(p => p.GetByVisitKey(It.IsAny<long>())).Returns(codingContext.Object);
            fixture.Register(() => codeContextRepository.Object);

            var serviceSynchronizationService = new Mock<IServiceSynchronizationService> ();
            fixture.Register(() => serviceSynchronizationService.Object);

            var visitImportService = fixture.CreateAnonymous<VisitImportService>();

            // Exercise
            visitImportService.ImportVisit(fixture.CreateAnonymous<long>());

            // Verify
        }

 public void addMovement_returns_valid_instance_with_valid_inputs()
 {
     var fixture = new Fixture();
     fixture.Register(UnLocodeHelpers.GetNewUnLocode);
     var voyageBuilder = fixture.CreateAnonymous<VoyageBuilder>();
     var arrivalLocation = fixture.CreateAnonymous<BookingApi.Domain.Location.Location>();
     var departureTime = fixture.CreateAnonymous<DateTime>();
     var arrivalTime = fixture.CreateAnonymous<DateTime>();
     Assert.NotNull(voyageBuilder.AddMovement(arrivalLocation, departureTime, arrivalTime));
 }