public void GetCompanies()
{
var controller = new CompaniesController(new SampleDataRepository());
IQueryable <Company> companies = controller.GetCompanies();
Assert.IsTrue(companies.Count() > 0);
}
public void Edit_ReturnsNotFoundActionResult_NotExisitingId()
{
// Arrange
var mockEmployeeRepository = new Mock <IEmployeeRepository>();
var mockProductRepository = new Mock <IProductRepository>();
var mockLocationRepository = new Mock <ILocationRepository>();
var mockCompanyEmployeeRepository = new Mock <ICompanyEmployeeRepository>();
var mockCompanyLocationRepository = new Mock <ICompanyLocationRepository>();
var mockCompanyProductRepository = new Mock <ICompanyProductRepository>();
var mockCompanyRepository = new Mock <ICompanyRepository>();
mockCompanyRepository.Setup(repo => repo.GetAll())
.Returns(GetCompanies());
var controller = new CompaniesController(
mockCompanyRepository.Object,
mockEmployeeRepository.Object,
mockLocationRepository.Object,
mockCompanyEmployeeRepository.Object,
mockCompanyLocationRepository.Object,
mockCompanyProductRepository.Object);
// Act
var result = (NotFoundResult)controller.Edit(666);
// Assert
Assert.Equal(404, result.StatusCode);
}
public CompaniesEntity[] GetCompanies(int?id = 0, String name = "")
{
ValidSecurityToken(authHeader);
CompaniesController controller = new CompaniesController();
CompaniesEntity[] companies;
if (CacheHelper.Exists("GetCompanies") == false)
{
CacheHelper.Add("GetCompanies", controller.GetCompanies(), DateTime.Now.AddDays(1));
}
CacheHelper.Get("GetCompanies", out companies);
if (!string.IsNullOrEmpty(name) && id <= 0)
{
return(companies.Where(x => x.Name.ToLower().Contains(name.ToLower())).ToArray());
}
else if (string.IsNullOrEmpty(name) && id > 0)
{
return(companies.Where(x => x.Id == id).ToArray());
}
else if (!string.IsNullOrEmpty(name) && id > 0)
{
return(companies.Where(x => x.Id == id && x.Name.ToLower().Contains(name.ToLower())).ToArray());
}
return(companies);
}
protected void RptCompany_ItemCommand(object source, RepeaterCommandEventArgs e)
{
string[] variable = e.CommandArgument.ToString().Split('|');
if (e.CommandName == "SelectCompany")
{
if (CompanyId != Convert.ToInt32(variable[0]))
{
CompanyId = Convert.ToInt32(variable[0]);
CompanyName = variable[1];
var address = new CompaniesController().GetCompanyAddress(CompanyId).Select(x => new ItemEntity()
{
Text = x.ToString(), Value = x.Id.ToString()
}).ToArray();
if (address.Length >= 1)
{
CompanyAddress = address[0].Text;
AddressId = Convert.ToInt32(address[0].Value);
RptCompanyAddress.DataSource = address;
RptCompanyAddress.DataBind();
}
}
}
else if (e.CommandName == "SelectAddress")
{
AddressId = Convert.ToInt32(variable[0]);
CompanyAddress = variable[1];
}
}
public void CreateCompany_ValidInputCreatesCompanyAndReturnsAnOkResult_WithAnCompany()
{
// Arrange
var newCompany = SeedTestData.GetTestCompany();
mockRepo.Setup(repo => repo.Company.CreateCompany(It.IsAny <Company>()))
.Verifiable();
var controller = new CompaniesController(mockRepo.Object, _mapper);
CompanyForCreationDto newCompanyDto = new CompanyForCreationDto()
{
Name = newCompany.Name,
Address = newCompany.Address,
Country = newCompany.Country
};
// Act
var result = controller.CreateCompany(newCompanyDto);
// Assert
Assert.IsInstanceOf <OkObjectResult>(result);
var okResult = result as OkObjectResult;
Assert.That(okResult.Value, Is.TypeOf <Company>());
Company resultComp = okResult.Value as Company;
Assert.AreEqual(resultComp.Name, newCompany.Name);
Assert.AreEqual(resultComp.Address, newCompany.Address);
Assert.AreEqual(resultComp.Country, newCompany.Country);
mockRepo.Verify();
}
public void Index_ReturnsAViewResult_WithAListOfCompanies()
{
// Arrange
var mockEmployeeRepository = new Mock <IEmployeeRepository>();
var mockProductRepository = new Mock <IProductRepository>();
var mockLocationRepository = new Mock <ILocationRepository>();
var mockCompanyEmployeeRepository = new Mock <ICompanyEmployeeRepository>();
var mockCompanyLocationRepository = new Mock <ICompanyLocationRepository>();
var mockCompanyProductRepository = new Mock <ICompanyProductRepository>();
var mockCompanyRepository = new Mock <ICompanyRepository>();
mockCompanyRepository.Setup(repo => repo.GetAll())
.Returns(GetCompanies());
var controller = new CompaniesController(
mockCompanyRepository.Object,
mockEmployeeRepository.Object,
mockLocationRepository.Object,
mockCompanyEmployeeRepository.Object,
mockCompanyLocationRepository.Object,
mockCompanyProductRepository.Object);
// Act
var result = controller.Index();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <Company> >(
viewResult.ViewData.Model);
Assert.Equal(3, model.Count());
}
protected void Page_Load(object sender, EventArgs e)
{
if (UsuarioLogado != null)
{
ltUserName.Text = UsuarioLogado.Name;
if (!IsPostBack)
{
var controller = new CompaniesController();
var itens = controller.GetCompaniesUser(UsuarioLogado.Id);
if (itens.Length >= 1)
{
CompanyId = Convert.ToInt32(itens[0].Value);
CompanyName = itens[0].Text;
var address = controller.GetCompanyAddress(CompanyId).Select(x => new ItemEntity()
{
Text = x.ToString(), Value = x.Id.ToString()
}).ToArray();
if (address.Length >= 1)
{
CompanyAddress = address[0].Text;
AddressId = Convert.ToInt32(address[0].Value);
RptCompanyAddress.DataSource = address;
RptCompanyAddress.DataBind();
}
ImgCompanyPic.ImageUrl = "/ImageHandler.ashx?ID=" + CompanyId + "&type=COMPANY&token=" + SecurityToken;
}
RptCompany.DataSource = itens;
RptCompany.DataBind();
}
}
}
public List <CompanyResponse> GetAllCompanies(List <ContactDTO> contactList)
{
_getMessage?.Invoke("Loading companies started");
CompaniesController companiesController = new CompaniesController(_apiKey, _baseURL);
List <CompanyResponse> companyList = new List <CompanyResponse>();
CompanyResponse companyResponse;
int tmp = 0;
foreach (var contact in contactList)
{
companyResponse = companiesController.GetCompany(contact.Company_Id);
if (companyResponse != null)
{
companyList.Add(companyResponse);
tmp = companyList.Count % 10;
if (tmp == 0)
{
_getMessage?.Invoke($"Loaded {companyList.Count} companies");
}
}
}
return(companyList);
}
public ComaniesHttpClientV1Test()
{
_persistence = new CompaniesMemoryPersistence();
_controller = new CompaniesController();
_client = new CompaniesHttpClientV1();
_service = new CompaniesHttpServiceV1();
IReferences references = References.FromTuples(
new Descriptor("CompaniesService", "persistence", "memory", "default", "1.0"), _persistence,
new Descriptor("CompaniesService", "controller", "default", "default", "1.0"), _controller,
new Descriptor("CompaniesService", "client", "http", "default", "1.0"), _client,
new Descriptor("CompaniesService", "service", "http", "default", "1.0"), _service
);
_controller.SetReferences(references);
_service.Configure(HttpConfig);
_service.SetReferences(references);
_client.Configure(HttpConfig);
_client.SetReferences(references);
_fixture = new CompaniesClientV1Fixture(_client);
_service.OpenAsync(null).Wait();
_client.OpenAsync(null).Wait();
}
public BitdefenderClient(string apikey, string accessurl = null)
{
if (apikey == null)
{
throw new ArgumentNullException(nameof(apikey));
}
var baseAddress = CreateAccessUrl(accessurl);
var auth = CreateBasicAuthHeaderValue(apikey);
_http = new HttpClient();
try
{
_http.BaseAddress = baseAddress;
_http.DefaultRequestHeaders.Authorization = auth;
_http.DefaultRequestHeaders.Accept.Clear();
_http.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
Network = new NetworkController(_http);
Companies = new CompaniesController(_http);
}
catch
{
_http.Dispose();
throw;
}
}
public CompaniesControllerTest()
{
_dummyData = new DummyProject3_BackendContext();
_companyRepository = new Mock <ICompanyRepository>();
_userRepository = new Mock <IUserRepository>();
_companiesController = new CompaniesController(_companyRepository.Object, _userRepository.Object);
}
public void BeforeEach()
{
_assetCompaniesRepository = new Mock <IAssetManagerCompaniesRepository>();
_logger = new Mock <ILogger>();
_assetCompaniesManager = new AssetManagerCompaniesManager(_assetCompaniesRepository.Object, _logger.Object);
_CompaniesController = new CompaniesController(_assetCompaniesManager, _logger.Object);
}
public async Task AddCompany_WithProperCompany_ShouldAddCorrectly()
{
var companyModel = new CompanyCreationBindingModel()
{
Name = companyName,
Bulstat = bulstat,
Address = address,
TownName = town
};
var controller = new CompaniesController(companiesService, townsService);
// Act
await controller.Add(companyModel);
var company = this.dbContext.Companies.First();
// Assert
Assert.AreEqual(1, this.dbContext.Companies.Count());
Assert.AreEqual(companyName, company.Name);
Assert.AreEqual(bulstat, company.Bulstat);
Assert.AreEqual(address, company.Address);
Assert.AreEqual(town, company.Town.Name);
}
public void GetCompany_ReturnCompanyByISIN()
{
// Arrange
var context = new TestDBContext();
context.Companies.Add(new Company()
{
ID = 1, CompanyName = "Apple Inc.", Exchange = "NASDAQ", Ticker = "APPL", ISIN = "US0378331005", WebsiteURL = "http://www.apple.com", CreationDate = DateTime.Now, UpdateTime = DateTime.Now
});
context.Companies.Add(new Company()
{
ID = 2, CompanyName = "British Airways Plc", Exchange = "Pink Sheets", Ticker = "BAIRY", ISIN = "US1104193065", WebsiteURL = null, CreationDate = DateTime.Now, UpdateTime = DateTime.Now
});
context.Companies.Add(new Company()
{
ID = 3, CompanyName = "Heineken NV", Exchange = "Euronext Amsterdam", Ticker = "HEIA", ISIN = "NL0000009165", WebsiteURL = null, CreationDate = DateTime.Now, UpdateTime = DateTime.Now
});
// Act
var controller = new CompaniesController(context);
var result = controller.GetCompany(isin: "US0378331005") as OkNegotiatedContentResult <Company>;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.Content.CompanyName);
Assert.AreEqual("Apple Inc.", result.Content.CompanyName);
}
public async Task Company_can_be_created()
{
// arrange
var request = new CreateCompany.Command()
{
Name = "Sample product",
Comment = "test comment",
PostalCode = "Postal Code",
City = "City test",
Street = "test Street",
Latitude = 12,
Longitude = 25
};
// act
var controller = new CompaniesController(Mediator);
var result = await controller.CreateAsync(request);
// assert
result.Should().NotBeNullOrWhiteSpace();
var subject = AssertRepositoryContext.Companies.FirstOrDefault();
subject.Should().NotBeNull();
subject.Name.Should().Be(request.Name);
subject.Comment.Should().Be(request.Comment);
subject.PostalCode.Should().Be(request.PostalCode);
subject.City.Should().Be(request.City);
subject.Street.Should().Be(request.Street);
subject.Latitude.Should().Be(request.Latitude);
subject.Longitude.Should().Be(request.Longitude);
}
public void All_WithValidCompaniesAndGreaterThanTotalPagesPageShouldRedirectToAllAndLastPage()
{
const string SearchTerm = "Some company";
//Arrange
this.companyService.Setup(c => c.All(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <int>()))
.Returns(this.GetAllCompanies());
this.companyService.Setup(c => c.TotalCompanies(It.IsAny <string>()))
.Returns(this.GetAllCompanies().Count);
var controller = new CompaniesController(companyService.Object, null, null);
//Act
var result = controller.All(SearchTerm, 100);
//Assert
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be(nameof(CompaniesController.All));
result.As <RedirectToActionResult>()
.RouteValues[RouteValueKeySearchTerm]
.Should().Be(SearchTerm);
result.As <RedirectToActionResult>()
.RouteValues[RouteValueKeyPage]
.Should().Be(LastPage);
}
public void Details_WithExistingCompanyAndLastReviewsPageShouldReturnView()
{
//Arrange
CompanyDetailsServiceModel company = this.GetCompanyDetailsServiceModel();
reviewService.Setup(r => r.TotalReviews(It.IsAny <string>()))
.Returns(ReviewsCount);
companyService.Setup(c => c.CompanyDetails(It.IsAny <string>()))
.Returns(company);
var controller = new CompaniesController(companyService.Object, townService.Object, reviewService.Object);
//Act
var result = controller.Details(CompanyId, LastPage);
//Assert
result.Should().BeOfType <ViewResult>();
var model = result.As <ViewResult>().Model;
model.Should().BeOfType <CompanyDetails>();
model.As <CompanyDetails>().SearchForm.CompanyId.Should().Be(CompanyId);
model.As <CompanyDetails>().ReviewForm.CompanyId.Should().Be(CompanyId);
model.As <CompanyDetails>().Reviews.Pagination.CurrentPage.Should().Be(LastPage);
model.As <CompanyDetails>().Reviews.Pagination.NextPage.Should().Be(LastPage);
model.As <CompanyDetails>().Reviews.Pagination.TotalPages.Should().Be(LastPage);
model.As <CompanyDetails>().Reviews.Pagination.TotalElements.Should().Be(ReviewsCount);
this.AssertCompayDetailsViewModel(this.GetCompanyDetailsServiceModel(), model.As <CompanyDetails>());
}
public void TestDetailsView()
{
var companiesController = new CompaniesController();
var result = companiesController.Details(1) as ViewResult;
Assert.AreEqual("Details", result.ViewName);
}
public void PutProduct_ShouldFail_WhenDifferentID()
{
var controller = new CompaniesController(new TestStoreAppContext());
var badresult = controller.PutProduct("999", GetDemoProduct());
Assert.IsInstanceOfType(badresult, typeof(BadRequestResult));
}
public CompaniesControllerTest()
{
_unitOfWorkMock = new Mock <IUnitOfWork>();
_mapperMock = new Mock <IMapper>();
_userManager = new Mock <FakeUserManager>();
controller = new CompaniesController(_unitOfWorkMock.Object, _mapperMock.Object, _userManager.Object);
}
public async Task ShouldSendQueryRequestOnSearchCompanies()
{
var mediaStub = Substitute.For <IMediator>();
var controller = new CompaniesController(mediaStub);
await controller.SearchCompanies(new SearchCompaniesFilter());
await mediaStub.Received(1).Send(Arg.Any <SearchCompaniesQuery>());
}
public void QuickSearch(string name)
{
CompaniesController controller = new CompaniesController();
ViewResult result = controller.QuickSearch("JYP") as ViewResult;
List <Company> model = result.Model as List <Company>;
Assert.AreEqual(1, model.Count);
}
public async Task ShouldSendCompanyCreateCommandOnCreateCompany()
{
var mediaStub = Substitute.For <IMediator>();
var controller = new CompaniesController(mediaStub);
await controller.CreateCompany(new Domain.Entities.Company());
await mediaStub.Received(1).Send(Arg.Any <CreateCompanyCommand>());
}
public async Task ShouldSendFindCompanyRequestOnFindCompanyByIsin()
{
var mediaStub = Substitute.For <IMediator>();
var controller = new CompaniesController(mediaStub);
await controller.FindCompanyByIsin("");
await mediaStub.Received(1).Send(Arg.Any <FindCompanyByIsinQuery>());
}
public void Delete()
{
var repository = new SampleDataRepository();
var controller = new CompaniesController(repository);
int id = 1;
controller.DeleteCompany(id);
Assert.IsNull(repository.Get(id));
}
public async Task ShouldSetRouteIdOnBodyOnCompanyUpdate()
{
var mediaStub = Substitute.For <IMediator>();
var controller = new CompaniesController(mediaStub);
await controller.UpdateCompany(1, new Domain.Entities.Company());
await mediaStub.Received(1).Send(Arg.Is <UpdateCompanyCommand>(c => c.Company.Id == 1));
}
public void GetCompany()
{
var controller = new CompaniesController(new SampleDataRepository());
int id = 1;
Company company = controller.GetCompany(id);
Assert.IsNotNull(company);
Assert.AreEqual(id, company.Id);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActivitiesControllerTest" /> class.
/// </summary>
public CompaniesControllerTest()
{
this.entitiesForTest = new EntitiesForTest();
this.repositoryMock = new Mock <IRepository <Company> >();
this.mapperMock = new Mock <IMapper>();
this.target = new CompaniesController(
this.repositoryMock.Object,
this.mapperMock.Object);
}
public void SetUp()
{
var companyServiceMock = new Mock <ICompanyService>();
companyServiceMock.Setup(x => x.GetCompany(TestCompanies.Gsk.Nip)).Returns(Task.FromResult(TestCompanies.Gsk));
companyServiceMock.Setup(x => x.GetCompany(TestCompanies.Google.Nip)).Returns(Task.FromResult(TestCompanies.Google));
_companiesController = new CompaniesController(companyServiceMock.Object);
}
private void PopularPets()
{
if (CompanyId > 0)
{
CompaniesController controller = new CompaniesController();
ListPetsEntities = controller.GetCompanyPets(CompanyId);
rptPetEntities.DataSource = ListPetsEntities;
rptPetEntities.DataBind();
}
}
