public void GetByIdReturnsCompany()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository = new EfRepository <Company>(new ApplicationDbContext(options.Options));
repository.AddAsync(new Company {
Name = "Авангард ЕООД", Bulstat = "041835487509", VatNumber = $"BG{041835487509}", PhoneNumber = "+359 889 121 212", Address = "гр.Пловдив, ул.Марашев 5"
});
repository.AddAsync(new Company {
Name = "ЕТ Саламандър", Bulstat = "63835487509", VatNumber = $"BG{041835487509}", PhoneNumber = "+359 889 211 212", Address = "гр.Пловдив, ул.Марашев 6"
});
repository.AddAsync(new Company {
Name = "Тиесто Гранд", Bulstat = "041115487509", VatNumber = $"BG{041835487509}", PhoneNumber = "+359 889 121 211", Address = "гр.Пловдив, ул.Марашев 7"
});
repository.SaveChangesAsync();
var routesService = new CompaniesService(repository);
var routeFromDb = repository.AllAsNoTracking().FirstOrDefault(c => c.Name == "Тиесто Гранд");
var route = routesService.GetById(routeFromDb.Id);
Assert.Equal(routeFromDb.Id, route.Id);
Assert.Equal(routeFromDb.Name, route.Name);
Assert.Equal(routeFromDb.Bulstat, route.Bulstat);
Assert.Equal(routeFromDb.Address, route.Address);
}
public async Task GetDetailsAsyncReturnsCompanyDetails()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository = new EfRepository <Company>(new ApplicationDbContext(options.Options));
await repository.AddAsync(new Company { Name = "Авангард ЕООД" });
await repository.AddAsync(new Company { Name = "ЕТ Саламандър" });
await repository.AddAsync(new Company { Name = "Тиесто Гранд" });
await repository.SaveChangesAsync();
var companiesService = new CompaniesService(repository);
var companyFromDb = repository.AllAsNoTracking().FirstOrDefault(c => c.Name == "Тиесто Гранд");
AutoMapperConfig.RegisterMappings(typeof(DetailsCompanyViewModel).Assembly);
var company = await companiesService.GetDetailsAsync <DetailsCompanyViewModel>(companyFromDb.Id);
Assert.Equal(company.Name, companyFromDb.Name);
Assert.Equal(company.Bulstat, companyFromDb.Bulstat);
Assert.Equal(company.PhoneNumber, companyFromDb.PhoneNumber);
Assert.Equal(company.Address, companyFromDb.Address);
}
public void GetUsersCountRetunsUsersCountByCompanyName()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var usersRepository = new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options));
var repository = new EfRepository <Company>(new ApplicationDbContext(options.Options));
repository.AddAsync(new Company {
Name = "Авангард ЕООД"
});
repository.AddAsync(new Company {
Name = "ЕТ Саламандър"
});
repository.SaveChangesAsync();
var companies = repository.AllAsNoTracking().ToList();
for (int i = 0; i < companies.Count(); i++)
{
usersRepository.AddAsync(new ApplicationUser {
UserName = $"mars{i}", Email = "*****@*****.**", CompanyId = companies[i].Id, FullName = "Емилия Петрова", LastLoggingDate = DateTime.UtcNow
});
usersRepository.SaveChangesAsync();
}
var companiesService = new CompaniesService(repository);
var companyCount = companiesService.GetUsersCount("Авангард ЕООД");
Assert.Equal(1, companyCount);
}
public async Task GetCompanyManagerByCompanyIdAsync_WithIncorectMenager_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
var company = new Company()
{
Id = "asdasd",
Name = "Test Ltd",
};
var user = new SteuUser()
{
Id = "managerId",
Manager = false,
};
company.Employees.Add(user);
await context.AddAsync(company);
await context.SaveChangesAsync();
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Company>(context);
var service = new CompaniesService(repository);
await Assert.ThrowsAsync <ArgumentNullException>(() => service.GetCompanyManagerByCompanyIdAsync("asdasd"));
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (_loaded)
{
return;
}
_loaded = true;
_creating = NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/machine_families/create",
StringComparison.InvariantCulture);
if (Id <= 0 &&
!_creating)
{
return;
}
_companies = await CompaniesService.GetAsync();
_model = _creating ? new MachineFamilyViewModel() : await Service.GetAsync(Id);
_authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
_editing = _creating || NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/machine_families/edit/",
StringComparison.InvariantCulture);
StateHasChanged();
}
public async Task GetAsync_SouldReturn_Null_IfCompanyDoNotExists()
{
var db = this.GetDatabase();
var mapper = this.GetMapper();
var firstCompany = new Company {
Id = 1, Name = "Свеплина", Bulstat = "903097356", AccountablePerson = "H", Address = "k"
};
var secondCompany = new Company {
Id = 2, Name = "Просперитет", Bulstat = "BG909087356", AccountablePerson = "Y", Address = "ko"
};
var thirdCompany = new Company {
Id = 3, Name = "Тотал Щета", Bulstat = "903099066", AccountablePerson = "opk", Address = "top"
};
await db.Companies.AddRangeAsync(firstCompany, secondCompany, thirdCompany);
await db.SaveChangesAsync();
var companyService = new CompaniesService(db, mapper);
var result = await companyService.GetAsync(4);
result
.Should()
.BeNull();
}
public async Task AddAsyncCompanyShouldReturnCorrectDataFromDbContext(
string name,
string description,
string logoImg,
string officialSite,
string userId,
int categoryId)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Company>(dbContext);
var service = new CompaniesService(repository);
int companyId = await service.AddAsync(name, description, logoImg, officialSite, userId, categoryId);
var result = service.GetById(companyId);
Assert.Equal(1, result.Id);
Assert.Equal(name, result.Name);
Assert.Equal(description, result.Description);
Assert.Equal(logoImg, result.LogoImage);
Assert.Equal(officialSite, result.OfficialSite);
Assert.Equal(userId, result.UserId);
Assert.Equal(categoryId, result.CategoryId);
}
public async Task GetAsync_SouldReturn_CorrectModel_IfCompanyExists()
{
var db = this.GetDatabase();
var mapper = this.GetMapper();
var firstCompany = new Company {
Id = 1, Name = "Свеплина", Bulstat = "903097356", AccountablePerson = "H", Address = "k"
};
var secondCompany = new Company {
Id = 2, Name = "Просперитет", Bulstat = "BG909087356", AccountablePerson = "Y", Address = "ko"
};
var thirdCompany = new Company {
Id = 3, Name = "Тотал Щета", Bulstat = "903099066", AccountablePerson = "opk", Address = "top"
};
await db.Companies.AddRangeAsync(firstCompany, secondCompany, thirdCompany);
await db.SaveChangesAsync();
var companyService = new CompaniesService(db, mapper);
var result = await companyService.GetAsync(2);
result
.Should()
.BeOfType <CompanyDetailsModel>()
.And
.Match <CompanyDetailsModel>(c => c.AccountablePerson == "Y" &&
c.Address == "ko" &&
c.Bulstat == "BG909087356" &&
c.Name == "Просперитет");
}
public async Task AllAsync_SouldReturn_CollectionWithThreeCompanies_IfThreeAreInDb()
{
var db = this.GetDatabase();
var mapper = this.GetMapper();
var firstCompany = new Company {
Id = 1, Name = "Свеплина", Bulstat = "903097356"
};
var secondCompany = new Company {
Id = 2, Name = "Просперитет", Bulstat = "BG909087356"
};
var thirdCompany = new Company {
Id = 3, Name = "Тотал Щета", Bulstat = "903099066"
};
await db.Companies.AddRangeAsync(firstCompany, secondCompany, thirdCompany);
await db.SaveChangesAsync();
var companyService = new CompaniesService(db, mapper);
var result = await companyService.AllAsync();
result
.Should()
.NotBeEmpty()
.And
.HaveCount(3)
.And
.Match(c =>
c.ElementAt(0).Name == "Свеплина" &&
c.ElementAt(1).Bulstat == "BG909087356" &&
c.ElementAt(2).Name == "Тотал Щета");
}
public void SetUp()
{
_companiesRepo = new Mock<ICompaniesRepository>();
_companiesService = new CompaniesService(_companiesRepo.Object);
}
public async Task <int> EditByIdAsyncShouldReturnTrueWithCorrectInputUsingDbContext()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "CompanyTest123").Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Companies.Add(new Company
{
Id = 1,
Name = "C1",
Description = "desc",
LogoImage = "image",
OfficialSite = "officialSite",
CategoryId = 1
});
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Company>(dbContext);
var tagRepository = new EfDeletableEntityRepository <Tag>(dbContext);
var service = new CompaniesService(repository, tagRepository);
var result = await service.EditById(1, "C11", "desc", "image", "officialSite", 1);
Assert.Equal(1, result);
return(result);
}
public async Task CreateCompanyAsyncTest_WhitCorrectData_ShouldReturnTrue()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Company>(context);
var service = new CompaniesService(repository);
var model = new CreateCompanyBindingModel()
{
Name = "Test Ltd",
UIC = "123123123",
UserId = "asdasd asd asd asd ",
LicenseUrl = "dadadasdadasd",
};
var user = new SteuUser()
{
Id = "asdadas",
};
var actualResult = await service.CreateCompanyAsync(model, user);
Assert.True(actualResult);
}
public async Task CreateAsync_ShouldReturn_True_IfInputDataIsCorrect()
{
var db = this.GetDatabase();
var mapper = this.GetMapper();
var companyServiec = new CompaniesService(db, mapper);
const string name = "Петров 96";
const string address = "София Младост 6";
const string bulstat = "BG063698652";
const string accountablePerson = "Ivan Metodiev";
//Act
var result = await companyServiec.CreateAsync(name, address, bulstat, accountablePerson);
var savedEntry = await db.Companies.FirstOrDefaultAsync(x => x.Name == "Петров 96");
//Assert
result
.Should()
.BeTrue();
savedEntry
.Should()
.NotBeNull()
.And
.BeOfType <Company>()
.And
.Match <Company>(x => x.Bulstat == "BG063698652" &&
x.Name == "Петров 96");
}
public void GetCompanies_ShouldProperlyReturnAllCompanies()
{
//Arrange
var mockedRepository = new Mock <IEfRepository <Company> >();
var mockedImageService = new Mock <IImageService>();
var companies = new List <Company>()
{
new Company {
CompanyName = "Name", Description = "Description"
},
new Company {
CompanyName = "Name", Description = "Description"
},
new Company {
CompanyName = "Name", Description = "Description"
}
}.AsQueryable();
mockedRepository.Setup(x => x.GetAllQueryable).Returns(companies);
var service = new CompaniesService(mockedRepository.Object, mockedImageService.Object);
//Act
var result = service.GetCompanies();
//Assert
Assert.AreEqual(3, result.Count());
}
public async Task GetCompanyManagerByCompanyIdAsync_WithCorrectData_ShouldReturnCompany()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
var company = new Company()
{
Id = "asdasd",
Name = "Test Ltd",
};
var user = new SteuUser()
{
Id = "managerId",
Manager = true,
};
company.Employees.Add(user);
await context.AddAsync(company);
await context.SaveChangesAsync();
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Company>(context);
var service = new CompaniesService(repository);
var actualResult = await service.GetCompanyManagerByCompanyIdAsync("asdasd");
Assert.Equal("managerId", actualResult);
}
public async Task EditAsyncUpdatesExistingRoute()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository = new EfRepository <Company>(new ApplicationDbContext(options.Options));
var company = new Company {
Name = "Авангард ЕООД"
};
await repository.AddAsync(company);
await repository.SaveChangesAsync();
var companiesService = new CompaniesService(repository);
company.Bulstat = "2638236483";
company.VatNumber = $"BG{company.Bulstat}";
company.PhoneNumber = "+ 359 999 000 000";
await companiesService.EditAsync(company);
var updatedCompany = repository.AllAsNoTracking().FirstOrDefault(c => c.Name == "Авангард ЕООД");
Assert.Equal(company.Bulstat, updatedCompany.Bulstat);
Assert.Equal(company.VatNumber, updatedCompany.VatNumber);
Assert.Equal(company.PhoneNumber, updatedCompany.PhoneNumber);
}
public void InitializeTests()
{
this.dbContext = MockDbContext.GetDbContext();
var mapper = MockAutoMapper.GetMapper();
this.townsService = new TownsService(dbContext, mapper);
this.companiesService = new CompaniesService(dbContext, mapper, townsService);
}
public CompaniesServiceTests()
{
long Id = singleEntity.Id;
Mock = DefaultContextMock.GetMock();
MockSet = SetUpMock.SetUpFor(testEntities);
Mock.Setup(c => c.Set <Company>()).Returns(MockSet.Object);
Mock.Setup(c => c.Company).Returns(MockSet.Object);
testedService = new CompaniesService(Mock.Object);
}
public void Constructor_ShouldReturnAnInstanceOfCompaniesService()
{
//Arrange
var mockedImageService = new Mock <IImageService>();
var mockedRepository = new Mock <IEfRepository <Company> >();
//Act
var service = new CompaniesService(mockedRepository.Object, mockedImageService.Object);
//Assert
Assert.IsInstanceOf <CompaniesService>(service);
}
public async Task AllAsync_SouldReturn_Null_IfNoCompaniesInDb()
{
var db = this.GetDatabase();
var mapper = this.GetMapper();
;
var companyService = new CompaniesService(db, mapper);
var result = await companyService.AllAsync();
result
.Should()
.BeEmpty();
}
public async Task GetAllShouldReturnCorrectNumberUsingDbContext()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Companies.Add(new Company());
dbContext.Companies.Add(new Company());
dbContext.Companies.Add(new Company());
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Company>(dbContext);
var service = new CompaniesService(repository);
Assert.Equal(3, await service.GetCountAsync());
}
public async Task CreateAsyncCreatesCompany()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository = new EfRepository <Company>(new ApplicationDbContext(options.Options));
var companiesService = new CompaniesService(repository);
await companiesService.CreateAsync("Авангард ЕООД");
await companiesService.CreateAsync("ЕТ Саламандър");
var companyCount = repository.AllAsNoTracking().ToList().Count();
Assert.Equal(2, companyCount);
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (_loaded)
{
return;
}
_loaded = true;
_creating = NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/software_versions/create",
StringComparison.InvariantCulture);
if (Id <= 0 &&
!_creating)
{
return;
}
_softwareVersions = await Service.GetAsync();
_softwareFamilies = await SoftwareFamiliesService.GetAsync();
_licenses = await LicensesService.GetAsync();
_companies = await CompaniesService.GetAsync();
_roles = await DocumentRolesService.GetEnabledAsync();
_model = _creating ? new SoftwareVersionViewModel() : await Service.GetAsync(Id);
_authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
_addingCompanyRoleId = _roles.First().Id;
_softwareVersionCompanies = await CompaniesBySoftwareVersionService.GetBySoftwareVersion(Id);
_editing = _creating || NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/software_versions/edit/",
StringComparison.InvariantCulture);
if (_editing)
{
SetCheckboxes();
}
StateHasChanged();
}
public async Task WhenCreateCompanyThatDoesNotExistDatabase()
{
var companies = new List <Company>();
var mockCompanyRepo = new Mock <IDeletableEntityRepository <Company> >();
mockCompanyRepo.Setup(x => x.All()).Returns(companies.AsQueryable());
mockCompanyRepo.Setup(x => x.AddAsync(It.IsAny <Company>())).Callback(
(Company company) => companies.Add(company));
var mockHotelRepo = new Mock <IDeletableEntityRepository <Hotel> >();
var service = new CompaniesService(mockCompanyRepo.Object, mockHotelRepo.Object);
await service.CreateAsync("NeykovEOOD", "131071587", "0888989844", "*****@*****.**", 1, "Първи май №2", 1);
Assert.Single(companies);
}
public async Task DeleteUserCompanyByCompanyIdAsyncTest_WithInCorrectData_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
await context.Companies.AddAsync(new Company()
{
Id = "asdasd",
Name = "Test Ltd",
});
await context.SaveChangesAsync();
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Company>(context);
var service = new CompaniesService(repository);
await Assert.ThrowsAsync <ArgumentNullException>(() => service.DeleteUserCompanyByCompanyIdAsync("Test"));
}
public void TestGetCompanyById()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
AutoMapperConfig.RegisterMappings(typeof(MyTestCompany).Assembly);
var repository = new EfDeletableEntityRepository <Company>(new ApplicationDbContext(options.Options));
repository.AddAsync(new Company {
Name = "test"
}).GetAwaiter().GetResult();
repository.SaveChangesAsync();
var companyService = new CompaniesService(repository);
var company = companyService.GetById <MyTestCompany>(1);
Assert.Equal("test", company.Name);
}
public async Task CreateCompanyAsyncTest_WhitNullUser_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Company>(context);
var service = new CompaniesService(repository);
var model = new CreateCompanyBindingModel()
{
Name = "Test Ltd",
UIC = "123123123",
UserId = "asdasd asd asd asd ",
LicenseUrl = "dadadasdadasd",
};
await Assert.ThrowsAsync <ArgumentNullException>(() => service.CreateCompanyAsync(model, null));
}
public void GetCompanyWithFakeId()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository =
new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options));
repository.AddAsync(new ApplicationUser()
{
Description = "test",
Type = UserType.Employer,
});
repository.SaveChangesAsync().GetAwaiter().GetResult();
var company = new CompaniesService(repository);
AutoMapperConfig.RegisterMappings(typeof(CompaniesServiceTests.MyTest).Assembly);
Assert.Null(company.GetCompanyAsync <MyTest>("dasdasads"));
}
/// <summary>
/// Initializes a new instance of AgileCrm.
/// </summary>
/// <returns>
/// <see cref="IAgileCrm" />.
/// </returns>
private static IAgileCrm Initialize()
{
var httpClient = new HttpClientWrapper(
localAgileCrmConfiguration);
var companiesService = new CompaniesService(
httpClient,
localLogger);
var contactsService = new ContactsService(
httpClient,
localLogger);
var dealsService = new DealsService(
httpClient,
localLogger);
var contactNotesService = new ContactNotesService(
httpClient,
localLogger);
var dealNotesService = new DealNotesService(
httpClient,
localLogger);
var notesService = new NotesService(
contactNotesService,
dealNotesService);
var tasksService = new TasksService(
httpClient,
localLogger);
var agileCrm = new AgileCrm(
companiesService,
contactsService,
dealsService,
notesService,
tasksService);
return(agileCrm);
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (_loaded)
{
return;
}
_loaded = true;
_creating = NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/processors/create", StringComparison.InvariantCulture);
if (Id <= 0 &&
!_creating)
{
return;
}
_companies = await CompaniesService.GetAsync();
_instructionSets = await InstructionSetsService.GetAsync();
_model = _creating ? new ProcessorViewModel() : await Service.GetAsync(Id);
_instructionSetExtensions = await InstructionSetExtensionsService.GetAsync();
_processorExtensions = await InstructionSetExtensionsByProcessorService.GetByProcessor(Id);
_authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
_editing = _creating || NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/processors/edit/",
StringComparison.InvariantCulture);
if (_editing)
{
SetCheckboxes();
}
StateHasChanged();
}
public async Task TestGetByIdCompany()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var companyRepository = new EfDeletableEntityRepository <Company>(new ApplicationDbContext(options.Options));
var hotelRepository = new EfDeletableEntityRepository <Hotel>(new ApplicationDbContext(options.Options));
await companyRepository.AddAsync(new Company { Id = 1, Bulstat = "131071587" });
await companyRepository.AddAsync(new Company { Id = 2, Bulstat = "131071589" });
await companyRepository.SaveChangesAsync();
var companyService = new CompaniesService(companyRepository, hotelRepository);
AutoMapperConfig.RegisterMappings(typeof(MyTestCompany).Assembly);
var company = await companyService.GetByIdAsync <MyTestCompany>(1);
Assert.Equal("131071587", company.Bulstat);
}
