public void Company_EqualsCompanyDifferentRegistrationNumber_ReturnsFalse()
{
var company = CompanyBuilder.NewCompany;
var company2 = CompanyBuilder.WithRegistrationNumber("test registration number");
Assert.NotEqual(company, company2);
}
public void Company_EqualsCompanyDifferentName_ReturnsFalse()
{
var company = CompanyBuilder.NewCompany;
var company2 = CompanyBuilder.WithName("test name");
Assert.NotEqual(company, company2);
}
public async Task Can_register_as_Customer_and_send_email()
{
// arrange
var company = CompanyBuilder.Create().WithName("test company").Build(ArrangeRepositoryContext);
var dto = new Register.Command("*****@*****.**", "test pass", "", "", company.Id);
var controller = new AuthorizationController(Mediator);
// act
var result = await controller.RegisterAsync(dto);
// assert
result.Should().NotBeNullOrWhiteSpace();
var subject = AssertRepositoryContext.Users.FirstOrDefault();
subject.Should().NotBeNull();
subject.Roles.Should().Be(UserRole.Customer);
subject.Email.Should().Be(dto.Email);
subject.Password.Text.Should().NotBeNullOrWhiteSpace();
subject.Password.Salt.Should().NotBeNullOrWhiteSpace();
subject.IsActive.Should().BeFalse();
subject.IsRemoved.Should().BeFalse();
subject.PermissionsToken.Token.Should().NotBeNullOrEmpty();
subject.PermissionsToken.Expiration.Should().BeAfter(DateTime.Now);
subject.PermissionsToken.Expiration.Should().BeBefore(DateTime.Now.AddDays(2));
MailerMock.Verify(mock => mock.SendAsync(It.Is <string>(x => x == dto.Email), It.IsAny <string>(), It.Is <string>(x => x.Contains(subject.PermissionsToken.Token)), false), Times.Once);
MailerMock.VerifyNoOtherCalls();
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
var userBuilder = new UserBuilder(modelBuilder.Entity <User>());
var companyBuilder = new CompanyBuilder(modelBuilder.Entity <Company>());
var activityBuilder = new ActivityBuilder(modelBuilder.Entity <Activity>());
}
public void Company_EqualsCompanyDifferentProducerContact_ReturnsFalse()
{
var company = CompanyBuilder.WithProducerContact(new AlwaysUnequalProducerContact());
var company2 = CompanyBuilder.WithProducerContact(new AlwaysUnequalProducerContact());
Assert.NotEqual(company, company2);
}
public static Company WithProducerContact(ProducerContact contact)
{
var builder = new CompanyBuilder();
builder.contact = contact;
return(builder.Build());
}
public static Company WithName(string name)
{
var builder = new CompanyBuilder();
builder.name = name;
return(builder.Build());
}
public static Company WithRegistrationNumber(string registrationNumber)
{
var builder = new CompanyBuilder();
builder.registrationNumber = registrationNumber;
return(builder.Build());
}
/// <summary>
/// Creates and adds a few ItemViewModel objects into the Items collection.
/// </summary>
public void LoadData()
{
var company = CompanyBuilder.CreateInMemoryModel();
this.Company = company;
this.Name = company.Name;
this.IsDataLoaded = true;
}
public async void ReturnCreatedCompany()
{
// When
var newCompany = new CompanyBuilder().Build();
var company = await client.CreateCompanyAsync(newCompany);
// Then
Assert.NotNull(company);
Assert.Equal(newCompany.Id.Value, company.Id);
}
public void TestRoundtripCompanyRepository()
{
OnSetUp();
var company = new CompanyBuilder().CreateCompany();
_companyRepository.AddCompanies(new List <Company> {
company
});
Assert.AreEqual(_companyRepository.GetCompany(company.Gcp).Name, company.Name);
}
public void TestAddCompanies()
{
OnSetUp();
var companyBuilder = new CompanyBuilder().SetGcp(Gcp);
var addCompaniesRequest = companyBuilder.CreateAddCompaniesRequest();
var response = _companyController.Post(addCompaniesRequest);
var databaseCompany = _companyRepository.GetCompany(Gcp);
var correctCompany = companyBuilder.CreateCompany();
Assert.IsTrue(response.Success);
Assert.IsTrue(CompaniesAreEqual(new Company(databaseCompany), correctCompany));
}
public void XmlOperationsTest()
{
var c = CompanyBuilder.CreateCompany(Xml);
var total = Features.Total(Xml);
Assert.AreEqual(c.Total, total);
var newCompany = Features.Cut(Xml);
var newTotal = Features.Total(newCompany);
Assert.AreEqual(total, newTotal * 2);
}
public async void ReturnCompanyGivenExisitngId()
{
// Given
var newCompany = new CompanyBuilder().Build();
await client.CreateCompanyAsync(newCompany);
// When
var company = await client.GetCompanyByIdAsync(newCompany.Id.Value);
// Then
Assert.NotNull(company);
Assert.Equal(newCompany.Id.Value, company.Id);
}
public async void ReturnAnyCompany()
{
// Given
var newCompany = new CompanyBuilder().Build();
await client.CreateCompanyAsync(newCompany);
// When
var page = await client.GetCompaniesAsync();
// Then
Assert.NotNull(page);
Assert.NotNull(page.Items);
Assert.NotNull(page.Items.Any());
}
public async void DeleteExistingCompany()
{
// Given
var newCompany = new CompanyBuilder().Build();
var companyToDelete = await client.CreateCompanyAsync(newCompany);
// When
await client.DeleteCompanyAsync(companyToDelete.Id.Value);
// Then
var company = await client.GetCompanyByIdAsync(newCompany.Id.Value);
Assert.Null(company);
}
public void TestGetCompanyByGcp()
{
OnSetUp();
var companyBuilder = new CompanyBuilder().SetGcp(Gcp);
_companyRepository.AddCompanies(new List <Company> {
companyBuilder.CreateCompany()
});
var result = _companyController.Get(Gcp);
var correctCompany = companyBuilder.CreateCompany();
Assert.IsTrue(CompaniesAreEqual(correctCompany, result.Company));
Assert.IsTrue(result.Success);
}
public async void ReturnUpdatedCompany()
{
// Given
var newCompany = new CompanyBuilder().Build();
var companyToUpdate = await client.CreateCompanyAsync(newCompany);
// When
companyToUpdate.Description += " [updated]";
var company = await client.UpdateCompanyAsync(companyToUpdate.Id.Value, companyToUpdate);
// Then
Assert.NotNull(company);
Assert.Equal(companyToUpdate.Id, company.Id);
Assert.Equal(companyToUpdate.Description, company.Description);
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Conventions.Remove <PluralizingTableNameConvention>();
modelBuilder.Conventions.Add <OneToManyCascadeDeleteConvention>();
var userBuilder = new UserBuilder(modelBuilder.Entity <UserEntity>());
var roleBuilder = new RoleBuilder(modelBuilder.Entity <RoleEntity>());
var companyBuilder = new CompanyBuilder(modelBuilder.Entity <CompanyEntity>());
var experimentBuilder = new ExperimentBuilder(modelBuilder.Entity <ExperimentEntity>());
var permissionBuilder = new PermissionBuilder(modelBuilder.Entity <PermissionEntity>());
var projectBuilder = new ProjectBuilder(modelBuilder.Entity <ProjectEntity>());
var auditTrailBuilder = new AuditTrailBuilder(modelBuilder.Entity <AuditTrailEntity>());
var auditTrailChangeLogBuilder = new AuditTrailChangeLogBuilder(modelBuilder.Entity <AuditTrailChangeLogEntity>());
var LicenseTypeBuilder = new LicenseTypeBuilder(modelBuilder.Entity <LicenseTypeEntity>());
var LicenseBuilder = new LicenseBuilder(modelBuilder.Entity <LicenseEntity>());
}
public async Task Orders_can_be_created()
{
// arrange
var user = UserBuilder.Create().WithRole(UserRole.Customer).WithEmail("*****@*****.**").WithRole(UserRole.Customer).Active().Build(ArrangeRepositoryContext);
var company = CompanyBuilder.Create().WithName("test company").WithUsers(user).Build(ArrangeRepositoryContext);
var product = ProductBuilder.Create().WithName("test Prod").Active().Build(ArrangeRepositoryContext);
var amount = 2;
var request = new CreateOrder.Command
{
DeliveryDate = DateTime.Now.AddDays(1),
UserId = user.Id,
OrderProducts = new List <OrderItemDto> {
new OrderItemDto()
{
ProductId = product.Id,
Amount = amount
}
}
};
var controller = new OrdersController(Mediator);
controller.SetUserId(user.Id);
// act
var result = await controller.CreateAsync(request);
// assert
result.Should().NotBeNullOrWhiteSpace();
var subject = AssertRepositoryContext.Orders
.Include(x => x.OrderProducts)
.ThenInclude(x => x.Product)
.FirstOrDefault();
subject.Should().NotBeNull();
subject.DeliveryDate.Should().Be(request.DeliveryDate);
subject.UserId.Should().Be(request.UserId);
subject.DestinationCompanyId.Should().Be(company.Id);
subject.OrderProducts.Count.Should().Be(1);
subject.OrderProducts.First().ProductId.Should().Be(product.Id);
subject.OrderProducts.First().Amount.Should().Be(amount);
}
private static AbstractCompanyEntity GetCompanyFromDecoratedBuilder()
{
var builder = new CompanyBuilder("Apple");
var appleCompany = new LoggingCompanyBuilder(builder)
.BuildEmployee("Tim Cook", 10200000, "CEO", "appl")
.BuildGroup("Vice Presidents", "ppl")
.BuildEmployee("Craig Federighi", 1000000, "Vice President of Engineering", "Vice")
.BuildEmployee("Jonathan Ive", 1000000, "Vice President of Design", " Presidents")
.BuildEmployee("Phillip Schiller", 1000000, "Vice President of Marketing", "Vice Pres")
.BuildGroup("iPad", "Vice Presidents")
.BuildGroup("iWatch", "Vice Presidents")
.BuildGroup("iPhone", "Vice Presidents")
.BuildEmployee("Phillip", 150000, "iPad Designer", "ipad")
.BuildEmployee("Todd Jones", 200000, "iWatch Designer", "IWATCH")
.GetResult();
return(appleCompany);
}
public Company ToSDKCompany()
{
if (sdkCompany != null)
{
return(sdkCompany);
}
else if (apiCompany != null)
{
CompanyBuilder builder = CompanyBuilder.NewCompany(apiCompany.Name)
.WithId(apiCompany.Id)
.WithAddress(new AddressConverter(apiCompany.Address).ToSDKAddress())
.WithData(apiCompany.Data);
return(builder.Build());
}
else
{
return(null);
}
}
private static AbstractCompanyEntity GetCompanyFromBuilder()
{
// Construct company. Company builder allows you to search for the parent of the new
// entity and will place it automatically.
var appleCompany = new CompanyBuilder("Apple")
.BuildEmployee("Tim Cook", 10200000, "CEO", "appl")
.BuildGroup("Vice Presidents", "ppl")
.BuildEmployee("Craig Federighi", 1000000, "Vice President of Engineering", "Vice")
.BuildEmployee("Jonathan Ive", 1000000, "Vice President of Design", " Presidents")
.BuildEmployee("Phillip Schiller", 1000000, "Vice President of Marketing", "Vice Pres")
.BuildGroup("iPad", "Vice Presidents")
.BuildGroup("iWatch", "Vice Presidents")
.BuildGroup("iPhone", "Vice Presidents")
.BuildEmployee("Phillip", 150000, "iPad Designer", "ipad")
.BuildEmployee("Todd Jones", 200000, "iWatch Designer", "IWATCH")
.GetResult();
return(appleCompany);
}
public async Task Can_not_create_order_in_unavailability_duration()
{
// arrange
var user = UserBuilder.Create().WithRole(UserRole.Customer).WithEmail("*****@*****.**").WithRole(UserRole.Customer).Active().Build(ArrangeRepositoryContext);
var company = CompanyBuilder.Create().WithName("test company").WithUsers(user).Removed().Build(ArrangeRepositoryContext);
var product = ProductBuilder.Create().WithName("test Prod").Active().Build(ArrangeRepositoryContext);
var unavailability = UnavailabilityBuilder.Create().From(DateTime.Now).To(DateTime.Now.AddDays(3)).WithReason(UnavailabilityReason.Sick).Build(ArrangeRepositoryContext);
var request = new CreateOrder.Command
{
DeliveryDate = DateTime.Now.AddDays(1),
UserId = user.Id,
OrderProducts = new List <OrderItemDto> {
new OrderItemDto()
{
ProductId = product.Id,
Amount = 1
}
}
};
var controller = new OrdersController(Mediator);
controller.SetUserId(user.Id);
// act
Func <Task> act = () => controller.CreateAsync(request);
var exception = await Assert.ThrowsAsync <BadRequestException>(act);
//assert
exception.Message.Should().Be("Can not create order in unavailability duration");
// assert
var subject = AssertRepositoryContext.Orders.ToList();
subject.Count.Should().Be(0);
}
public void CreateCompanyFromXml()
{
var c = CompanyBuilder.CreateCompany(Xml);
Assert.AreEqual(123456 + 12345 + 1234 + 234567 + 23456 + 2345 + 2344, c.Total);
}
public CompanyService(IUnitOfWork unitOfWork, CompanyBuilder companyBuilder, CompanyAdapter companyAdapter)
{
this.unitOfWork = unitOfWork;
this.companyBuilder = companyBuilder;
this.companyAdapter = companyAdapter;
}
public void withSpecifiedValues()
{
AccountBuilder accountBuilder = AccountBuilder.NewAccount()
.WithName(ACC_NAME)
.WithId(ACC_ID)
.WithOwner(ACC_OWNER)
.WithLogoUrl(ACC_LOGOURL)
.WithData(ACC_DATA)
.WithCompany(CompanyBuilder.NewCompany(ACC_CO_NAME)
.WithAddress(AddressBuilder.NewAddress()
.WithAddress1(ACC_CO_ADDR_ADDR1)
.WithAddress2(ACC_CO_ADDR_ADDR2)
.WithCity(ACC_CO_ADDR_CITY)
.WithCountry(ACC_CO_ADDR_COUNTRY)
.WithState(ACC_CO_ADDR_STATE)
.WithZipCode(ACC_CO_ADDR_ZIP).Build())
.WithId(ACC_CO_ID)
.WithData(ACC_CO_DATA)
.Build())
.WithCustomField(CustomFieldBuilder.CustomFieldWithId(ACC_FIELD_ID)
.WithDefaultValue(ACC_FIELD_DEF_VLE)
.IsRequired(ACC_FIELD_IS_REQUIRED)
.WithTranslation(TranslationBuilder.NewTranslation(ACC_FIELD_TRANSL_LANG).Build())
.Build())
.WithLicense(LicenseBuilder.NewLicense()
.CreatedOn(ACC_LIC_CREATED)
.WithPaidUntil(ACC_LIC_PAIDUNTIL)
.WithStatus(ACC_LIC_STATUS)
.WithTransaction(ACC_LIC_TRANS_CREATED,
CreditCardBuilder.NewCreditCard()
.WithCvv(ACC_LIC_TRANS_CC_CVV)
.WithName(ACC_LIC_TRANS_CC_NAME)
.WithNumber(ACC_LIC_TRANS_CC_NUM)
.WithType(ACC_LIC_TRANS_CC_TYPE)
.WithExpiration(ACC_LIC_TRANS_CC_EXP_MONTH, ACC_LIC_TRANS_CC_EXP_YEAR)
.Build(),
PriceBuilder.NewPrice()
.WithAmount(ACC_LIC_TRANS_PRICE_AMOUNT)
.WithCurrency(ACC_LIC_TRANS_PRICE_CURR_ID, ACC_LIC_TRANS_PRICE_CURR_NAME,
ACC_LIC_TRANS_PRICE_CURR_DATA)
.Build())
.WithPlan(PlanBuilder.NewPlan(ACC_LIC_PLAN_ID)
.WithId(ACC_LIC_PLAN_NAME)
.WithContract(ACC_LIC_PLAN_CONTRACT)
.WithDescription(ACC_LIC_PLAN_DES)
.WithGroup(ACC_LIC_PLAN_GRP)
.WithCycle(ACC_LIC_PLAN_CYC)
.WithOriginal(ACC_LIC_PLAN_ORI)
.WithData(ACC_LIC_PLAN_DATA)
.WithFreeCycles(ACC_LIC_PLAN_CYC_COUNT, ACC_LIC_PLAN_CYC_CYCLE)
.WithQuota(ACC_LIC_PLAN_QUOTA_CYCLE, ACC_LIC_PLAN_QUOTA_LIMIT, ACC_LIC_PLAN_QUOTA_SCOPE,
ACC_LIC_PLAN_QUOTA_TARGET)
.WithFeatures(ACC_LIC_PLAN_FEAT)
.WithPrice(PriceBuilder.NewPrice()
.WithAmount(ACC_LIC_PLAN_PRICE_AMOUNT)
.WithCurrency(ACC_LIC_PLAN_PRICE_CURR_ID, ACC_LIC_PLAN_PRICE_CURR_NAME,
ACC_LIC_PLAN_PRICE_CURR_DATA)
.Build())
.Build())
.Build())
.WithAccountProviders(new List <Provider>()
{
ProviderBuilder.NewProvider(ACC_PROV_DOC_NAME)
.WithData(ACC_PROV_DOC_DATA)
.WithId(ACC_PROV_DOC_ID)
.WithProvides(ACC_PROV_DOC_NAME)
.Build()
}, new List <Provider>()
{
ProviderBuilder.NewProvider(ACC_PROV_USR_NAME)
.WithData(ACC_PROV_USR_DATA)
.WithId(ACC_PROV_USR_ID)
.WithProvides(ACC_PROV_USR_PROVIDES)
.Build()
});
Account account = accountBuilder.Build();
Assert.AreEqual(ACC_NAME, account.Name);
Assert.AreEqual(ACC_CO_ID, account.Company.Id);
Assert.AreEqual(ACC_CO_ADDR_ADDR1, account.Company.Address.Address1);
Assert.AreEqual(1, account.CustomFields.Count);
Assert.AreEqual(ACC_FIELD_DEF_VLE, account.CustomFields[0].Value);
Assert.AreEqual(1, account.CustomFields[0].Translations.Count);
Assert.AreEqual(ACC_FIELD_TRANSL_LANG, account.CustomFields[0].Translations[0].Language);
Assert.AreEqual(1, account.Licenses.Count);
Assert.AreEqual(ACC_LIC_STATUS, account.Licenses[0].Status);
Assert.AreEqual(1, account.Licenses[0].Transactions.Count);
Assert.AreEqual(ACC_LIC_TRANS_CC_NUM, account.Licenses[0].Transactions[0].CreditCard.Number);
Assert.AreEqual(ACC_LIC_TRANS_PRICE_AMOUNT, account.Licenses[0].Transactions[0].Price.Amount);
Assert.AreEqual(ACC_LIC_PLAN_CONTRACT, account.Licenses[0].Plan.Contract);
Assert.AreEqual(ACC_LIC_PLAN_PRICE_AMOUNT, account.Licenses[0].Plan.Price.Amount);
Assert.AreEqual(1, account.Providers.Documents.Count);
Assert.AreEqual(ACC_PROV_DOC_NAME, account.Providers.Documents[0].Name);
Assert.AreEqual(1, account.Providers.Users.Count);
Assert.AreEqual(ACC_PROV_USR_NAME, account.Providers.Users[0].Name);
}
