C# Fixture.CreateMany方法代码示例

        public void MessageShouldBeSameAfterSerializationAndDeserialization()
        {
            var writer = new BinaryWriter(new MemoryStream());
            IMessageFactory msgFactory = new MessageFactory(new Message[]
                {
                    new ISomeServiceComplexRequest()
                });

            var fixture = new Fixture();
            fixture.Customize<ISomeServiceComplexRequest>(ob =>
                ob.With(x => x.datas,
                    fixture.CreateMany<SubData>().ToList()));
            fixture.Customize<ComplexData>(ob => ob
                .With(x => x.SomeArrString, fixture.CreateMany<string>().ToList())
                .With(x => x.SomeArrRec, fixture.CreateMany<SubData>().ToList()));

            var msg = fixture.CreateAnonymous<ISomeServiceComplexRequest>();

            //serialize and deserialize msg1
            msg.Serialize(writer);
            writer.Seek(0, SeekOrigin.Begin);
            var reader = new BinaryReader(writer.BaseStream);
            Message retMsg = msgFactory.Deserialize(reader);

            retMsg.Should().BeOfType<ISomeServiceComplexRequest>();
            msg.ShouldBeEqualTo((ISomeServiceComplexRequest)retMsg);
        }

        private static void CreateTestDataIn(Database db)
        {
            var createRole = new CreateRole
            {
                Name = "Admin",
                Permissions = new[] {"View Users", "Edit Users", "Deactivate Users"}
            };
            db.CreateRole(createRole);
            db.CreateUser(new CreateUser {FullName = "Dan Barua", UserName = "dan", RoleId = createRole.Id.GetValueOrDefault()});
            db.CreateUser(new CreateUser {FullName = "Jonathon Channon", UserName = "jonathon", RoleId = createRole.Id.GetValueOrDefault()});

            // let's generate some random data!
            var fixture = new Fixture {RepeatCount = 100};

            var roles = fixture.CreateMany<CreateRole>().ToList();
            var users = fixture.CreateMany<CreateUser>().ToList();
            foreach (var r in roles)
            {
                db.CreateRole(r);
            }

            var roleCount = roles.Count();
            foreach (var u in users)
            {
                u.RoleId = roles.Skip(new Random().Next(0, roleCount)).Take(1).First().Id.GetValueOrDefault();
                // select random id from roles
                db.CreateUser(u);
            }
        }

            public static TestData Create(int stepCount, int machinesPerStep)
            {
                var fixture = new Fixture();
                var returnValue = new TestData
                {
                    DeployBatchRequest = fixture.Build<DeployBatchRequest>()
                                    .With(i=>i.ItemList,
                                            fixture.Build<DeployBatchRequestItem>()
                                                .With(j=>j.MachineList, fixture.CreateMany<DeployMachine>(machinesPerStep).ToList())
                                                .CreateMany(stepCount).ToList())
                                    .Create(),
                    ProjectManager = new Mock<IProjectManager>()
                };
                var deployMachineNameList = fixture.CreateMany("DeployMachineName", machinesPerStep).ToList();
                foreach(var item in returnValue.DeployBatchRequest.ItemList)
                {
                    for(int i = 0; i < machinesPerStep; i++)
                    {
                        item.MachineList[i].MachineName = deployMachineNameList[i];
                    }
                }
                returnValue.Sut = new DeploymentPlanBuilder(returnValue.ProjectManager.Object);

                return returnValue;
            }

        public void ShouldProperlyInvokeRequestReplyMethod()
        {
            #region Arrange
            var fixture = new Fixture();
            fixture.Customize<ISomeServiceComplexRequest>(ob =>
                ob.With(x => x.datas,
                    fixture.CreateMany<SubData>().ToList()));
            fixture.Customize<ComplexData>(ob => ob
                .With(x => x.SomeArrString, fixture.CreateMany<string>().ToList())
                .With(x => x.SomeArrRec, fixture.CreateMany<SubData>().ToList()));

            var inputMsg = fixture.CreateAnonymous<ISomeServiceComplexRequest>();
            var output = inputMsg.data;

            var tcs = new TaskCompletionSource<ComplexData>();
            tcs.SetResult(output);

            var service = Substitute.For<ISomeService>();
            service.Complex(inputMsg.requestId, inputMsg.data, inputMsg.name, inputMsg.datas)
                .Returns(x => tcs.Task);

            #endregion

            //Act
            Task<Message> ret = _protocolDesc.Dispatch(service, inputMsg);

            //Assert
            service.Received(1).Complex(inputMsg.requestId, inputMsg.data, inputMsg.name, inputMsg.datas);
            ret.Should().NotBeNull();
            ret.Status.Should().Be(TaskStatus.RanToCompletion);
            var replyMsg = ret.Result as ISomeServiceComplexReply;
            replyMsg.Should().NotBeNull();
            replyMsg.RetVal.Should().Be(output);
        }

        protected override sealed void SetUp()
        {
            base.SetUp();

            var fixture = new Fixture();

            _sources = fixture.CreateMany<IEnumerable<int>>().ToArray();
            _comparer = new TestComparer();

            for (var i = 0; i < _sources.Length; i++) {
                _sources[i] = fixture.CreateMany<int>().OrderBy(item => item);
            }
        }

        public IEnumerable<PatientTherapy> GetPatientTherapies(Fixture fixture, Random randomizer, PatientDemographics demographic, int maxNumberOfPatientTherapies)
        {
            fixture.Customize<PatientTherapy>(pt => pt.With(x => x.PatientId, demographic.PatientId)
                                                      .Without(x => x.DDID)
                                                      .Without(x => x.RXNorm)
                                                      .Without(x => x.StopDate));

            var therapies = fixture.CreateMany<PatientTherapy>(randomizer.Next(0, maxNumberOfPatientTherapies + 1));
            foreach (var therapy in therapies)
            {
                var daysOnTherapy = randomizer.Next(1, 365);
                therapy.StopDate = new DateTime(Math.Min(therapy.StartDate.AddDays(daysOnTherapy).Ticks, DateTime.Now.Ticks));

                var hasFavoredTherapy = randomizer.NextPercent() <= ChanceOfHavingFavoredCondition;
                if (hasFavoredTherapy)
                {
                    var pair = randomizer.NextDictionaryPair(_favoredTherapies);
                    therapy.NDC = pair.Key;
                    therapy.DrugName = pair.Value;
                }
                else
                {
                    therapy.NDC = NDCGenerator.GetRandomNDC(randomizer);
                }
            }

            return therapies.OrderBy(x => x.StartDate);
        }

        public void FreshenMailBoxTestWithException()
        {
            _imapWorker.Setup(false);

            var r = new ImapCommandResponse();

            var fix = new Fixture();
            fix.Customize(new AutoMoqCustomization());

            var messages = fix.CreateMany<IMessageSummary>().ToList();

            //first fetch throws exception - after closing and opening folders now messages are returned
            //this mirrors how the client has been functioning in real world tests
            inbox.Setup(x => x.FetchAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<MessageSummaryItems>(),
                It.IsAny<CancellationToken>())).ThrowsAsync(new ImapCommandException(r ,"The IMAP server replied to the 'FETCH' command with a 'NO' response."))
                .Callback(() =>
                {
                    inbox.Setup(x => x.FetchAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<MessageSummaryItems>(),
                        It.IsAny<CancellationToken>())).ReturnsAsync(messages);
                });

            _imapWorker.FreshenMailBox();

            inbox.Verify(x => x.CloseAsync(It.Is<bool>(y => y == false), It.IsAny<CancellationToken>()), Times.Exactly(1));
            inbox.Verify(x => x.OpenAsync(It.IsAny<FolderAccess>(), It.IsAny<CancellationToken>()));
        }

        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 IsEnabledCallsAllToggles([Frozen] IFeatureToggleProvider toggleProvider, IFeature feature,
            Fixture fixture, FeatureContext sut)
        {
            var featureToggles = fixture.CreateMany<Fake<IFeatureToggle>>().ToList();
            foreach (Fake<IFeatureToggle> fake in featureToggles)
            {
                fake.CallsTo(ft => ft.IsEnabled(feature))
                    .Returns(null);
            }
            var finalTogle = A.Fake<Fake<IFeatureToggle>>();
            finalTogle.CallsTo(ft => ft.IsEnabled(feature))
                .Returns(true);
            featureToggles.Add(finalTogle);

            A.CallTo(() => toggleProvider.GetFeatureToggles())
                .Returns(featureToggles.Select(f => f.FakedObject));

            sut.IsEnabled(feature);

            foreach (Fake<IFeatureToggle> fake in featureToggles)
            {
                fake.CallsTo(ft => ft.IsEnabled(feature))
                    .MustHaveHappened();
            }
        }

        public IEnumerable<PatientProcedure> GetPatientProcedures(Fixture fixture, Random randomizer, PatientDemographics demographic, int maxNumberOfPatientProcedures)
        {
            fixture.Customize<PatientProcedure>(pp => pp.With(x => x.PatientId, demographic.PatientId)
                                                        .Without(x => x.CptHcpcs));

            var procedures = fixture.CreateMany<PatientProcedure>(randomizer.Next(0, maxNumberOfPatientProcedures + 1)).ToList();
            foreach (var procedure in procedures)
            {
                procedure.ProcedureDate = procedure.ProcedureDate.Date;

                var hasFavoredProcedure = randomizer.NextPercent() <= ChanceOfHavingFavoredProcedure;
                procedure.CptHcpcs = hasFavoredProcedure ? randomizer.NextListElement(_favoredProcedureCodes) : GetRandomProcedure(randomizer);

                var isProcedureRecent = randomizer.NextPercent() <= ChanceOfHavingRecentProcedure;
                if(isProcedureRecent)
                {
                    var oldestRecentDateTime = DateTime.Today.AddMonths(-6);
                    if(procedure.ProcedureDate < oldestRecentDateTime)
                    {
                        var maximumNumberOfDaysForRecent = (int)(DateTime.Today - oldestRecentDateTime).TotalDays;
                        var daysAgo = randomizer.Next(1, maximumNumberOfDaysForRecent);
                        procedure.ProcedureDate = DateTime.Today.AddDays(-daysAgo);
                    }
                }
            }

            return procedures.OrderBy(x => x.ProcedureDate);
        }

				public static TestData Create(int projectCount=5)
				{
					var fixture = new Fixture();
					var returnValue = new TestData
					{
						Fixture = fixture,
						UserName = fixture.Create<string>("UserName"),
						ProjectList = fixture.CreateMany<DeployProject>(projectCount).ToList(),
						ProjectRoleManager = new Mock<IProjectRoleManager>(),
                        SystemRoleManager = new Mock<ISystemRoleManager>(),
						UserIdentity = new Mock<IUserIdentity>()
					};
					returnValue.DeployProjectRoleList = 
						(from i in returnValue.ProjectList
						 select new DeployProjectRole
							{
								ProjectId = i.Id,
								RoleName = fixture.Create<string>("RoleName")
							}
						).ToList();
                    returnValue.ProjectRoleManager.Setup(i => i.GetProjectRoleListForUser(It.IsAny<string>())).Returns(new List<DeployProjectRole>());
                    returnValue.ProjectRoleManager.Setup(i => i.GetProjectRoleListForUser(returnValue.UserName)).Returns(returnValue.DeployProjectRoleList);

                    returnValue.SystemRoleManager.Setup(i=>i.GetSystemRoleListForUser(It.IsAny<string>())).Returns(new List<SystemRole>());

					returnValue.UserIdentity.Setup(i=>i.UserName).Returns(returnValue.UserName);

					returnValue.Sut = new PermissionValidator(returnValue.ProjectRoleManager.Object, returnValue.SystemRoleManager.Object, returnValue.UserIdentity.Object);

					return returnValue;
				}

        private static void Main(string[] args)
        {
            var fixture = new Fixture();
            fixture.Customizations.Add(new FirstNameBuilder());
            fixture.Customizations.Add(new AddressListBuilder());

            var aNumber = fixture.Create<int>();
            Console.WriteLine("Autofixture initialised aNumber with {0}\n\n\n", aNumber);

            var aString = fixture.Create<string>();
            Console.WriteLine("Autofixture initialised aString with {0}\n\n\n", aString);

            var aPerson = fixture.Create<Person>();
            Console.WriteLine("Autofixture initialised aContact with...\n\n {0}", aPerson);

            const int contactCount = 3;
            var people = fixture.CreateMany<Person>(contactCount);

            Console.WriteLine("Autofixture initialised {0} contacts...\n\n", contactCount);

            foreach (var person in people)
            {
                Console.WriteLine("\n\n{0}", person);
            }

            Console.ReadKey();
        }

 public void TestInitialize()
 {
     var fixture = new Fixture();
     factories = Substitute.For<Factories>();
     navigator = Substitute.For<Navigator>();
     stateProvider = Substitute.For<StateProvider>();
     facade = Substitute.For<ReplacementBuilderAndSugarEstimatorFacade>();
     clipboard = Substitute.For<Clipboard>();
     messageDialog = Substitute.For<MessageDialog>();
     navigation = new InsulinEditingViewModel.Navigation();
     CreateSut();
     insulin = fixture.Create<Insulin>();
     insulin.InitializeCircumstances(new List<Guid>());
     insulin.SetOwner(factories);
     sugar = new Sugar();
     sugar.SetOwner(factories);
     factories.InsulinCircumstances.Returns(fixture.CreateMany<InsulinCircumstance>().ToList());
     factories.CreateSugar().Returns(sugar);
     settings = new Settings { MaxBolus = 5 };
     factories.Settings.Returns(settings);
     meal = fixture.Create<Meal>();
     factories.Finder.FindMealByInsulin(insulin).Returns(meal);
     factories.Finder.FindInsulinById(insulin.Id).Returns(insulin);
     var replacementAndEstimatedSugars = new ReplacementAndEstimatedSugars();
     replacementAndEstimatedSugars.EstimatedSugars = new List<Sugar>();
     replacementAndEstimatedSugars.Replacement
         = new Replacement { InsulinTotal = new Insulin(), Items = new List<ReplacementItem>() };
     facade.GetReplacementAndEstimatedSugars(Arg.Any<Meal>(), Arg.Any<Insulin>(), Arg.Any<Sugar>())
             .Returns(replacementAndEstimatedSugars);
     factories.MealNames.Returns(new List<MealName>());
     stateProvider.State.Returns(new Dictionary<string, object>());
 }

		public void TestInitialize()
		{
			_fixture = new Fixture();
			_awbRepository = new Mock<IAwbRepository>(MockBehavior.Strict);
			_awbIds = Enumerable.Range(0, AWBCount).Select(x => (long)x).ToArray();
			_awbsData = _awbIds.Select(i => _fixture.Build<AirWaybillData>()
				.With(d => d.Id, i)
				.Create()).ToArray();
			_awbRepository.Setup(x => x.Get(_awbIds)).Returns(_awbsData);

			_applications = _fixture.CreateMany<ApplicationListItem>(AppCount).ToArray();
			for(var i = 0; i < AppCount; i++)
			{
				var item = _applications[i];
				item.AirWaybillId = i % AWBCount;
				item.Id = i;
				item.ClientNic = "Client " + i % ClientCount;
				item.Count = i;
				item.Weight = i;
				item.Value = i;
				item.Volume = i;
			}

			_grouper = new ApplicationGrouper(_awbRepository.Object);
		}

        public void Given_WhenWhen_ShouldExpectedResult()
        {
            var documentStore = new DocumentStore { Url = "http://mamluka-pc:4253" };
            documentStore.Initialize();

            var fixture = new Fixture();

            using (var session = documentStore.OpenSession())
            {
                var theList = fixture.CreateMany<Contact>(1000).ToList();

                theList.Take(500).ToList().ForEach(x => x.DomainGroup = "a");
                theList.Skip(500).Take(500).ToList().ForEach(x => x.DomainGroup = "b");

                var bigDoc = new Holder
                                 {
                                     TheList = theList
                                 };

                session.Store(bigDoc);
                session.SaveChanges();
            }

            documentStore.DatabaseCommands.PutIndex("Count_Contacts", new IndexDefinitionBuilder<Holder, SummeryOfDomains>
            {
                Map = contacts => contacts.SelectMany(x => x.TheList).Select(x => new { x.DomainGroup, Count = 1 }),
                Reduce = results => results.GroupBy(x => x.DomainGroup).Select(x => new { DomainGroup = x.Key, Count = x.Sum(m => m.Count) })

            }, true);

            using (var session = documentStore.OpenSession())
            {
                Trace.WriteLine(session.Query<List<int>>("Count_Contacts").First());
            }
        }