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 = "******", RoleId = createRole.Id.GetValueOrDefault()});
db.CreateUser(new CreateUser {FullName = "Jonathon Channon", UserName = "******", 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 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 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 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 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);
}
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 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());
}
}
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;
}
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 CreatePopulatedList()
{
var fixture = new Fixture();
fixture.Register(() =>
fixture.CreateMany<int>().ToList());
var list = fixture.Create<List<int>>();
Assert.True(list.Any());
}
public void CreateHashCode_TwoNotEqualIntsList_ReturnsNotEqualHashCodes ()
{
// arrange
var fixture = new Fixture ();
var a = fixture.CreateMany<int> (10).ToList ();
var b = fixture.CreateMany<int> (9).ToList ();
// act
var result_a = a.CreateHashCode ();
var result_b = b.CreateHashCode ();
// assert
result_a.Should ().NotBe (result_b);
}
public void SelectAllWillReturnCorrectResult()
{
// Fixture setup
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var items = fixture.CreateMany<CampaignItem>().ToList();
var expectedPresenters = fixture.CreateMany<CampaignItemPresenter>().ToList();
fixture.Freeze<Mock<CampaignRepository>>().Setup(r => r.SelectAll()).Returns(items);
fixture.Freeze<Mock<IPresentationMapper>>().Setup(m => m.Map(items)).Returns(expectedPresenters);
var sut = fixture.CreateAnonymous<CampaignPresenter>();
// Exercise system
IEnumerable<CampaignItemPresenter> result = sut.SelectAll();
// Verify outcome
Assert.Equal(expectedPresenters, result);
// Teardown
}
public IEnumerable<PatientUtilization> GetPatientUtilizations(Fixture fixture, Random randomizer, PatientDemographics demographic, int maxNumberOfPatientUtilizations)
{
fixture.Customize<PatientUtilization>(pu => pu.With(x => x.PatientId, demographic.PatientId));
var utilizations = fixture.CreateMany<PatientUtilization>(randomizer.Next(0, maxNumberOfPatientUtilizations + 1));
return utilizations.OrderBy(x => x.ActivityDate);
}
public void TestInitialize()
{
factories = Substitute.For<Factories>();
fixture = new Fixture();
factories.Finder.Returns(new FinderImpl(factories));
factories.CreateCategory().Returns(new Category());
factories.Categories.Returns(fixture.CreateMany<Category>().ToList());
factories.Products.Returns(fixture.CreateMany<Product>(5).ToList());
foreach (var product in factories.Products)
{
product.CategoryId = factories.Categories[1].Id;
product.SetOwner(factories);
}
factories.MruProducts.Returns(new MruProductsImpl(new List<Guid>(), factories));
factories.Settings.Returns(new Settings());
viewModel = new ProductListingViewModel(factories, new BackgroundWorkerSyncFactory());
}
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 CreatePopulatedEnumerable()
{
var fixture = new Fixture();
fixture.Register(() => fixture.CreateMany<int>());
var integers =
fixture.CreateAnonymous<IEnumerable<int>>();
Assert.True(integers.Any());
}
public void SanityTest()
{
Fixture fixture = new Fixture();
float[] floatData = fixture.CreateMany<float>(100).ToArray();
double[] doubleDataByStandardWay = ExactWay.CreateDoubleArray(floatData);
double[] doubleDataByFastWay = FastWay.CreateDoubleArray(floatData);
Assert.That(doubleDataByFastWay, Is.EquivalentTo(doubleDataByStandardWay));
}
public void AutoGenerateCollectionOfStrings()
{
Fixture fixture = new Fixture();
IEnumerable<string> testStrings = fixture.CreateMany<string>();
// Assert
testStrings.Should().NotBeNull();
testStrings.Count().Should().Be(3);
}
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 void TestInitialize()
{
factories = Substitute.For<Factories>();
fixture = new Fixture();
factories.Categories.Returns(fixture.CreateMany<Category>().ToList());
categories = factories.Categories.Select(category => new CategoryViewModel(category, factories)).ToList();
product = new Product { CategoryId = factories.Categories.First().Id };
product.SetOwner(factories);
overrideCategory = new CategoryViewModel(new Category(), factories);
}
public void ParseThreeInvalidArgsWillReturnCorrectResult()
{
// Fixture setup
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var args = fixture.CreateMany<string>().ToList();
var sut = fixture.CreateAnonymous<CurrencyParser>();
// Exercise system
var result = sut.Parse(args);
// Verify outcome
Assert.IsAssignableFrom<HelpCommand>(result);
// Teardown
}
public void Ctor_WithTools_ShowsTools()
{
var fixture = new Fixture();
var tools = fixture.CreateMany<Mock<ToolViewModelBase>>(3)
.Select(q => q.Object)
.ToArray();
var viewModel = new ScreenEditorViewModel(tools);
Assert.Equal(3, viewModel.Tools.Count());
Assert.Equal(tools, viewModel.Tools);
}
public void CreatedSutCanHaveItemsAssignedSubsequently()
{
// Fixture setup
var fixture = new Fixture();
// Exercise system
var mc = fixture.Create<MyClassA>();
mc.Items = fixture.CreateMany<MyClassB>().ToArray();
// Verify outcome
Assert.True(mc.Items.Length > 0);
Assert.True(mc.Items.All(x => x != null));
// Teardown
}
public void CreateHashCode_TwoEqualObjectsListWithNestedList_ReturnsEqualHashCodes ()
{
// arrange
var fixture = new Fixture ();
fixture.Customize<TestObject> (composer => composer.With (x => x.Number, fixture.Create<int> ()));
var a = fixture.CreateMany<TestObject> (10).Cast<object> ().ToList ();
a.Insert (5, fixture.CreateMany<TestObject> ());
a.Insert (8, fixture.CreateMany<int> ());
var b = a.ToList ();
// act
var result_a = a.CreateHashCode ();
var result_b = b.CreateHashCode ();
// assert
result_a.Should ().Be (result_b);
}
public void GetContext_InvalidTypeConversion_ThrowsArgumentException()
{
// Arrange
var fixture = new Fixture();
var contextInput = fixture.CreateMany <string>();
var context = new Dictionary <string, object> {
{ nameof(contextInput), contextInput }
};
var parentRuleResult = new RuleResultTree();
var actionContext = new ActionContext(context, parentRuleResult);
string name = nameof(contextInput);
// Act
Assert.Throws <ArgumentException>(() => actionContext.GetContext <RuleResultTree>(name));
}
public void ShouldReturnValidResult()
{
// arrange
var areas = Fixture.CreateMany <Energy>(3);
number expectedResultInJoules = areas.Sum(e => e.Joules);
var expectedResultUnit = areas.First().Unit;
var expectedResult = new Energy(expectedResultInJoules).Convert(expectedResultUnit);
// act
var result = EnumerableExtensions.Sum(areas);
// assert
result.Joules.Should().BeApproximately(expectedResult.Joules);
result.Unit.Should().Be(expectedResult.Unit);
result.Value.Should().BeApproximately(expectedResult.Value);
}
public void ShouldReturnValidResult()
{
// arrange
var objects = Fixture.CreateMany <Energy>(3).Select(e => new TestObject <Energy>(e));
number expectedResultInMetres = objects.Sum(e => e.Property.Joules);
var expectedResultUnit = objects.First().Property.Unit;
var expectedResult = new Energy(expectedResultInMetres).Convert(expectedResultUnit);
// act
var result = EnumerableExtensions.Sum(objects, e => e.Property);
// assert
result.Joules.Should().BeApproximately(expectedResult.Joules);
result.Unit.Should().Be(expectedResult.Unit);
result.Value.Should().BeApproximately(expectedResult.Value);
}
public void GetFeaturedProductsWillReturnCorrectResult()
{
// Fixture setup
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var expectedProducts = fixture.CreateMany <Product>().ToList();
fixture.Freeze <Mock <ProductRepository> >().Setup(r => r.GetFeaturedProducts()).Returns(expectedProducts);
var sut = fixture.CreateAnonymous <AuditingProductRepository>();
// Exercise system
var result = sut.GetFeaturedProducts();
// Verify outcome
Assert.True(expectedProducts.SequenceEqual(result));
// Teardown
}
public async Task SaveProcessManagerAndPublishCommands_inserts_pending_commands_sequentially()
{
// Arrange
var fixture = new Fixture();
IEnumerable <FooCommand> commands = fixture.CreateMany <FooCommand>();
var processManager = new FooProcessManager(commands);
var operationId = Guid.NewGuid();
var correlationId = Guid.NewGuid();
string contributor = fixture.Create <string>();
var serializer = new JsonMessageSerializer();
var sut = new SqlProcessManagerDataContext <FooProcessManager>(
new FooProcessManagerDbContext(),
serializer,
Mock.Of <ICommandPublisher>());
// Act
using (sut)
{
await sut.SaveProcessManagerAndPublishCommands(processManager, operationId, correlationId, contributor);
}
// Assert
using (var db = new FooProcessManagerDbContext())
{
IQueryable <PendingCommand> query =
from c in db.PendingCommands
where c.ProcessManagerId == processManager.Id
orderby c.Id
select c;
List <PendingCommand> pendingCommands = await query.ToListAsync();
pendingCommands.Should().HaveCount(commands.Count());
foreach (var t in commands.Zip(pendingCommands, (expected, actual) => new { expected, actual }))
{
t.actual.ProcessManagerType.Should().Be(typeof(FooProcessManager).FullName);
t.actual.ProcessManagerId.Should().Be(processManager.Id);
t.actual.MessageId.Should().NotBeEmpty();
t.actual.OperationId.Should().Be(operationId);
t.actual.CorrelationId.Should().Be(correlationId);
t.actual.Contributor.Should().Be(contributor);
serializer.Deserialize(t.actual.CommandJson).ShouldBeEquivalentTo(t.expected, opts => opts.RespectingRuntimeTypes());
}
}
}
public Tests()
{
_jsonConverter = new DependencyCollection()
.AddECS()
.BuildProvider()
.GetRequired <JConverter>();
_converter = _jsonConverter.Converters.Get(typeof(TestAsset));
var reference = CreateAsset(6);
var assets = new LocalList <Asset>(
new TestAsset(7, new IComponent[] { Fixture.Create <TestComponent1>() })
{
Array = Fixture.CreateMany <int>().ToArray(),
Reference = reference
},
CreateAsset(4, Fixture.Create <TestComponent1>()),
CreateAsset(3, Fixture.Create <TestComponent2>()),
CreateAsset(2),
reference);
var components = new IComponent[]
{
Fixture.Create <TestComponent1>(),
Fixture.Create <TestComponent2>(),
new TestComponent3
{
Asset = (TestAsset)assets[0],
AssetsArray = assets.ToArray(),
AssetsList = assets.ToList()
}
};
_asset = new TestAsset(1, components)
{
Array = Fixture.CreateMany <int>().ToArray()
};
assets.Add(_asset);
assets.Reverse();
_assets = assets.ToArray();
_actors = new[] { BuildActor(1), new TestActor(2)
{
Prototype = reference
} };
}
public async Task RotaPersonagensDeveRetornarTiposCorretos()
{
var personagens = _fixture.CreateMany <PersonagensViewModel>();
servicoAplicacaoMarvel.Setup(p => p.ObterPersonagens(It.IsAny <CancellationToken>())).ReturnsAsync(personagens);
var retorno = await personagemController.ObterPersonagens(It.IsAny <CancellationToken>());
Assert.IsType <ActionResult <IEnumerable <PersonagensViewModel> > >(retorno);
Assert.IsType <OkObjectResult>(retorno.Result);
}
public async Task DeleteLink_Request_Missing_Auth_Credentials_Should_Return_UnAuthorized()
{
// Arrange
IEnumerable <Document> docs = Fixture.CreateMany <Document>();
ILogger dummyLogger = A.Dummy <ILogger>();
Binder dummyBinder = A.Fake <Binder>();
RemoveAuthFromContext();
// Act
IActionResult result = await _linkOperations.DeleteLink(this.DefaultRequest, docs, null, "vanityUrl", dummyBinder, dummyLogger);
AddAuthToContext();
// Assert
Assert.IsType <UnauthorizedResult>(result);
}
public void ShouldReturnValidResult()
{
// arrange
var source = Fixture.CreateMany <Weight>(3);
number expectedResultInKilograms = source.Average(e => e.Kilograms);
var expectedResultUnit = source.First().Unit;
var expectedResult = new Weight(expectedResultInKilograms).Convert(expectedResultUnit);
// act
var result = EnumerableExtensions.Average(source);
// assert
result.Kilograms.Should().BeApproximately(expectedResult.Kilograms);
result.Unit.Should().Be(expectedResult.Unit);
result.Value.Should().BeApproximately(expectedResult.Value);
}
public SendEmailToEmployerCommandHandlerTestsFixture()
{
_autoFixture = new Fixture();
AccountId = _autoFixture.Create <long>();
TemplateId = _autoFixture.Create <string>();
ReplyTo = _autoFixture.Create <string>();
Tokens = _autoFixture.Create <Dictionary <string, string> >();
Employees = _autoFixture.CreateMany <TeamMemberViewModel>().ToList();
Logger = new FakeLogger <SendEmailToEmployerCommandHandler>();
MessageHandlerContext = new Mock <IMessageHandlerContext>();
PipelineContext = MessageHandlerContext.As <IPipelineContext>();
AccountApiClient = new Mock <IAccountApiClient>();
AccountApiClient.Setup(x => x.GetAccountUsers(It.IsAny <long>())).ReturnsAsync(Employees);
Handler = new SendEmailToEmployerCommandHandler(AccountApiClient.Object, Logger);
}
public void ResetAllPendingToQueued_PreservesOriginalOrder()
{
var storage = JobStorageFactory();
var queueItems = Fixture.CreateMany <TQueue>(15).ToList();
foreach (var item in queueItems)
{
storage.Queue(item);
}
storage.ResetAllPendingToQueued();
List <TQueue> items = SlideItemsToPending(storage).ToList();
Assert.True(queueItems.SequenceEqual(items, GenericEqualityComparer <TQueue> .ByAllMembers()));
}
private void ScatterCardsOnTable(Table table, int count)
{
var cards = _f.CreateMany <Card>(count).ToList();
if (cards.Count >= 4)
{
table.GameField.Pile.Push(cards.Take(4).ToList(), PilePosition.Default);
}
if (cards.Count > 4)
{
table.Stock?.Pile.Push(cards.Skip(4).Take(3).ToList(), PilePosition.Default);
}
if (cards.Count > 7)
{
table.Discard?.Pile.Push(cards.Skip(7).ToList(), PilePosition.Default);
}
}
public void Arrange()
{
_fixture = new Fixture();
_paymentRequestsLimit = 3;
_mockPayableLegalEntityQueryRepository = new Mock <IPaymentsQueryRepository>();
_mockAccountDataRepository = new Mock <IAccountDataRepository>();
_mockBusinessCentralFinancePaymentsService = new Mock <IBusinessCentralFinancePaymentsService>();
_mockBusinessCentralFinancePaymentsService.Setup(x => x.PaymentRequestsLimit)
.Returns(_paymentRequestsLimit);
_paymentsToSend = _fixture.CreateMany <PaymentDto>(5).ToList();
_unsentPayments = _paymentsToSend.TakeLast(5 - _paymentRequestsLimit).ToList();
_command = new SendPaymentRequestsCommand(_fixture.Create <long>(), _fixture.Create <DateTime>());
_sut = new SendPaymentRequestsCommandHandler(_mockAccountDataRepository.Object, _mockPayableLegalEntityQueryRepository.Object, _mockBusinessCentralFinancePaymentsService.Object);
}
public async Task RunWithNullProjectInRequestShouldThrowException()
{
// Arrange
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var releasePipeline = fixture.Create <ReleaseDefinition>();
// Act
var activity = new ScanReleasePipelinesActivity(
fixture.Create <EnvironmentConfig>(),
fixture.CreateMany <IReleasePipelineRule>());
var exception = await Assert.ThrowsAsync <ArgumentNullException>(async() =>
await activity.RunAsync((null, releasePipeline)));
exception.Message.ShouldContainWithoutWhitespace("Value cannot be null. (Parameter 'input')");
}
public async Task _then_service_points_are_returned_to_the_clitn()
{
var serviceResult = Fixture.CreateMany <PostNord.ServicePoint>().ToList();
_postNordClientMock.Setup(
c =>
c.FindNearestByAddress(It.IsAny <RegionInfo>(), It.IsAny <string>(), It.IsAny <string>(),
It.IsAny <string>(), null, It.IsAny <int>(), It.IsAny <string>()))
.ReturnsAsync(serviceResult);
var result = await _sut.Get(_street, Fixture.Create <string>(), Fixture.Create <string>());
foreach (var servicePoint in serviceResult)
{
result.Single(r => r.value.Id == servicePoint.Id).ShouldBeEquivalentOf(servicePoint);
}
}
public void Component_SerializeListOfEnums_ResultIsTheSameAsInput()
{
//Arrange
List <TestEnum> toSerialize = _fixture.CreateMany <TestEnum>(20).ToList();
//Act
var result = AvroConvert.Serialize(toSerialize);
var deserialized = AvroConvert.Deserialize <List <TestEnum> >(result);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(toSerialize, deserialized);
}
public void PushStartBackWhenOffsetsPutStartInTheFuture(int imageCount, int durationHours, int?offsetMonth, int?offsetDay, int?offsetHour, DateTime now, int expectedIndex, [Frozen] Mock <IDateTimeProvider> dateTimeProviderMock, SkinCalculator skinCalculator)
{
var fixture = new Fixture();
dateTimeProviderMock.Setup(x => x.Now()).Returns(now);
fixture.Register(() => TimeSpan.FromHours(durationHours));
fixture.Register(() => (IList <string>)fixture.CreateMany <string>(imageCount).ToList());
var skin = fixture.Create <Skin>();
skin.StartOffset.Month = offsetMonth;
skin.StartOffset.Day = offsetDay;
skin.StartOffset.Hour = offsetHour;
var nextImages = skinCalculator.NextImage(skin, now);
Assert.Equal(skin.Images[expectedIndex], nextImages.First());
}
static void Main(string[] args)
{
var fixture = new Fixture();
int elementsCount = 10000;
Console.WriteLine($"{DateTime.Now} - Start for {elementsCount} elements");
List <User> users = fixture.CreateMany <User>(elementsCount).ToList();
Console.WriteLine($"{DateTime.Now} - Users prepared");
TestPerformanceOfAtrributeReading(users);
Console.WriteLine("\nEnd - press any key to exit...");
Console.Read();
}
private void CreateTestRelatedData()
{
TestDirectorSeeded = CreatePersonWithoutRelatedInfo();
TestDirectorNotSeeded = CreatePersonWithoutRelatedInfo();
TestActorNotSeeded = CreatePersonWithoutRelatedInfo();
TestActorSeeded = CreatePersonWithoutRelatedInfo();
TestWriterNotSeeded = CreatePersonWithoutRelatedInfo();
TestWriterSeeded = CreatePersonWithoutRelatedInfo();
TestCompanyNotSeeded = CreateCompanyWithoutRelatedInfo();
TestCompanySeeded = CreateCompanyWithoutRelatedInfo();
RatingSources = fixture.CreateMany <RatingSource>().ToList();
RatingSources.ForEach(x => x.Ratings = new List <Rating>());
}
public async Task GetRates_FormatAndValidateArgs_AndConvertResult()
{
var rates = fixture.CreateMany <CurrencyRate>().ToList();
var formattedFrom = fixture.Create <string>();
formatter.Setup(f => f.FormatName(rates.First().CurrencyFrom)).Returns(formattedFrom);
validator.Setup(v => v.Validate(formattedFrom));
ratesReader.Setup(r => r.GetRates(formattedFrom)).ReturnsAsync(rates);
var result = await svc.GetRates(rates.First().CurrencyFrom);
var expectedResult = rates.ToDto();
result.Should().BeEquivalentTo(expectedResult);
}
public async void Given_a_list_of_products_and_a_list_of_ingredients_should_merge_they()
{
//Arrange
var fixture = new Fixture();
var productList = fixture.CreateMany <ProductToGet>();
//var igredientList = fixture.CreateMany<>();
//var mergeService = new MergeService();
//Act
//var result = mergeService.MergeProductsAndIngredients()
//Assert
}
public void MoreThanOneChangeIsNotNull()
{
var data = Fixture.CreateMany <RequestedChange>(10).ToArray();
var index = new Random().Next(0, data.Length);
data[index] = new RequestedChange
{
AddGradeSeparatedJunction = Fixture.Create <Messages.AddGradeSeparatedJunction>(),
AddRoadNode = Fixture.Create <Messages.AddRoadNode>(),
AddRoadSegment = Fixture.Create <Messages.AddRoadSegment>(),
AddRoadSegmentToEuropeanRoad = Fixture.Create <Messages.AddRoadSegmentToEuropeanRoad>(),
AddRoadSegmentToNationalRoad = Fixture.Create <Messages.AddRoadSegmentToNationalRoad>(),
AddRoadSegmentToNumberedRoad = Fixture.Create <Messages.AddRoadSegmentToNumberedRoad>(),
};
Validator.ShouldHaveValidationErrorFor(c => c.Changes, data);
}
public async Task Then_data_is_fetched_from_database()
{
// Arrange
var allAccounts = _fixture.CreateMany <Models.Account>(10).ToArray();
const long accountLegalEntityId = -1;
allAccounts[1].AccountLegalEntityId = accountLegalEntityId;
_context.Accounts.AddRange(allAccounts);
_context.SaveChanges();
// Act
var actual = await _sut.Get(x => x.AccountLegalEntityId == accountLegalEntityId);
//Assert
actual.Should().BeEquivalentTo(allAccounts[1], opts => opts.ExcludingMissingMembers());
}
public void Autofixture_Demo()
{
// https://github.com/AutoFixture/AutoFixture
// https://github.com/AutoFixture/AutoFixture/wiki/Cheat-Sheet
Fixture fix = new Fixture(); // Konfiguration
var person = fix.Create <Person>();
var personen = fix.CreateMany <Person>(1000).ToArray();
// Geschachtelt:
var company = fix.Create <Company>();
// Zahl in einem bestimmten Bereich:
// https://stackoverflow.com/questions/40811099/autofixture-for-number-ranges
}
public static void TestPropertyNameGeneration()
{
var ins = FastBulkInsertUtil.CreateBulkInserter <TestDbEntityWithoutAnnotations>(
TableMappingRules.UpperSnake("MY_GEN_NAME"));
Check.That(ins.TableName).Equals("MY_GEN_NAME");
var f = new Fixture();
var ds = f.CreateMany <TestDbEntityWithoutAnnotations>().ToArray();
var instr = ins.BuildInstructionsForRows(ds);
Check.That(instr).HasSize(4);
Check.That(instr[0].DbParamType).Equals(DbParameterTypeNumbers.Raw);
Check.That(instr[1].DbParamType).Equals(DbParameterTypeNumbers.NVarChar);
Check.That(instr[2].DbParamType).Equals(DbParameterTypeNumbers.Date);
// enum is number
Check.That(instr[3].DbParamType).Equals(DbParameterTypeNumbers.Number);
}
public void ReturnsProjectsFromRequest(int projectCount)
{
// Arrange
var context = new Mock <IDurableActivityContext>();
var client = new Mock <IVstsRestClient>();
var projects = _fixture.CreateMany <Project>(projectCount).ToList();
client.Setup(c => c.Get(It.IsAny <IEnumerableRequest <Project> >()))
.Returns(projects);
// Act
var fun = new GetProjectsActivity(client.Object);
var result = fun.Run(context.Object);
// Assert
result.Union(projects).Count().ShouldBe(projectCount);
}
public bool CheckMovieLimitTest(int requestCount)
{
var users = F.CreateMany <RequestLimit>().ToList();
users.Add(new RequestLimit {
Username = "", RequestCount = requestCount, RequestType = RequestType.Movie
});
RequestLimitRepo.Setup(x => x.GetAllAsync()).ReturnsAsync(users);
var settings = new PlexRequestSettings {
AlbumWeeklyRequestLimit = 0, MovieWeeklyRequestLimit = 5, TvWeeklyRequestLimit = 0
};
var result = Search.CheckRequestLimit(settings, RequestType.Movie).Result;
RequestLimitRepo.Verify(x => x.GetAllAsync(), Times.Once);
return(result);
}
public void PerformanceTest_WithSizeSearchOptions_ExecutesCorrectlyWithinTime()
{
// arrange
var searchOptions = new SearchOptions
{
Sizes = Fixture.CreateMany <Size>().ToList()
};
SearchResults results = null;
// act
Action act = () => results = ClassUnderTest.Search(searchOptions);
// assert
act.ExecutionTimeOf(s => s()).Should().BeLessOrEqualTo(TimeSpan.FromMilliseconds(100));
AssertResults(searchOptions, results.Shirts);
AssertColorCounts(searchOptions, results.ColorCounts);
AssertSizeCounts(searchOptions, results.SizeCounts);
}
public OrderBoolTests()
{
//Given
var datas = Fixture.CreateMany <SampleData>(11).ToList();
var count = 0;
foreach (var data in datas)
{
data.Can = true;
data.Age = count++;
}
datas[7].Can = false;
Bulk(datas);
ElasticClient.Indices.Refresh();
}
public async Task Then_the_hub_page_is_displayed_for_the_account()
{
// Arrange
var legalEntities = _fixture.CreateMany <LegalEntityModel>(2).ToList();
_viewModel.Selected = legalEntities[0].AccountLegalEntityId;
// Act
var result = await _sut.ChooseOrganisation(_viewModel) as RedirectToActionResult;
// Assert
result.Should().NotBeNull();
result.ActionName.Should().Be("Index");
result.ControllerName.Should().Be("Hub");
result.RouteValues["AccountId"].Should().Be(_viewModel.AccountId);
result.RouteValues["AccountLegalEntityId"].Should().Be(_viewModel.Selected);
}
