public async Task GivenACompanyHouseSearchClient_WhenSearchingForAOfficer()
{
var fixture = new Fixture();
var items = fixture.Build<Item>()
.With(x => x.Kind, "searchresults#officer")
.CreateMany().ToArray();
_resourceDetails = fixture.Build<ResourceDetails>()
.With(x => x.Officers, items)
.Create();
var uri = new Uri("https://wibble.com/search/companies");
var resource = new OfficerSearchResourceBuilder()
.CreateResource(_resourceDetails);
HttpMessageHandler handler = new StubHttpMessageHandler(uri, resource);
var uriBuilder = new Mock<ISearchUriBuilder>();
uriBuilder.Setup(x => x.Build(It.IsAny<SearchRequest>()))
.Returns(uri);
var uriBuilderFactory = new Mock<ISearchUriBuilderFactory>();
uriBuilderFactory.Setup(x => x.Create<OfficerSearch>())
.Returns(uriBuilder.Object);
_client = new CompaniesHouseSearchClient(new HttpClient(handler), uriBuilderFactory.Object);
_result = await _client.SearchAsync<OfficerSearch>(new SearchRequest());
}
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;
}
internal static Blog BuildAnyBlogWithRelations(Fixture f)
{
var blog = new Blog()
{
Author = f.Create<string>(),
Description = f.Create<string>(),
Name = f.Create<string>(),
Posts = f.Build<Post>()
.OmitAutoProperties()
.With(p => p.Date, f.Create<string>())
.With(p => p.Text, f.Create<string>())
.CreateMany()
.ToList(),
Followers = f.Build<Follower>()
.OmitAutoProperties()
.With(p => p.Name, f.Create<string>())
.CreateMany()
.ToList(),
};
// The Url must be unique, since its an alternate key on the post
foreach (var p in blog.Posts)
{
p.Url = Guid.NewGuid().ToString();
}
return blog;
}
public CompanyFilingHistory Build(CompaniesHouseCompanyFilingHistoryClientTestCase testCase)
{
var fixture = new Fixture();
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<FilingHistoryItem>(x => x.DateOfProcessing));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<FilingHistoryItemAnnotation>(x => x.DateOfAnnotation));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<FilingHistoryItemAssociatedFiling>(x => x.Date));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<FilingHistoryItemResolution>(x => x.DateOfProcessing));
var annotations = fixture.Build<FilingHistoryItemAnnotation>()
.CreateMany().ToArray();
var associatedFilings = fixture.Build<FilingHistoryItemAssociatedFiling>()
.CreateMany().ToArray();
var resolutions = fixture.Build<FilingHistoryItemResolution>()
.With(x => x.Category, testCase.ResolutionCategory)
.With(x => x.Subcategory, testCase.Subcategory)
.CreateMany().ToArray();
var items = fixture.Build<FilingHistoryItem>()
.With(x => x.Category, testCase.Category)
.With(x => x.Subcategory, testCase.Subcategory)
.With(x => x.Annotations, annotations)
.With(x => x.AssociatedFilings, associatedFilings)
.With(x => x.Resolutions, resolutions)
.CreateMany().ToArray();
var filingHistory = fixture.Build<CompanyFilingHistory>()
.With(x => x.HistoryStatus, testCase.HistoryStatus)
.With(x => x.Items, items)
.Create();
return filingHistory;
}
public static TestData Create(bool existingUser = false)
{
var fixture = new Fixture();
var testData = new TestData
{
Fixture = fixture,
UserManager = new Mock<IUserManager>(),
SystemRoleManager = new Mock<ISystemRoleManager>(),
SystemSettings = new Mock<ISystemSettings>(),
AdministratorUserName = fixture.Create<string>("UserName"),
AdministratorPassword = fixture.Create<string>("Password"),
AdministratorEmailAddress = fixture.Create<string>("EmailAddress"),
AdministratorRole = fixture.Build<SystemRole>()
.With(i => i.RoleType, EnumSystemRoleType.Administrator)
.Create()
};
if (existingUser)
{
testData.ExistingUser = fixture.Build<SrirachaUser>()
.With(i => i.UserName, testData.AdministratorUserName)
.Create();
testData.UserManager.Setup(i => i.GetUser(testData.ExistingUser.Id)).Returns(testData.ExistingUser);
testData.UserManager.Setup(i => i.TryGetUserByUserName(testData.ExistingUser.UserName)).Returns(testData.ExistingUser);
testData.UserManager.Setup(i => i.GetUserByUserName(testData.ExistingUser.UserName)).Returns(testData.ExistingUser);
}
testData.SystemRoleManager.Setup(i => i.GetBuiltInRole(EnumSystemRoleType.Administrator)).Returns(testData.AdministratorRole);
testData.Sut = new SystemSetterUpper(testData.UserManager.Object, testData.SystemRoleManager.Object, testData.SystemSettings.Object);
return testData;
}
public void SettingSpouseIsPossible()
{
// Fixture setup
var fixture = new Fixture();
var person = fixture.Build<Person>().Without(p => p.Spouse).CreateAnonymous();
var sut = fixture.Build<Person>().Without(p => p.Spouse).CreateAnonymous();
// Exercise system
sut.Spouse = person;
// Verify outcome
Assert.Equal<Person>(sut, person.Spouse);
// Teardown
}
public void GivenACompanyHouseSearchCompanyClient_WhenSearchingForACompany()
{
var fixture = new Fixture();
_resourceDetails = fixture.Create<ResourceDetails>();
_expectedCompanies = new List<CompanyDetails>
{
fixture.Build<CompanyDetails>().With(x => x.CompanyStatus, "active").With(x => x.CompanyType, "private-unlimited").Create(),
fixture.Build<CompanyDetails>().With(x => x.CompanyStatus, "dissolved").With(x => x.CompanyType, "private-unlimited").Create(),
fixture.Build<CompanyDetails>().With(x => x.CompanyStatus, "liquidation").With(x => x.CompanyType, "private-unlimited").Create(),
fixture.Build<CompanyDetails>().With(x => x.CompanyStatus, "receivership").With(x => x.CompanyType, "private-unlimited").Create(),
fixture.Build<CompanyDetails>().With(x => x.CompanyStatus, "administration").With(x => x.CompanyType, "private-unlimited").Create(),
fixture.Build<CompanyDetails>().With(x => x.CompanyStatus, "voluntary-arrangement").With(x => x.CompanyType, "private-unlimited").Create(),
fixture.Build<CompanyDetails>().With(x => x.CompanyStatus, "converted-closed").With(x => x.CompanyType, "private-unlimited").Create(),
fixture.Build<CompanyDetails>().With(x => x.CompanyStatus, "insolvency-proceedings").With(x => x.CompanyType, "private-unlimited").Create(),
};
var uri = new Uri("https://wibble.com/search/companies");
var resource = new CompanySearchResourceBuilder()
.AddCompanies(_expectedCompanies)
.CreateResource(_resourceDetails);
HttpMessageHandler handler = new StubHttpMessageHandler(uri, resource);
var httpClientFactory = new Mock<IHttpClientFactory>();
httpClientFactory.Setup(x => x.CreateHttpClient())
.Returns(new HttpClient(handler));
var uriBuilder = new Mock<ICompanySearchUriBuilder>();
uriBuilder.Setup(x => x.Build(It.IsAny<CompanySearchRequest>()))
.Returns(uri);
_client = new CompaniesHouseSearchCompanyClient(httpClientFactory.Object, uriBuilder.Object);
_result = _client.SearchCompanyAsync(new CompanySearchRequest()).Result;
}
public void BuildOrderWithShippingAddressInDenmark()
{
// Fixture setup
var fixture = new Fixture();
// Exercise system
var order = fixture.Build<Order>()
.With(o => o.ShippingAddress,
fixture.Build<Address>()
.With(a => a.Country, "Denmark")
.CreateAnonymous())
.CreateAnonymous();
// Verify outcome
Assert.Equal<string>("Denmark", order.ShippingAddress.Country);
// Teardown
}
public async Task Save_should_update_an_existing_product()
{
using (var store = NewDocumentStore())
{
using (var session = store.OpenAsyncSession())
{
// Arrange
var fixture = new Fixture();
var product = fixture.Build<Product>()
.With(c => c.Id, "Products-1")
.With(c => c.Name, "Mediums")
.Create();
await SaveEntity(product, session);
// Act
var dto = new ProductDto {Id = "Products-1", Name = "Updated name"};
var service = GetProductsService(session);
var model = await service.Save(dto);
model.Message.Should().Be("Atualizou tipo Updated name");
}
using (var session = store.OpenAsyncSession())
{
var actual = await session.LoadAsync<Product>("Products-1");
actual.Name.Should().Be("Updated name");
}
}
}
public async Task GetById_should_retrieve_a_product_from_the_db()
{
using (var store = NewDocumentStore())
{
using (var session = store.OpenAsyncSession())
{
// Arrange
var fixture = new Fixture();
var product = fixture.Build<Product>()
.With(c => c.Id, "Products-1")
.With(c => c.Name, "Mediums")
.Create();
await SaveEntity(product, session);
// Act
var service = GetProductsService(session);
var actual = await service.GetById("Products-1");
// Assert
actual.Id.Should().Be("Products-1");
actual.Name.Should().Be("Mediums");
actual.Count.Should().Be(product.Count);
actual.Type.Should().Be(product.Type);
}
}
}
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 Should_Save_a_Job()
{
var fixture = new Fixture();
var job = fixture.Build<Job>()
.Without(c => c.Id)
.CreateAnonymous();
using (var saveContext = DbContext())
{
var repo = new Repository<Job>(saveContext);
repo.InsertOrUpdate(job);
repo.Save();
}
Job savedJob;
using (var readContext = DbContext())
{
var repo1 = new Repository<Job>(readContext);
savedJob = repo1.Find(job.Id);
}
// savedJob.Id.ShouldEqual(1);
var compare = new KellermanSoftware.CompareNetObjects.CompareObjects();
// savedJob is a proxy
compare.MaxDifferences = 1;
compare.Compare(job, savedJob);
(compare.Differences.Count <= 1).ShouldBeTrue();
Debug.WriteLine(compare.DifferencesString);
}
public UserDataBuilder()
{
var fixture = new Fixture();
user = fixture.Build<User>()
.Without(u => u.Id)
.Create();
}
public ResourceBuilders.CompanyProfile Build(CompaniesHouseCompanyProfileClientTestCase testCase)
{
var fixture = new Fixture();
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<ResourceBuilders.LastAccounts>(x => x.MadeUpTo));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<ResourceBuilders.Accounts>(x => x.NextMadeUpTo));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<ResourceBuilders.Accounts>(x => x.NextDue));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<ResourceBuilders.AnnualReturn>(x => x.LastMadeUpTo));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<ResourceBuilders.AnnualReturn>(x => x.NextDue));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<ResourceBuilders.AnnualReturn>(x => x.NextMadeUpTo));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<ResourceBuilders.CompanyProfile>(x => x.DateOfCreation));
fixture.Customizations.Add(
new UniversalDateSpecimenBuilder<ResourceBuilders.CompanyProfile>(x => x.DateOfDissolution));
fixture.Customizations.Add(
new UniversalDateSpecimenBuilder<ResourceBuilders.CompanyProfile>(x => x.LastFullMembersListDate));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<ResourceBuilders.Officer>(x => x.AppointedOn));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<ResourceBuilders.Officer>(x => x.ResignedOn));
fixture.Customizations.Add(new UniversalNullableDateSpecimenBuilder<ResourceBuilders.ConfirmationStatement>(x => x.NextMadeUpTo));
fixture.Customizations.Add(new UniversalNullableDateSpecimenBuilder<ResourceBuilders.ConfirmationStatement>(x => x.LastMadeUpTo));
fixture.Customizations.Add(new UniversalNullableDateSpecimenBuilder<ResourceBuilders.ConfirmationStatement>(x => x.NextDue));
var lastAccounts = fixture.Build<ResourceBuilders.LastAccounts>()
.With(x => x.Type, testCase.LastAccountsType)
.Create();
var accounts = fixture.Build<ResourceBuilders.Accounts>()
.With(x => x.LastAccounts, lastAccounts)
.Create();
var officers = EnumerationMappings.PossibleOfficerRoles.Keys.Select(x => fixture.Build<ResourceBuilders.Officer>()
.With(y => y.OfficerRole, x)
.Create()).ToArray();
var officerSummary = fixture.Build<ResourceBuilders.OfficerSummary>().With(x => x.Officers, officers).Create();
var companyProfile = fixture.Build<ResourceBuilders.CompanyProfile>()
.With(x => x.Accounts, accounts)
.With(x => x.CompanyStatus, testCase.CompanyStatus)
.With(x => x.CompanyStatusDetail, testCase.CompanyStatusDetail)
.With(x => x.Jurisdiction, testCase.Jurisdiction)
.With(x => x.Type, testCase.Type)
.With(x => x.OfficerSummary, officerSummary)
.Create();
return companyProfile;
}
internal static Post BuildAnyPost(Fixture fixture)
{
return fixture.Build<Post>()
.OmitAutoProperties()
.With(p => p.Text, fixture.Create<string>())
.With(p => p.Url, Guid.NewGuid().ToString())
.With(p => p.Date, fixture.Create<string>())
.Create();
}
public void BuildWithoutSpouseWillSucceed()
{
var fixture = new Fixture();
var person = fixture.Build<Person>()
.Without(p => p.Spouse)
.CreateAnonymous();
Assert.NotNull(person);
}
public void SutIsProfile()
{
// Fixture setup
var fixture = new Fixture();
// Exercise system
var sut = fixture.Build<UserProfile>().OmitAutoProperties().CreateAnonymous();
// Verify outcome
Assert.IsAssignableFrom<ProfileBase>(sut);
// Teardown
}
public void BuildAndImmediatelyCreateAnonymous()
{
// Fixture setup
var fixture = new Fixture();
// Exercise system
var mc = fixture.Build<MyClass>().Create();
// Verify outcome
Assert.NotNull(mc);
// Teardown
}
public static void Run()
{
//var db=StaticConfig.Container
var db = DependencyResolver.Current.GetService<InMemoryDb>();
var f = new Fixture();
foreach (var p in f.Build<Post>().Without(d=>d.CreatedOn).CreateMany(5))
{
db.Save(p);
}
}
public void BuildExample()
{
var fixture = new Fixture();
var person = fixture.Build<Person>()
.Without(p => p.Lastname)
.Create();
Assert.IsNotNull(person);
}
public void CreateAddsItemToDb()
{
var fixture = new Fixture();
var db = fixture.Freeze<Db>();
var item = fixture.Build<DbItem>().Without(x => x.ParentID).Create();
var sut = new AddContentDbItemCommand();
sut.Execute(item, new SpecimenContext(fixture));
db.GetItem(item.ID).Should().NotBeNull();
}
public void DefaultCurrencyIsCorrect()
{
// Fixture setup
var fixture = new Fixture();
var sut = fixture.Build<ProductEditorViewModel>().OmitAutoProperties().CreateAnonymous();
// Exercise system
var result = sut.Currency;
// Verify outcome
Assert.Equal(string.Empty, result);
// Teardown
}
public Officers Build()
{
var fixture = new Fixture();
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<Officer>(x => x.AppointedOn));
fixture.Customizations.Add(new UniversalDateSpecimenBuilder<Officer>(x => x.ResignedOn));
var officers = EnumerationMappings.PossibleOfficerRoles.Keys.Select(x => fixture.Build<Officer>()
.With(y => y.OfficerRole, x)
.Create()).ToArray();
var officerSummary = fixture.Build<Officers>().With(x => x.Items, officers).Create();
var result = fixture.Build<Officers>()
.With(x => x.Items, officerSummary.Items)
.With(x => x.ActiveCount, officerSummary.ActiveCount)
.With(x => x.ResignedCount, officerSummary.ResignedCount)
.Create();
return result;
}
public void BuildMyViewModelAndOmitAutoPropertiesWillSucceed()
{
// Fixture setup
var fixture = new Fixture();
// Exercise system
var mvm = fixture.Build<MyViewModel>()
.OmitAutoProperties()
.Create();
// Verify outcome
Assert.NotNull(mvm);
// Teardown
}
public void BuildOrderWithManyOrderLines()
{
// Fixture setup
var fixture = new Fixture();
// Exercise system
var order = fixture.Build<Order>()
.Do(o => fixture.AddManyTo(o.OrderLines))
.CreateAnonymous();
// Verify outcome
Assert.Equal<int>(fixture.RepeatCount, order.OrderLines.Count);
// Teardown
}
public void CreateWithNullRepositoryWillThrow()
{
// Fixture setup
var fixture = new Fixture().Customize(new CommerceWebCustomization());
ProductRepository nullRepository = null;
// Exercise system and verify outcome
Assert.Throws<ArgumentNullException>(() =>
fixture.Build<CommerceControllerFactory>()
.FromFactory(() => new CommerceControllerFactory(nullRepository))
.CreateAnonymous());
// Teardown
}
public void BuildMyViewModelWithouSelectedItemWillSucceed()
{
// Fixture setup
var fixture = new Fixture();
// Exercise system
var mvm = fixture.Build<MyViewModel>()
.Without(s => s.SelectedItem)
.Create();
// Verify outcome
Assert.NotNull(mvm);
// Teardown
}
public void CreateMyClassWithPropertyConstrainedAsInTheFeatureRequest()
{
// Fixture setup
var fixture = new Fixture();
// Exercise system
var mc = fixture.Build<MyClass>()
.With(x => x.SomeText, 0, 100)
.Create();
// Verify outcome
Assert.True(0 <= mc.SomeText.Length && mc.SomeText.Length <= 100, "SomeText within constraints.");
// Teardown
}
public void CreateWithNullNameWillThrow()
{
// Fixture setup
var fixture = new Fixture();
string nullName = null;
// Exercise system and verify outcome
Assert.Throws<ArgumentNullException>(() =>
fixture.Build<DiscountedProduct>()
.FromFactory((decimal unitPrice) => new DiscountedProduct(nullName, unitPrice))
.CreateAnonymous());
// Teardown
}
public void CreateWithNullItemWillThrow()
{
// Fixture setup
var fixture = new Fixture();
Product nullItem = null;
// Exercise system and verify outcome
Assert.Throws<ArgumentNullException>(() =>
fixture.Build<Extent>()
.FromFactory(() => new Extent(nullItem))
.CreateAnonymous());
// Teardown
}
public void ContactUs_WhenModelIsValid_ReturnsContactUsView()
{
var emailSender = new Mock <ISendEmail>().Object;
var sut = new HomeController(Enumerable.Empty <IGenerateEmail>(), emailSender, MockReCaptchaService.Create(true));
Assert.True(sut.ModelState.IsValid);
var fixture = new Fixture();
var model = fixture.Build <ContactUsModel>()
.With(m => m.PhoneNumber, RandomDataGenerator.RandomPhoneNumber())
.Create();
//Act
// ReSharper disable once UnusedVariable
var result = sut.ContactUs(model);
// Assert
Assert.IsType <Task <IActionResult> >(result);
var redirectToActionResult = result.Result as RedirectToActionResult;
Assert.Equal(nameof(ThankYouController), redirectToActionResult?.ControllerName + "Controller");
Assert.Equal(nameof(ThankYouController.Index), redirectToActionResult?.ActionName);
}
public PaymentCommandHandlerTests()
{
_fixture = new Fixture();
_handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
_paymentRepositoryMock = new Mock <IPaymentCommandRepository>();
var httpClient = new HttpClient(_handlerMock.Object)
{
BaseAddress = new Uri("http://bank.com")
};
IOptions <AppSettings> appSettings = new OptionsWrapper <AppSettings>(new AppSettings
{
BankSimulatorPaymentUrl = "http://bank.com"
});
_paymentCommandHandler = new PaymentCommandHandler(new BankPaymentProcessor(httpClient, appSettings),
new PaymentCommandValidator(), _paymentRepositoryMock.Object);
_validPaymentCommand = _fixture.Build <PaymentCommand>()
.With(c => c.CardNumber, "1234567898765432")
.With(c => c.ExpiryMonth, DateTime.Now.Month)
.With(c => c.ExpiryYear, DateTime.Now.Year + 1)
.With(c => c.CurrencyCode, "GBP")
.Create();
}
public void SetUp()
{
var fixture = new Fixture().Customize(new AutoMoqCustomization());
_randomWageType = fixture.Create <int>();
_randomLegacyWageType = fixture.Create <int>();
_randomWageUnit = fixture.Create <int>();
_randomDurationType = (DurationType) new Random().Next(1, 4);
var durationTypeMapper = new DurationMapper();
_randomDomainDurationType = durationTypeMapper.MapTypeToDomainType(_randomDurationType);
_request = fixture.Build <CreateApprenticeshipRequest>()
.With(request => request.WageType, (WageType)_randomWageType)
.With(request => request.WageUnit, (WageUnit)_randomWageUnit)
.With(request => request.DurationType, _randomDurationType)
.With(request => request.IsEmployerDisabilityConfident, fixture.Create <bool>())
.Create();
_mockWageTypeMapper = fixture.Freeze <Mock <IWageTypeMapper> >();
_mockWageTypeMapper
.Setup(typeMapper => typeMapper.MapToLegacy(It.IsAny <CreateApprenticeshipRequest>()))
.Returns((LegacyWageType)_randomLegacyWageType);
_mockWageTextFormatter = fixture.Freeze <Mock <IWageTextFormatter> >();
fixture.Inject <IDurationMapper>(durationTypeMapper);
_employerInformation = fixture.Create <EmployerInformation>();
var mapper = fixture.Create <CreateApprenticeshipParametersMapper>();
_mappedParameters = mapper.MapFromRequest(_request, _employerInformation);
}
public void Setup()
{
var fixture = new Fixture();
var cursoRecords = fixture.CreateMany <Curso>().ToList();
cursoRecords.Add(fixture.Build <Curso>().With(tr => tr.CursoId, Guid.Empty).Create());
var options = new DbContextOptionsBuilder <EducationDbContext>()
.UseInMemoryDatabase(databaseName: $"EducationDbContext-{Guid.NewGuid()}")
.Options;
var educationDbContextFake = new EducationDbContext(options);
educationDbContextFake.Cursos.AddRange(cursoRecords);
educationDbContextFake.SaveChanges();
var mapConfig = new MapperConfiguration(cfg => {
cfg.AddProfile(new MappingTest());
});
var mapper = mapConfig.CreateMapper();
handlerAllCursos = new GetCursosQuery.GetCursoQueryHandler(educationDbContextFake, mapper);
}
/// <summary>
/// Create registration
/// </summary>
/// <returns></returns>
private static DiscovererRegistration CreateRegistration()
{
var fix = new Fixture();
var cert = fix.CreateMany <byte>(1000).ToArray();
var r = fix.Build <DiscovererRegistration>()
.FromFactory(() => new DiscovererRegistration(
fix.Create <string>(), fix.Create <string>()))
.With(x => x.Locales, fix.CreateMany <string>()
.ToList().EncodeAsDictionary())
.With(x => x.SecurityPoliciesFilter, fix.CreateMany <string>()
.ToList().EncodeAsDictionary())
.With(x => x.TrustListsFilter, fix.CreateMany <string>()
.ToList().EncodeAsDictionary())
.With(x => x.DiscoveryUrls, fix.CreateMany <string>()
.ToList().EncodeAsDictionary())
.Without(x => x.Certificate)
.Without(x => x.Thumbprint)
.Without(x => x.IsDisabled)
.Without(x => x.NotSeenSince)
.Create();
r._desired = r;
return(r);
}
public void TestThatQueryCallsMapOnFoodWasteObjectMapper()
{
var fixture = new Fixture();
var translationInfoMock = DomainObjectMockBuilder.BuildTranslationInfoMock();
var systemDataRepositoryMock = MockRepository.GenerateMock <ISystemDataRepository>();
systemDataRepositoryMock.Stub(m => m.Get <ITranslationInfo>(Arg <Guid> .Is.Anything))
.Return(translationInfoMock)
.Repeat.Any();
systemDataRepositoryMock.Stub(m => m.DataProviderForFoodItemsGet())
.Return(DomainObjectMockBuilder.BuildDataProviderMock())
.Repeat.Any();
systemDataRepositoryMock.Stub(m => m.FoodItemGetAll())
.Return(DomainObjectMockBuilder.BuildFoodItemMockCollection())
.Repeat.Any();
var foodWasteObjectMapperMock = MockRepository.GenerateMock <IFoodWasteObjectMapper>();
foodWasteObjectMapperMock.Stub(m => m.Map <IFoodItemCollection, IView>(Arg <IFoodItemCollection> .Is.Anything, Arg <CultureInfo> .Is.Anything))
.Return(MockRepository.GenerateMock <IView>())
.Repeat.Any();
var foodItemCollectionGetQueryHandlerBase = new MyFoodItemCollectionGetQueryHandler(systemDataRepositoryMock, foodWasteObjectMapperMock, fixture.Create <bool>());
Assert.That(foodItemCollectionGetQueryHandlerBase, Is.Not.Null);
var foodItemCollectionGetQuery = fixture.Build <FoodItemCollectionGetQuery>()
.With(m => m.TranslationInfoIdentifier, Guid.NewGuid())
.With(m => m.FoodGroupIdentifier, null)
.Create();
foodItemCollectionGetQueryHandlerBase.Query(foodItemCollectionGetQuery);
foodWasteObjectMapperMock.AssertWasCalled(m => m.Map <IFoodItemCollection, IView>(Arg <IFoodItemCollection> .Is.NotNull, Arg <CultureInfo> .Is.Equal(translationInfoMock.CultureInfo)));
}
public void Arrange()
{
_fixture = new Fixture();
_startDate = DateTime.Now.Date;
_censusDate = _startDate.AddDays(17);
_collectionPeriod = new CollectionPeriod(1, (byte)DateTime.Now.Month, (short)DateTime.Now.Year, DateTime.Now.AddMonths(-2), _censusDate, (short)DateTime.Now.Year, true);
_learningPeriod3 = new LearningPeriod(_startDate, null);
_learningPeriods = new List <LearningPeriod>()
{
new LearningPeriod(_startDate.AddDays(-60), _startDate.AddDays(-60 + 15)),
new LearningPeriod(_startDate.AddDays(-30), _startDate.AddDays(-30 + 12)),
_learningPeriod3
};
_sutModel = _fixture
.Build <LearnerModel>()
.With(l => l.LearningPeriods, _learningPeriods)
.With(l => l.DaysInLearnings, new List <DaysInLearning>())
.Create();
_sut = Sut(_sutModel);
}
public void SetUp()
{
"Given a fixture"
.Given(() =>
{
Fixture = new Fixture();
Fixture.Customize(new AutoMoqCustomization());
});
"And an inner comparison"
.And(() =>
{
Inner = Fixture.Freeze <Mock <IComparison> >();
Inner.Setup(x => x.Compare(It.IsAny <IComparisonContext>(), It.IsAny <object>(), It.IsAny <object>()))
.Returns <IComparisonContext, object, object>(
(c, v1, v2) =>
{
if (v1.Equals(v2))
{
return(ComparisonResult.Pass);
}
c.AddDifference(new Difference());
return(ComparisonResult.Fail);
});
});
"And a ComplexObjectComparison"
.And(() => SUT = Fixture.Build <ComplexObjectComparison>()
.OmitAutoProperties()
.Create());
"And a Comparison context object"
.And(() => Context = new ComparisonContext("Property"));
}
public void TestThatQueryReturnsViewFromMapOnFoodWasteObjectMapper()
{
var fixture = new Fixture();
var systemDataRepositoryMock = MockRepository.GenerateMock <ISystemDataRepository>();
systemDataRepositoryMock.Stub(m => m.Get <ITranslationInfo>(Arg <Guid> .Is.Anything))
.Return(DomainObjectMockBuilder.BuildTranslationInfoMock())
.Repeat.Any();
systemDataRepositoryMock.Stub(m => m.DataProviderForFoodGroupsGet())
.Return(DomainObjectMockBuilder.BuildDataProviderMock())
.Repeat.Any();
systemDataRepositoryMock.Stub(m => m.FoodGroupGetAllOnRoot())
.Return(DomainObjectMockBuilder.BuildFoodGroupMockCollection())
.Repeat.Any();
var viewMock = MockRepository.GenerateMock <IView>();
var foodWasteObjectMapperMock = MockRepository.GenerateMock <IFoodWasteObjectMapper>();
foodWasteObjectMapperMock.Stub(m => m.Map <IFoodGroupCollection, IView>(Arg <IFoodGroupCollection> .Is.Anything, Arg <CultureInfo> .Is.Anything))
.Return(viewMock)
.Repeat.Any();
var foodGroupTreeGetQueryHandlerBase = new MyFoodGroupTreeGetQueryHandler(systemDataRepositoryMock, foodWasteObjectMapperMock, fixture.Create <bool>());
Assert.That(foodGroupTreeGetQueryHandlerBase, Is.Not.Null);
var foodGroupTreeGetQuery = fixture.Build <FoodGroupTreeGetQuery>()
.With(m => m.TranslationInfoIdentifier, Guid.NewGuid())
.Create();
var result = foodGroupTreeGetQueryHandlerBase.Query(foodGroupTreeGetQuery);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(viewMock));
}
public async Task Register_Should_Call_UserManager()
{
// ARRANGE
var model = Fixture.Build <RegistrationModel>()
.With(_ => _.Email, "*****@*****.**")
.With(_ => _.Password, "cool1Password!!")
.Create();
_mockUserService.Setup(_ => _.RegisterAsync(model))
.ReturnsAsync(new UserModel());
_mockUrlHelper.Setup(_ => _.Link("GetUserAsync", It.IsAny <Dictionary <string, object> >()))
.Returns("http://testlink.com");
_mockProfileService.Setup(_ => _.GetInitialProfileImageAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(0));
// ACT
var result = await _profilesController.Register(model);
var message = await result.ExecuteAsync(new CancellationToken());
message.StatusCode.Should().Be(HttpStatusCode.Created);
}
public void ViewModelToRequest_GivenValidViewModel_PropertiesShouldBeMapped()
{
var viewModel = fixture.Build <AatfEditDetailsViewModel>()
.With(e => e.StatusValue, AatfStatus.Approved.Value)
.With(e => e.SizeValue, AatfSize.Large.Value)
.Create();
viewModel.CompetentAuthorityId = viewModel.CompetentAuthoritiesList.Last().Abbreviation;
var result = requestCreator.ViewModelToRequest(viewModel);
result.Should().NotBeNull();
result.Data.Id.Should().Be(viewModel.Id);
result.Data.Name.Should().Be(viewModel.Name);
result.Data.ApprovalNumber.Should().Be(viewModel.ApprovalNumber);
result.Data.CompetentAuthority.Abbreviation.Should().Be(viewModel.CompetentAuthorityId);
result.Data.AatfStatus.Should().Be(AatfStatus.Approved);
result.Data.SiteAddress.Should().Be(viewModel.SiteAddressData);
result.Data.Size.Should().Be(AatfSize.Large);
result.Data.FacilityType.Should().Be(viewModel.FacilityType);
result.Data.ApprovalDate.Should().Be(viewModel.ApprovalDate.GetValueOrDefault());
result.Data.AatfSizeValue.Should().Be(viewModel.SizeValue);
result.Data.AatfStatusValue.Should().Be(viewModel.StatusValue);
}
[Links(Policy = "FullInfoPolicy")] //if you want to add parent with same service needs to have same policy name
public async Task <Order> Get([FromRoute] Guid customerId, Guid id)
{
Fixture f = new Fixture();
var order = f.Build <Order>()
.With(a => a.Id, id)
.With(a => a.ForCustomerId, customerId)
.Without(w => w.Links)
.Create();
var customer = new Customer {
Id = customerId
};
await _linkService.AddLinksAsync(order);
await _linkService.AddLinksAsync(customer);
//if you add policy with the same name in this case FullInfoPolicy,
//then this use self from order, so stupid its made for simple crud behaviour out of the box
//but if you are explicit in the full info policy it all works nuts
order.AddLink("parent", customer.Links["self"]);
return(order);
}
public async void ReplaceById_WhenCalledWithValidIdQuestionUpdatedAsExpected()
{
const string replacementQuestionId = "1";
var questionFromRepo = await repository.GetById(replacementQuestionId);
if (questionFromRepo == null)
{
return;
}
var fixture = new Fixture();
var question = fixture.Build <Question>().Create();
const string replacementQuestionText = "This is the replacement text...";
question.Id = replacementQuestionId;
question.Text = replacementQuestionText;
await repository.ReplaceById(question);
questionFromRepo = await repository.GetById(replacementQuestionId);
questionFromRepo.ShouldNotBeNull();
questionFromRepo.Text.ShouldEqual(replacementQuestionText);
}
public void user_add_command_succed()
{
var fixture = new Fixture().Customize(new AutoNSubstituteCustomization {
ConfigureMembers = true
});
fixture.Register <EntityId>(() => EntityId.From(fixture.Create <Guid>()));
fixture.Register <Name>(() => Name.From(fixture.Create <string>()));
fixture.Register <Version>(() => Version.From(fixture.Create <int>()));
fixture.Register <SocialSecurityId>(() => SocialSecurityId.From(fixture.Create <string>()));
fixture.Register <Email>(() => Email.From(string.Format($"{fixture.Create<string>()}@teste.com")));
fixture.Register <User>(() => User.From(fixture.Create <EntityId>(),
fixture.Create <Name>(), fixture.Create <SocialSecurityId>(),
fixture.Create <Email>(), fixture.Create <Version>()));
var finalUser = fixture.Create <User>();
var command = fixture.Build <AddUserCommand>()
.With(user => user.CommercialEmail, finalUser.CommercialEmail.Value)
.With(user => user.Cnpj, finalUser.Cnpj.Value)
.With(user => user.Name, finalUser.Name.Value)
.Create();
var mediator = fixture.Create <IMediator>();
var logger = fixture.Create <ILogger <AddUserCommandHandler> >();
var db = fixture.Create <IDbSession <IUserRepository> >();
var handler = new AddUserCommandHandler(logger, mediator, db);
var result = handler.Execute(command);
db.Received().Repository.Add(finalUser);
db.Received().SaveChanges();
mediator.Received(1).Publish(Arg.Any <UserAddedEvent>());
Assert.True(result.IsSucceed);
}
public async Task Should_results_be_filtered_by_userName()
{
var fixture = new Fixture();
Post Create(string authorName)
{
var post = fixture.Build <Post>().Without(e => e.Author).Create();
post.Author = authorName;
return(post);
};
var posts_result = new[] {
Create("Lucas"),
Create("Bob"),
Create("Lucas"),
Create("Jonas"),
Create("lucas"),
Create("Michal"),
Create("Lucas "),
Create("Ruan"),
Create("Mudi"),
Create("LUCAS")
};
var rssReader = A.Fake <IRssPostReader>();
A.CallTo(() => rssReader.ReadPostsAsync(A <string> ._, A <DateTime> ._)).Returns(posts_result);
var repository = new PostsRepository(rssReader, DateTime.MinValue, fixture.Create <string>());
var posts = await repository.GetPagedPosts(1, 10, "Lucas");
posts.Should().HaveCount(5);
posts.Should().OnlyContain(e => e.Author.ToLowerInvariant().Contains("lucas"));
}
private void SetUp()
{
"Given a fixture".x(() =>
{
Fixture = new Fixture();
Fixture.Customize(new AutoMoqCustomization());
});
"And an inner comparison".x(() =>
{
Inner = new MockComparison();
Fixture.Inject <IComparison>(Inner);
});
"And a ComplexObjectComparison".x(() =>
SUT = Fixture.Build <ComplexObjectComparison>()
.OmitAutoProperties()
.Create()
);
"And a Comparison context object".x(() =>
Context = new ComparisonContext("Property")
);
}
public void Arrange()
{
var fixture = new Fixture();
var birthDate = fixture.Create <DateTime?>();
var startDate = fixture.Create <DateTime?>();
var endDate = fixture.Create <DateTime?>();
_mapper = new UpdateDraftApprenticeshipRequestMapper();
_source = fixture.Build <EditDraftApprenticeshipViewModel>()
.With(x => x.BirthDay, birthDate?.Day)
.With(x => x.BirthMonth, birthDate?.Month)
.With(x => x.BirthYear, birthDate?.Year)
.With(x => x.EndMonth, endDate?.Month)
.With(x => x.EndYear, endDate?.Year)
.With(x => x.StartMonth, startDate?.Month)
.With(x => x.StartYear, startDate?.Year)
.Without(x => x.StartDate)
.Without(x => x.Courses)
.Create();
_act = async() => await _mapper.Map(TestHelper.Clone(_source));
}
private async Task CreateClashesForDelete(string externalReference1, string externalReference2)
{
var clashesHierarchy = new[]
{
Fixture.Build <CreateClash>()
.With(x => x.Externalref, externalReference1)
.With(c => c.ParentExternalidentifier, string.Empty)
.With(c => c.Differences, new List <ClashDifference>())
.With(x => x.DefaultOffPeakExposureCount, 100)
.With(x => x.DefaultPeakExposureCount, 200)
.Create(),
Fixture.Build <CreateClash>()
.With(x => x.Externalref, externalReference2)
.With(c => c.Differences, new List <ClashDifference>())
.With(x => x.ParentExternalidentifier, externalReference1)
.With(x => x.DefaultOffPeakExposureCount, 100)
.With(x => x.DefaultPeakExposureCount, 200)
.Create()
};
await Api.Create(clashesHierarchy).ConfigureAwait(false);
await Task.Delay(GivenSteps.delayForSave).ConfigureAwait(false);
}
public static IPostprocessComposer <KongRoute> BuildRouteWithoutPlugins(
Fixture fixture,
Protocols protocols = Protocols.BothHttp,
List hosts = List.ValidItems,
List headers = List.Null,
Set methods = Set.Null,
List paths = List.Null,
Set snis = Set.Null,
Set sources = Set.Null,
Set destinations = Set.Null,
Set tags = Set.Null,
ushort httpsRedirect = 426) => fixture.Build <KongRoute>()
.With(x => x.Id, fixture.Create <string>())
.With(x => x.HttpsRedirectStatusCode, httpsRedirect)
.With(x => x.Plugins, fixture.CreateChildren(Children.Empty, fixture.GetValidKongPlugin, fixture.GetKongPluginWithOneError))
.With(x => x.Protocols, fixture.CreateProtocols(protocols))
.With(x => x.Hosts, fixture.CreateHosts(hosts))
.With(x => x.Headers, fixture.CreateHeaders(headers))
.With(x => x.Methods, fixture.CreateMethods(methods))
.With(x => x.Paths, fixture.CreatePaths(paths))
.With(x => x.Snis, fixture.CreateSnis(snis))
.With(x => x.Sources, fixture.CreateEndpoints(sources))
.With(x => x.Destinations, fixture.CreateEndpoints(destinations))
.With(x => x.Tags, fixture.CreateTags(tags));
public async Task CreateFinanceStatistics()
{
var fixture = new Fixture();
var financeDbContext = new EmployerFinanceDbContext(_configuration.DatabaseConnectionString);
var lazyDb = new Lazy <EmployerFinanceDbContext>(() => financeDbContext);
var levyRepository = new DasLevyRepository(_configuration, Mock.Of <ILog>(), lazyDb);
financeDbContext.Database.BeginTransaction();
try
{
await levyRepository.CreatePayments(new List <PaymentDetails>
{
fixture
.Build <PaymentDetails>()
.With(details => details.CollectionPeriodId, "R05")
// could put sanitised collection period and delivery period values in for mth and year
.With(details => details.PeriodEnd, "R12")
.With(details => details.EmployerAccountVersion, $"ver-{DateTime.Now.Ticks.ToString().Substring(4,10)}")
.With(details => details.ApprenticeshipVersion, $"ver-{DateTime.Now.Ticks.ToString().Substring(4,10)}")
.Without(details => details.FrameworkCode)
.Without(details => details.PathwayCode)
.Without(details => details.PathwayName)
.Create()
});
financeDbContext.Database.CurrentTransaction.Commit();
}
catch (Exception e)
{
financeDbContext.Database.CurrentTransaction.Rollback();
Console.WriteLine(e);
throw;
}
}
public void GetOrder_輸入orderId_應取得該筆訂單資料()
{
//arrange
var sut = this.GetSystemUnderTest();
Fixture fixture = new Fixture();
var source = fixture.Build <Orders>()
.OmitAutoProperties()
.Create();
var expected = new OrderDto
{
CustomerID = source.CustomerID,
EmployeeID = source.EmployeeID,
Freight = source.Freight,
OrderID = source.OrderID,
OrderDate = source.OrderDate,
RequiredDate = source.RequiredDate,
ShipAddress = source.ShipAddress,
ShipCity = source.ShipCity,
ShipCountry = source.ShipCountry,
ShippedDate = source.ShippedDate,
ShipName = source.ShipName,
ShipPostalCode = source.ShipPostalCode,
ShipRegion = source.ShipRegion,
ShipVia = source.ShipVia,
};
OrdeRepository.Find(null)
.ReturnsForAnyArgs(source);
//act
var actual = sut.GetOrder(source.OrderID);
//assert
actual.Should().BeEquivalentTo(expected);
}
public async Task Then_the_learner_is_retrieved()
{
var submissionData = _fixture.Create <SubmissionData>();
submissionData.SetLearningData(new LearningData(true));
submissionData.SetSubmissionDate(_fixture.Create <DateTime>());
submissionData.LearningData.SetHasDataLock(true);
submissionData.SetRawJson(_fixture.Create <string>());
var testLearner =
_fixture.Build <LearnerModel>()
.With(l => l.SubmissionData, submissionData)
.Create();
// Act
await _sut.Add(testLearner);
await _dbContext.SaveChangesAsync();
// Act
var result = await _sut.GetByApprenticeshipIncentiveId(testLearner.ApprenticeshipIncentiveId);
// Assert
result.Id.Should().Be(testLearner.Id);
result.ApprenticeshipIncentiveId.Should().Be(testLearner.ApprenticeshipIncentiveId);
result.ApprenticeshipId.Should().Be(testLearner.ApprenticeshipId);
result.Ukprn.Should().Be(testLearner.Ukprn);
result.UniqueLearnerNumber.Should().Be(testLearner.UniqueLearnerNumber);
result.SubmissionData.Should().NotBeNull();
result.SubmissionData.SubmissionDate.Should().Be(testLearner.SubmissionData.SubmissionDate);
result.SubmissionData.LearningData.IsInlearning.Should().Be(testLearner.SubmissionData.LearningData.IsInlearning);
result.SubmissionData.LearningData.HasDataLock.Should().BeTrue();
result.SubmissionData.LearningData.StartDate.Should().BeNull();
result.SubmissionData.LearningData.IsInlearning.Should().BeNull();
result.SubmissionData.RawJson.Should().Be(testLearner.SubmissionData.RawJson);
}
public void TestBulkInsertWithUnorderedColumns()
{
// Setup
var repository = new DbRepository <SqlConnection>(Constants.TestDatabase);
repository.ExecuteNonQuery(@"
CREATE TABLE [dbo].[TestTable](
[FullName] [NVARCHAR](50) NULL,
[Age] INT NULL,
[BirthDate] DATETIME NULL
) ");
var fixture = new Fixture();
var fixtureData = fixture.Build <TestTable>()
.With(x => x.FullName, "A B C")
.With(x => x.Age, 25)
.With(x => x.BirthDate, new DateTime(1993, 1, 1))
.CreateMany(10);
// Act
var affectedRows = repository.BulkInsert(fixtureData);
// Assert
affectedRows.ShouldBe(10);
}
public async Task GetItemsFromDocumentDb()
{
var fixture = new Fixture();
var carsFixture = fixture.Build <Car>()
.Without(x => x.Id)
.CreateMany(5);
var cars = new List <Car>();
foreach (var car in carsFixture)
{
cars.Add(await _carRepository.CreateItemAsync(car));
}
Expression <Func <Car, bool> > filter = f => f.WrittenOff && f.Make == Car.Makes.Ford;
var actual = await _carRepository.GetItemsAsync(filter);
var expected = cars.Where(filter.Compile());
Assert.NotNull(actual);
Assert.Equal(JsonConvert.SerializeObject(expected.OrderBy(x => x.Id)), JsonConvert.SerializeObject(actual.OrderBy(x => x.Id)));
}
public void ShouldReturnCommandForRoverToPointWestIfFacingNorthAndTurningLeft()
{
var rover = _fixture.Build <Rover.Core.Entities.Rover>()
.With(x => x.RoverFacingDirection, Direction.North)
.Create();
var roverActionCommand = new RoverActionCommand()
{
RoverAction = RoverAction.TurnLeft, ActionExecutionOrder = 1
};
_roverActonToCoordinateTranslationService = new RoverActonToCoordinateTranslationService(new RoverActionToDirection());
var result = _roverActonToCoordinateTranslationService.Translate(rover, roverActionCommand);
Assert.AreEqual(Direction.West, result.FacingDirection);
Assert.AreEqual(rover.GridPosition.X, result.XCoordinate);
Assert.AreEqual(rover.GridPosition.Y, result.YCoordinate);
}
public async Task ShouldAddNewRecordIntoCollection()
{
//Given
const string sensorName = "fuelLevel";
decimal expectedValue = _any.Create <decimal>();
var eventData = CreateEventData(_id);
eventData.Body.Returns(_any.Build <SensorDto>().With(t => t.Name, sensorName)
.With(t => t.Quality, 100)
.With(t => t.Value, expectedValue)
.Create().ToString());
var messageProcessor = _container.Resolve <IMessageProcessor>();
//When
await messageProcessor.ProcessAsync(new[] { eventData });
//Then
var doc = _dbContext.Get <VehicleSnapshot>().FirstOrDefault(t => t.Id == _id);
Assert.NotNull(doc);
Assert.NotNull(doc.Sensors[sensorName]);
Assert.Equal(expectedValue, doc.Sensors[sensorName].Value);
}
public async Task GivenPokemonName_WhenGetPokemonDescription_AndPokemonExistsWithEnglishTranslation_ThenReturnsPokemonDescription(string pokemonName)
{
//Given
var flavourTextEntries = _fixture.Build <FlavorTextEntries>()
.With(x => x.Language, new Language
{
Name = "en"
}).Create();
var pokemon = _fixture.Build <PokemonSpecies>()
.With(x => x.FlavorTextEntries, new[] { flavourTextEntries })
.Create();
_pokeApiRepositoryMock.Setup(x => x.GetPokemonAsync(pokemonName.ToLower())).ReturnsAsync(pokemon);
//When
var description = await _sut.GetPokemonDescriptionAsync(pokemonName);
//Then
Assert.Equal(pokemon.FlavorTextEntries.First(x => x.Language.Name == "en").FlavorText, description);
}
public async Task Then_data_is_fetched_from_database()
{
// Arrange
var account = _fixture.Create <Models.Account>();
var allApplications = _fixture.Build <Models.IncentiveApplication>().With(x => x.AccountLegalEntityId, account.AccountLegalEntityId).CreateMany <Models.IncentiveApplication>(10).ToArray();
const long accountId = -1;
allApplications[0].AccountId = accountId;
allApplications[3].AccountId = accountId;
_context.Accounts.Add(account);
_context.Applications.AddRange(allApplications);
_context.SaveChanges();
// Act
var actual = (await _sut.GetList(x => x.AccountId == accountId)).ToArray();
//Assert
actual.All(x => x.AccountId == accountId).Should().BeTrue();
actual.Should().BeEquivalentTo(new[] { allApplications[0], allApplications[3] }, opts => opts.ExcludingMissingMembers());
}
public void Setup()
{
Fixture fixture = new Fixture();
fixture.Behaviors.OfType <ThrowingRecursionBehavior>().ToList().ForEach(b => fixture.Behaviors.Remove(b));
fixture.Behaviors.Add(new OmitOnRecursionBehavior());
var owners = new List <Owner>
{
fixture.Build <Owner>().With(u => u.OwnerID, 1).With(u => u.Name, "Mateo").Create(),
fixture.Build <Owner>().With(u => u.OwnerID, 2).With(u => u.Name, "Malinowski").Create(),
fixture.Build <Owner>().With(u => u.OwnerID, 3).With(u => u.Name, "Malinowski").Create(),
fixture.Build <Owner>().With(u => u.OwnerID, 4).With(u => u.Name, "Malinowski").Create(),
fixture.Build <Owner>().With(u => u.OwnerID, 5).With(u => u.Name, "Malinowski").Create(),
fixture.Build <Owner>().With(u => u.OwnerID, 6).With(u => u.Name, "Malinowski").Create()
}.AsQueryable();
ownerMock = new Mock <DbSet <Owner> >();
ownerMock.As <IQueryable <Owner> >().Setup(m => m.Provider).Returns(owners.Provider);
ownerMock.As <IQueryable <Owner> >().Setup(m => m.Expression).Returns(owners.Expression);
ownerMock.As <IQueryable <Owner> >().Setup(m => m.ElementType).Returns(owners.ElementType);
ownerMock.As <IQueryable <Owner> >().Setup(m => m.GetEnumerator()).Returns(owners.GetEnumerator());
}
public void GetWeatherByRegionTests_When_IsBadRequest_Returns_Detail_And_BadRequestStatusCode()
{
var region = "sul";
var response = _fixture.Build <RegionResponse>()
.With(x => x.Detail, "Region must be one by Norte,Nordeste,Centro-Oeste,Sul,Sudeste - stul given")
.With(x => x.StatusCode, HttpStatusCode.BadRequest)
.With(x => x.Data, (IList <Region>)null)
.Create();
var jsonFile = JsonConvert.SerializeObject(response);
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest);
httpResponseMessage.Content = new StringContent(jsonFile);
httpResponseMessage.Content.Headers.ContentType.MediaType = "application/json";
_client.GetAsync($"{_host}/forecast/region/{region}?{_token}").Returns(httpResponseMessage);
var result = _service.GetWeatherByRegion(region);
result.Should().BeEquivalentTo(response);
}
