public async Task ShouldCheckOutPersons()
{
var addressRepository = Substitute.For <IRepository <Address, Guid> >();
var addressDataProvider = Substitute.For <IAddressDataProvider>();
var addressFactory = new AddressFactory();
var addressEntity = addressFactory.Create(new AddressFactoryInput()
{
City = "test", Street = "test", HomeNumber = "test", StreetNumber = "test", Id = Guid.NewGuid()
});
addressEntity.CheckInPersons(6);
addressRepository.Get(addressEntity.Id).Returns(addressEntity);
AddressController addressController = new AddressController(addressRepository, addressDataProvider, addressFactory, Substitute.For <IMeterReadDataProvider>());
await
addressController.CheckOutPerson(new CheckOut()
{
AddressId = addressEntity.Id,
Persons = 5
});
await addressRepository.Received(1).Get(addressEntity.Id);
Assert.Equal(1, addressEntity.CheckedInPersons);
}
public void CreateTest()
{
var factory = new AddressFactory();
var result = factory.Create(11, "street", "zipcode", "city");
Assert.AreEqual(11, result.StreetNumber);
Assert.AreEqual("street", result.Street);
Assert.AreEqual("zipcode", result.ZipCode);
Assert.AreEqual("city", result.City);
}
protected override void validateDbRecords(AddressData e, AddressData a)
{
var eObj = AddressFactory.Create(e);
var aObj = AddressFactory.Create(a);
var eView = AddressViewFactory.Create(eObj);
var aView = AddressViewFactory.Create(aObj);
Assert.AreEqual(eView.Contact, aView.Contact);
base.validateDbRecords(e, a);
}
//[Fact]
//public async Task ShouldProvideReadCreateUsageAggregate()
//{
// var address = CreateAddress();
// address.AddMeter("123", 0.00);
// _addressRepository.Add(address);
// _documentSession.SaveChanges();
// var usageDomainService = new UsageDomainService(_usageRepository, _addressRepository);
// await usageDomainService.CreateUsageFromMeterRead(Guid.NewGuid(), address.Id, 5.00, "123", DateTime.Now);
// _documentSession.SaveChanges();
// var usageDataProvider = new UsageDataProvider(_martenDatabaseFixture.DocumentStore.OpenSession());
// var usage = await usageDataProvider.GetLastUsage(address.Id);
// Assert.NotNull(usage);
// Assert.Equal(5.00, usage.Value);
//}
private Address CreateAddress()
{
return
(_addressFactory.Create(new AddressFactoryInput()
{
Street = "test street",
City = "test city",
StreetNumber = "2b",
HomeNumber = "2",
Id = Guid.NewGuid()
}));
}
public static Address Get(short streetNumber, string streetName, City city)
{
Address address;
if (Address.IsInDb(streetNumber, streetName, city))
{
address = AddressLoader.Load(streetNumber, streetName, city);
}
else
{
address = AddressFactory.Create(streetNumber, streetName, city);
address.RecordInDb();
}
return(address);
}
[TestMethod] public void CreateTest()
{
void test <T>(AddressData r)
{
var o = AddressFactory.Create(r);
Assert.IsInstanceOfType(o, typeof(T));
}
test <WebPageAddress>(GetRandom.Object <WebPageAddressData>());
test <EmailAddress>(GetRandom.Object <EmailAddressData>());
test <TelecomAddress>(GetRandom.Object <TelecomAddressData>());
test <GeographicAddress>(GetRandom.Object <GeographicAddressData>());
test <GeographicAddress>(GetRandom.Object <AddressData>());
test <GeographicAddress>(null);
}
public void ReturnInstanceOfAddress()
{
var name = "Name";
var cityId = 1;
var latitude = 1.0;
var longitude = 1.0;
var sut = new AddressFactory();
var addressTest = sut.Create(name, cityId, latitude, longitude);
Assert.IsInstanceOfType(addressTest, typeof(Address));
Assert.AreEqual(name, addressTest.Name);
Assert.AreEqual(cityId, addressTest.CityId);
Assert.AreEqual(latitude, addressTest.Latitude);
Assert.AreEqual(longitude, addressTest.Longitude);
}
public async Task ShouldDeleteAddressIfExists()
{
var addressRepository = Substitute.For <IRepository <Address, Guid> >();
var addressDataProvider = Substitute.For <IAddressDataProvider>();
var addressFactory = new AddressFactory();
var addressEntity = addressFactory.Create(new AddressFactoryInput()
{
City = "test", Street = "test", HomeNumber = "test", StreetNumber = "test", Id = Guid.NewGuid()
});
addressRepository.Get(addressEntity.Id).Returns(addressEntity);
AddressController addressController = new AddressController(addressRepository, addressDataProvider, addressFactory, Substitute.For <IMeterReadDataProvider>());
await addressController.Delete(addressEntity.Id);
addressRepository.Received(1).Delete(addressEntity.Id);
}
Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var addressId = Guid.NewGuid().ToString();
var address = new GeographicAddressData {
Address = model.AddressLine, CityOrAreaCode = model.City,
CountryID = getCountryCodesDictionary()[model.Country], ID = addressId,
ZipOrPostCodeOrExtension = model.ZipCode,
RegionOrStateOrCountryCode = model.County
};
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email,
FirstName = model.FirstName, LastName = model.LastName, Address = address, AddressID = addressId, DateOfBirth = model.DateOfBirth
};
await addresses.AddObject(AddressFactory.Create(address));
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
logger.LogInformation("User created a new account with password.");
var code = await userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
await emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
await signInManager.SignInAsync(user, isPersistent : false);
logger.LogInformation("User created a new account with password.");
return(redirectToLocal(returnUrl));
}
addErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
private async Task <Guid> InsertAddress()
{
var repository = CreateGenericMartenRepository();
var address =
_addressFactory.Create(new AddressFactoryInput()
{
Street = "test street",
City = "test city",
StreetNumber = "2b",
HomeNumber = "2",
Id = Guid.NewGuid()
});
var id = address.Id;
repository.Add(address);
await _session.SaveChangesAsync();
return(id);
}
public IContest Create(CreateContestCmd cmd)
{
return(WithTransaction(() =>
{
var address = AddressFactory.Create(cmd.StreetNumber, cmd.Street, cmd.ZipCode, cmd.City);
UnitOfWorks.Save(address);
var areaType = cmd.Indoor ? AreaType.Indoor : AreaType.Outdoor;
var physicalSettings = PhysicalSetting.Create(address, areaType, cmd.CountField);
UnitOfWorks.Save(physicalSettings);
var gameSetting = GameSettingFactory.Create(cmd.CountMinPlayerByTeam, cmd.CountMaxPlayerByTeam);
UnitOfWorks.Save(gameSetting);
var newContest = Domain.Games.Contest.Create(cmd.Date, physicalSettings, gameSetting);
UnitOfWorks.Save(newContest.EliminationSetting.MatchSetting);
UnitOfWorks.Save(newContest.EliminationSetting);
UnitOfWorks.Save(newContest);
return newContest;
}));
}
protected override IAddress createObject(AddressData r) => AddressFactory.Create(r);
public async Task <IAddress> GetObject(string id)
{
var r = await getObject(id);
return(AddressFactory.Create(r));
}
