public void ShowDestinationCommandShouldNavigateToPlacePage()
{
_mainPageViewModel.ShowDestinationCommand.Execute(_destinationBuilder.Generate());
A.CallTo(() => _autoFake.Resolve <INavigationService>().NavigateAsync(nameof(PlacePage), A <NavigationParameters> ._))
.MustHaveHappenedOnceExactly();
}
public void TestAutoFaker()
{
var fake = new AutoFaker <TimeHolder>()
.RuleFor(x => x.Time, faker => _validDate);
var created = fake.Generate();
created = fake.Generate();
created.Should().NotBeNull();
}
public async Task GetSuperfundTest()
{
Guid superFundID = AutoFaker.Generate <Guid>();
var response = await instance.GetSuperfundAsync(accessToken, xeroTenantId, superFundID);
Assert.IsType <SuperFunds>(response);
}
public async Task GetPayslipTest()
{
Guid payslipID = AutoFaker.Generate <Guid>();
var response = await instance.GetPayslipAsync(accessToken, xeroTenantId, payslipID);
Assert.IsType <PayslipObject>(response);
}
public async Task GetPayrollCalendarTest()
{
Guid payrollCalendarID = AutoFaker.Generate <Guid>();
var response = await instance.GetPayrollCalendarAsync(accessToken, xeroTenantId, payrollCalendarID);
Assert.IsType <PayrollCalendars>(response);
}
public async Task GetLeaveApplicationTest()
{
Guid leaveApplicationId = AutoFaker.Generate <Guid>();
var response = await instance.GetLeaveApplicationAsync(accessToken, xeroTenantId, leaveApplicationId);
Assert.IsType <LeaveApplications>(response);
}
public async Task GetEmployeeTest()
{
Guid employeeId = AutoFaker.Generate <Guid>();
var response = await instance.GetEmployeeAsync(accessToken, xeroTenantId, employeeId);
Assert.IsType <Employees>(response);
}
public static ListNode GenerateList(int size)
{
var nodes = new ListNode[size];
for (var i = 0; i < size; i++)
{
nodes[i] = new ListNode
{
Data = AutoFaker.Generate <string>()
};
var node = nodes[i];
if (i > 0)
{
var previous = nodes[i - 1];
node.Previous = previous;
previous.Next = node;
}
}
foreach (var node in nodes)
{
var rndIndex = _rnd.Next(size * 2);
if (rndIndex < size)
{
node.Random = nodes[rndIndex];
}
}
return(nodes[0]);
}
public void Should_Populate_Field()
{
var protobuf = AutoFaker.Generate <Protobuf>();
protobuf.Field.Should().NotBeEmpty();
protobuf.MapField.Should().NotBeEmpty();
}
public async Task Handler_WithValidRequestUrl_AndMatchingBrowserProfile_ShouldBeSelectMode_AndUseThatBrowserProfile()
{
// Arrange
var requestUrl = new Faker().Internet.Url();
var host = new Uri(requestUrl).Host;
var command = new ApplicationInitializeCommand(new[] { requestUrl });
var browserFaker = new AutoFaker <Browser>()
.UsePrivateConstructor();
var profileFaker = new AutoFaker <Profile>()
.UsePrivateConstructor();
//.RuleFor(p => p.Websites, new AutoFaker<Website>()
// .RuleFor(w => w.Domain, host)
// .Generate(1));
var browserProfiles = new AutoFaker <BrowserProfile>()
.CustomInstantiator(f => new BrowserProfile(browserFaker.Generate(), profileFaker.Generate(), f.Random.String()))
.Generate(1);
_browserService
.Setup(x => x.GetBrowserProfilesAsync())
.ReturnsAsync(browserProfiles);
// Act
var result = await _handler.Handle(command, CancellationToken.None);
// Assert
_applicationStore.VerifySet(x => x.ApplicationMode = ApplicationMode.Select, Times.Once);
_browserService.Verify(x => x.UseBrowserProfileAsync(browserProfiles.First(), requestUrl, false), Times.Once);
result.Should().BeOfType <Unit>();
}
private static Func <Type, string, (bool handled, object result)> ChildConverter()
{
return((type, value) =>
{
if (type == typeof(Child))
{
if (string.IsNullOrEmpty(value))
{
return (true, null);
}
//use a specific type of generation for this value
Child instance;
if (value == "Child1")
{
var faker = new AutoFaker <Child>()
.RuleFor(p => p.Name, f => "child1");
instance = faker.Generate();
}
else
{
//use std generation
instance = AutoFaker.Generate <Child>();
}
return (true, instance);
}
return (false, null);
});
}
public void Equals_SameArray_ReturnsTrue()
{
var expected = AutoFaker.Generate <InputMetadata>(3);
var actual = expected.Select(i => new InputMetadata(i)).ToList();
CollectionAssert.AreEqual(expected, actual);
}
public void Equals_SamePropertyValues_ReturnsTrue()
{
var expected = AutoFaker.Generate <InputMetadata>();
var actual = new InputMetadata(expected);
Assert.AreEqual(expected, actual);
}
public static IUserContext CreateUserContext()
{
var userContextMock = Substitute.For <IUserContext>();
userContextMock.UserId.Returns(AutoFaker.Generate <Guid>());
return(userContextMock);
}
private List <Exam> GetMockExams()
{
var autoFaker = new AutoFaker <Exam>();
var exams1 = Enumerable.Range(0, 10).Select(_ => autoFaker.Generate()).ToList();
var exams = new List <Exam>()
{
new Exam
{
Id = 1,
Title = "Exam 1"
},
new Exam
{
Id = 2,
Title = "Exam 2"
},
new Exam
{
Id = 3,
Title = "Exam 3"
}
};
return(exams1);
}
public void ConvertsEachMember()
{
var code = AutoFaker.Generate <string>();
var interfaceName = AutoFaker.Generate <string>();
var interfaceCode = AutoFaker.Generate <string>();
var interfaceData = new InterfaceData {
Name = interfaceName, Code = interfaceCode
};
parser.Setup(it => it.ExtractInterface(code)).Returns(interfaceData);
var members = new[]
{
new Mock <Member>().Object,
new Mock <Member>().Object,
new Mock <Member>().Object,
};
parser.Setup(it => it.ExtractMembers(interfaceCode)).Returns(members);
sut.Generate(code);
foreach (var member in members)
{
memberGenerator.Verify(it => it.Generate(member));
}
}
public void Service_GetPending_Should_Return_Items()
{
var id = Faker.Generate <Guid>();
var item = AutoFaker.Generate <Item>();
var item1Override = new ProductCodeOverride();
var item2Override = new ProductCodeOverride();
var items = new List <Item>
{
Faker.Generate <Item, ItemFaker>(builder => builder.WithArgs(id).WithOverride(item1Override)),
AutoFaker.Generate <Item, ItemFaker>(builder => builder.WithArgs(id).WithOverride(item2Override))
};
item.Status = ItemStatus.Pending;
items.Add(item);
_repository.GetFiltered(Service.PendingFilter).Returns(items);
_service.GetPending().Should().BeSameAs(items);
items.ElementAt(0).ProductInt.Code.SerialNumber.Should().Be(item1Override.Code);
items.ElementAt(0).ProductString.Code.SerialNumber.Should().Be(item1Override.Code);
items.ElementAt(1).ProductInt.Code.SerialNumber.Should().Be(item2Override.Code);
items.ElementAt(1).ProductString.Code.SerialNumber.Should().Be(item2Override.Code);
items.ElementAt(2).ProductInt.Code.SerialNumber.Should().BeNull();
items.ElementAt(2).ProductString.Code.SerialNumber.Should().BeNull();
}
public void SetupPeople()
{
var faker = PersonFaker();
var jacob = faker.Generate();
jacob.FirstName = "Jacob";
var bob = faker.Generate();
bob.FirstName = "Bob";
var jacobWife = faker.Generate();
jacobWife.SpouseId = jacob.Id;
jacob.SpouseId = jacobWife.Id;
Assert.Empty(_dbConnection.People);
_dbConnection.Insert(jacob);
_dbConnection.Insert(jacobWife);
_dbConnection.Insert(bob);
_dbConnection.BulkCopy(faker.Generate(5));
_dbConnection.Insert(jacob.Staff);
_dbConnection.Insert(bob.Staff);
var jacobGroup = AutoFaker.Generate <OrgGroup>();
jacobGroup.Id = jacob.Staff.OrgGroupId ?? Guid.Empty;
jacobGroup.Supervisor = bob.Id;
jacobGroup.ApproverIsSupervisor = true;
_dbConnection.Insert(jacobGroup);
var jacobMissionOrg = AutoFaker.Generate <MissionOrg>();
jacobMissionOrg.Id = jacob.Staff.MissionOrgId ?? Guid.Empty;
_dbConnection.Insert(jacobMissionOrg);
}
public async Task GetTimesheetTest()
{
Guid timesheetID = AutoFaker.Generate <Guid>();
var response = await instance.GetTimesheetAsync(accessToken, xeroTenantId, timesheetID);
Assert.IsType <TimesheetObject>(response);
}
public void Should_Generate_Many_Complex_Types()
{
var count = AutoConfig.DefaultRepeatCount.Invoke(null);
var instances = AutoFaker.Generate <Order, TestFaker>(count, new object[0]);
AssertGenerateMany(instances);
}
protected ServiceFixture(ITestOutputHelper output, IAutoBinder binder)
{
_faker = AutoFaker.Create(builder =>
{
builder.WithOverride(new ProductGeneratorOverride());
if (binder != null)
{
builder.WithBinder(binder);
}
});
// Setup
var id = _faker.Generate <Guid>();
var generator = new AutoFaker <Item>(binder)
.RuleFor(item => item.Id, () => id)
.RuleFor(item => item.Name, faker => faker.Person.FullName)
.RuleFor(item => item.Amendments, faker => new HashSet <string> {
"1", "2", "3"
});
_item = generator;
_items = generator.Generate(5);
_repository = Substitute.For <IRepository>();
_repository.Get(id).Returns(_item);
_repository.GetAll().Returns(_items);
_service = new Service(_repository);
_output = output;
}
public void GenerateJsonFiles(string rootPath)
{
var model = AppDomain.CurrentDomain.Load("Syinpo.Model");
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
var types = model.GetTypes().Where(w => w.Namespace.Contains("Syinpo.Model.Dto") || w.Namespace.Contains("Syinpo.Model.Core") || w.Namespace.Contains("Syinpo.Model.ViewResult") || w.Namespace.Contains("Syinpo.Model.Request")).ToList();
int i = 0;
foreach (var type in types)
{
try {
if (type.FullName == "Syinpo.Model.ViewResult.Safety.DeviceEventProcessResult" || type.FullName == "Syinpo.Model.Core.WeChat.Processor.WeChatMsgParameters" || type.FullName == "Syinpo.Model.Core.WeChat.Processor.WeChatMsgResult")
{
continue;
}
Console.WriteLine("{0}: {1}", i, type.FullName);
var filename = type.FullName + ".json";
var path = Path.Combine(rootPath, filename);
var text = JsonHelper.ToJson(AutoFaker.Generate(type));
File.WriteAllText(path, text);
}
catch (Exception ex) {
Console.WriteLine(ex.Message);
}
finally {
i++;
}
}
}
public void SetupTraining()
{
var personFaker = PersonFaker();
var personWithTraining = personFaker.Generate();
var trainingRequirement = AutoFaker.Generate <TrainingRequirement>();
trainingRequirement.FirstYear = 2015;
trainingRequirement.LastYear = 2018;
trainingRequirement.DepartmentId = personWithTraining.Staff.OrgGroupId;
trainingRequirement.Scope = TrainingScope.Department;
var orgGroup = AutoFaker.Generate <OrgGroup>();
orgGroup.Id = personWithTraining.Staff.OrgGroupId ?? Guid.Empty;
DbConnection.Insert(orgGroup);
DbConnection.Insert(personWithTraining);
DbConnection.Insert(personWithTraining.Staff);
DbConnection.Insert(trainingRequirement);
var staffTraining = AutoFaker.Generate <StaffTraining>();
staffTraining.StaffId =
personWithTraining.StaffId ?? throw new NullReferenceException("person staff id is null");
staffTraining.TrainingRequirementId = trainingRequirement.Id;
DbConnection.Insert(staffTraining);
}
public void Should_Populate_Object()
{
var obj = AutoFaker.Generate <Obj>();
obj.Should().NotBeNull();
obj.Properties.Should().NotBeNull();
}
public PersonRole InsertRole(Action <PersonRole> action = null)
{
var role = AutoFaker.Generate <PersonRole>();
role.Active = true;
role.EndDate = null;
action?.Invoke(role);
if (role.StartDate == default)
{
role.StartDate = DateTime.Now.AddYears(-2);
}
if (!role.Active && !role.EndDate.HasValue)
{
role.EndDate = role.StartDate.AddYears(1);
}
if (role.EndDate.HasValue)
{
role.StartDate.ShouldBeLessThan(role.EndDate.Value);
}
DbConnection.Insert(role);
return(role);
}
public Behaviors_Recursive()
{
_instance = AutoFaker.Generate <TestRecursiveClass>(builder =>
{
builder.WithRecursiveDepth(3);
});
}
public void Should_Generate_Many_Complex_Types()
{
var configure = CreateConfigure <IAutoFakerConfigBuilder>(AutoFaker.DefaultConfig);
var instances = AutoFaker.Generate <Order, TestFaker>(AutoConfig.DefaultRepeatCount, configure);
AssertGenerateMany(instances);
}
public async Task GivenStoreItem_WhenValid_ThenValidEntity()
{
// arrange
var id = AutoFaker.Generate <Guid>();
var code = AutoFaker.Generate <string>();
var data = AutoFaker.Generate <string>();
var userId = AutoFaker.Generate <Guid>();
// act
StoreItem item = null !;
Func <Task> action = () =>
{
item = new StoreItem(id, code, userId)
{
Data = data
};
return(Task.CompletedTask);
};
// assert
using (new AssertionScope())
{
await action.Should().NotThrowAsync();
item.Id.Should().Be(id);
item.Code.Should().Be(code);
item.Data.Should().Be(data);
item.UserId.Should().Be(userId);
}
}
static void GenerateData()
{
var argType = typeof(Action <>).MakeGenericType(typeof(IAutoGenerateConfigBuilder));
var person = AutoFaker.Generate <Person>();
var generatMethod = typeof(AutoFaker).GetMethod("Generate", new[] { argType });
var generatePerson = generatMethod.MakeGenericMethod(typeof(Person));
object p = generatePerson.Invoke(null, new object[] { null });
}
public static IEnumerable <object[]> ItemsData()
{
return(new List <object[]>
{
new object[] { AutoFaker.Generate <Item>(50) },
new object[] { new List <Item>() } //empty list
});
}
