public TenantControllerTest()
{
this.mockLogger = new Mock <ILogger <TenantController> >();
this.mockTenantContainer = new Mock <ITenantContainer>();
this.mockHttpContext = new Mock <HttpContext> {
DefaultValue = DefaultValue.Mock
};
this.mockHttpRequest = new Mock <HttpRequest> {
DefaultValue = DefaultValue.Mock
};
this.mockHttpRequest.Setup(m => m.HttpContext).Returns(this.mockHttpContext.Object);
this.mockHttpContext.Setup(m => m.Request).Returns(this.mockHttpRequest.Object);
this.claims = new List <Claim>();
this.claims.Add(new Claim("sub", "Admin"));
this.controller = new TenantController(this.mockTenantContainer.Object, this.mockLogger.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = this.mockHttpContext.Object,
},
};
this.contextItems = new Dictionary <object, object>
{
{
RequestExtension.ContextKeyTenantId, TenantId
},
{
RequestExtension.ContextKeyUserClaims, this.claims
},
};
this.mockHttpContext.Setup(m => m.Items).Returns(this.contextItems);
}
public async void Patch_No_Errors()
{
TenantControllerMockFacade mock = new TenantControllerMockFacade();
var mockResult = new Mock <UpdateResponse <ApiTenantResponseModel> >();
mockResult.SetupGet(x => x.Success).Returns(true);
mock.ServiceMock.Setup(x => x.Update(It.IsAny <string>(), It.IsAny <ApiTenantRequestModel>()))
.Callback <string, ApiTenantRequestModel>(
(id, model) => model.JSON.Should().Be("A")
)
.Returns(Task.FromResult <UpdateResponse <ApiTenantResponseModel> >(mockResult.Object));
mock.ServiceMock.Setup(x => x.Get(It.IsAny <string>())).Returns(Task.FromResult <ApiTenantResponseModel>(new ApiTenantResponseModel()));
TenantController controller = new TenantController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, new ApiTenantModelMapper());
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var patch = new JsonPatchDocument <ApiTenantRequestModel>();
patch.Replace(x => x.JSON, "A");
IActionResult response = await controller.Patch(default(string), patch);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
mock.ServiceMock.Verify(x => x.Update(It.IsAny <string>(), It.IsAny <ApiTenantRequestModel>()));
}
public async Task FindAll()
{
var daprClient = CreateMockDaprClientWithTenant();
var tenantService = new Mock <ITenantService>();
var tenantPropertiesService = new Mock <ITenantPropertiesService>();
tenantService.Setup(x => x.FindAllAsync()).Returns(
Task.FromResult(new List <Tenant>()
{
new Tenant("Id1", "name", null),
new Tenant("Id2", "name", null)
})
);
var tenantController = new TenantController(
tenantService.Object,
tenantPropertiesService.Object,
daprClient.Object
);
var result = await tenantController.FindAll();
var objectResult = Assert.IsType <OkObjectResult>(result.Result);
var tenantList = Assert.IsType <List <Tenant> >(objectResult.Value);
Assert.NotNull(tenantList);
Assert.Equal(2, tenantList !.Count);
daprClient.Verify(x => x.PublishEventAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()), Times.Never);
}
private void btnViewHouse_Click(object sender, EventArgs e)
{
if (!this._IsHouseIdValid(tbTenantViewHouseId))
{
this._CheckTenantViewHouseIdValidation();
return;
}
string houseId = tbTenantViewHouseId.Text.Trim();
House house = TenantController.GetHouse(houseId);
if (house != null)
{
ArrayList houses = new ArrayList();
houses.Add(house);
dgvTenantViewHouse.DataSource = houses;
tbTenantViewHouseId.Text = "";
}
else
{
// Displays the MessageBox.
MessageBox.Show(
"House not found",
"Error | House not found",
MessageBoxButtons.OK,
MessageBoxIcon.Information
);
this._LoadTenantViewHouseInformation();
}
}
public async void BulkInsert_No_Errors()
{
TenantControllerMockFacade mock = new TenantControllerMockFacade();
var mockResponse = new CreateResponse <ApiTenantResponseModel>(new FluentValidation.Results.ValidationResult());
mockResponse.SetRecord(new ApiTenantResponseModel());
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiTenantRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiTenantResponseModel> >(mockResponse));
TenantController controller = new TenantController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var records = new List <ApiTenantRequestModel>();
records.Add(new ApiTenantRequestModel());
IActionResult response = await controller.BulkInsert(records);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
var result = (response as OkObjectResult).Value as List <ApiTenantResponseModel>;
result.Should().NotBeEmpty();
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiTenantRequestModel>()));
}
public async Task CreateTenant_With_Properties()
{
var daprClient = CreateMockDaprClientWithTenant();
var tenantService = new Mock <ITenantService>();
var tenantPropertiesService = new Mock <ITenantPropertiesService>();
var tenantCreator = new TenantCreator("Id1", "name", new());
tenantService.Setup(x => x.CreateAsync(It.IsAny <TenantCreator>())).Returns(
Task.FromResult(new Tenant("Id1", "name", new()))
);
var tenantController = new TenantController(
tenantService.Object,
tenantPropertiesService.Object,
daprClient.Object
);
var result = await tenantController.CreateTenant(tenantCreator);
var createdAtActionResult = Assert.IsType <CreatedAtActionResult>(result.Result);
Assert.Equal(nameof(tenantController.FindOne), createdAtActionResult.ActionName);
var tenant = Assert.IsType <Tenant>(createdAtActionResult.Value);
Assert.NotNull(tenant);
Assert.Equal("Id1", tenant.Id);
Assert.Equal("name", tenant.Name);
Assert.NotNull(tenant.Properties);
daprClient.Verify(x => x.PublishEventAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TopicData <Tenant> >(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task UpdateProperty()
{
var daprClient = CreateMockDaprClientWithTenant();
var tenantService = new Mock <ITenantService>();
var tenantPropertiesService = new Mock <ITenantPropertiesService>();
var tenant = new Tenant("Id1", "name", null);
tenantPropertiesService.Setup(x => x.UpdatePropertyAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <List <string> >())).Returns(
Task.FromResult((Tenant?)new Tenant("Id1", "name", null))
);
var tenantController = new TenantController(
tenantService.Object,
tenantPropertiesService.Object,
daprClient.Object
);
var result = await tenantController.UpdateProperty("Id1", "data", new());
var acceptedAtActionResult = Assert.IsType <AcceptedAtActionResult>(result.Result);
Assert.Equal(nameof(tenantController.FindOne), acceptedAtActionResult.ActionName);
var tenantResult = Assert.IsType <Tenant>(acceptedAtActionResult.Value);
Assert.NotNull(tenant);
Assert.Equal("Id1", tenant.Id);
daprClient.Verify(x => x.PublishEventAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TopicData <Tenant> >(), It.IsAny <CancellationToken>()), Times.Once);
}
public void FetchTenant_RegularValues_OkResults()
{
//Arrange
var tenant = new Mock <ITenant>();
tenant.SetupGet(a => a.Id).Returns(2);
facade.Setup(f => f.FetchTenant("3445")).Returns(tenant.Object);
var controller = new TenantController(facade.Object)
{
ControllerContext = controllerContext
};
//Act
var result = controller.FetchTenant("3445");
//Assert
Assert.NotNull(result);
var okresult = Assert.IsType <OkNegotiatedContentResult <ITenant> >(result);
Assert.NotNull(okresult.Content);
Assert.Equal(2, okresult.Content.Id);
}
public async Task GetAllBatchesByTCShouldGetAllByTCAsync()
{
//Arrange (create a moq repo and use it for the controller)
var mockRepo = ApiTestData.MockBatchRepo(ApiTestData.Batches.ToList());
var options = TestDbInitializer.InitializeDbOptions("GetAllBatchesByTCShouldGetAllByTCAsync");
using var db = TestDbInitializer.CreateTestDb(options);
var mapper = new Mapper();
var mockLogger = new Mock <ILogger <TenantController> >();
var mockAddressService = new Mock <IAddressService>();
var controller = new TenantController(mockRepo.Object, mockAddressService.Object, mockLogger.Object);
//Act (get all batches)
var result = await controller.GetAllBatches("fa4d6c6e-9650-44c9-8c6b-5aebd3f9a67d");
//Assert
var ok = Assert.IsAssignableFrom <OkObjectResult>(result.Result);
var batches = Assert.IsAssignableFrom <System.Collections.Generic.List <Lib.Models.Batch> >(ok.Value);
Assert.NotNull(batches);
}
public void Post_Should_Return_Created_Response_And_Call_Add()
{
// Given
var newId = Guid.NewGuid();
var tenantService = Substitute.For <IService <Tenant> >();
var tenantCreator = Substitute.For <ITenantCreator>();
var logger = Substitute.For <ILogger <TenantController> >();
var accountService = Substitute.For <IAccountService>();
var inspectionService = Substitute.For <IInspectionService>();
var employeeService = Substitute.For <IEmployeeService>();
var branchOfficeService = Substitute.For <IService <BranchOffice> >();
var departmentService = Substitute.For <IService <Department> >();
var tenantController = new TenantController(
tenantService,
tenantCreator,
accountService,
inspectionService,
employeeService,
branchOfficeService,
departmentService,
logger);
var createTenantDto = new TenantCreateDto {
TenantDetails = new TenantDto
{
Name = "Demo tenant 1",
PrimaryContact = new ContactInfoDto
{
FullName = "John Doe"
},
ServiceDetails = new ServiceDetailsDto
{
ServiceExpireDate = DateTime.Now.Date + TimeSpan.FromDays(366)
}
},
AdminUserDetails = new TenantCreateAdminDto
{
FirstName = "Ivanov",
LastName = "Konstantin",
Patronymic = "Mikhaylovich",
UserName = "******",
Email = "*****@*****.**",
NewPassword = "******"
}
};
// When
var response = tenantController.Post(createTenantDto);
// Then
tenantCreator.Received().CreateNewTenant(
Arg.Is <Tenant>(v => v.Name == createTenantDto.TenantDetails.Name),
Arg.Is <UserDto>(v => v.FirstName == createTenantDto.AdminUserDetails.FirstName),
Arg.Is <string>(v => v == createTenantDto.AdminUserDetails.NewPassword)
);
var createdResponse = (CreatedResult)response.Result;
Assert.That(createdResponse.Location, Is.EqualTo(nameof(TenantController.GetTenant)));
}
public async Task PostShouldPost()
{
// Arrange (create a moq repo and use it for the controller)
var mockLogger = new Mock <ILogger <TenantController> >();
var mockAddressService = new Mock <IAddressService>();
var mockRepo = ApiTestData.MockTenantRepo(ApiTestData.Tenants.ToList());
mockRepo.Setup(r => r.AddAsync(It.IsAny <Lib.Models.Tenant>()));
var controller = new TenantController(mockRepo.Object, mockAddressService.Object, mockLogger.Object);
//Act
var result = await controller.PostAsync(new ApiTenant
{
AddressId = Guid.Parse("fa4d8c6e-9650-44c9-8c6b-5aebd3f9a67d"),
ApiAddress = null,
ApiBatch = null,
ApiCar = null,
BatchId = 1,
CarId = 1,
Email = "*****@*****.**",
FirstName = "Victoria",
Gender = "Female",
Id = null,
LastName = "Something Spanish",
RoomId = null,
TrainingCenter = Guid.Parse("837c3248-1685-4d08-934a-0f17a6d1836a")
});
//Assert
var ok = Assert.IsAssignableFrom <ObjectResult>(result.Result);
var tenant = Assert.IsAssignableFrom <string>(ok.Value);
Assert.NotNull(tenant);
}
public async Task TenantControllerGet()
{
var data = new FakeApiDataEntityHandler <Tenant>();
var model = TenantData.GetFirst();
data.Result.Setup(m => m.Execute(It.IsAny <Loader <Tenant> >())).Returns(model);
var controller = new TenantController(data, Logic)
{
CurrentUser = AdminUser
};
var result = await controller.Get(TenantData.FirstId) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().NotBeNull();
var check = result.Value as TenantViewModel;
check.ProfileId.Should().Be(model.ProfileId);
check.ProfileThumbUrl.Should().Be(model.ProfileThumbUrl);
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <Loader <Tenant> >()), Times.Once);
}
public async Task UserControllerFilter()
{
var data = new FakeApiDataResultHandler <Tenant, TenantDisplay>();
var list = new List <TenantDisplay> {
TenantData.GetFirstDisplay()
};
var filter = new TenantFilter {
TenantRestrict = true
};
data.Result.Setup(m => m.Execute(It.IsAny <TenantDisplayByFilter>())).Returns(list);
var controller = new TenantController(data, Logic)
{
CurrentUser = SuperUser
};
var result = await controller.Filter(filter) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().NotBeNull();
var check = result.Value as PagedResult <IEnumerable <TenantDisplay> >;
check.Should().NotBeNull();
check.Data.Count().Should().Be(list.Count);
Assert.That(check.Data, Is.DeepEqualTo(list));
data.HasExecuted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <TenantDisplayByFilter>()), Times.Once());
}
public async Task TenantControllerPost()
{
var data = new FakeApiDataEntityHandler <Tenant>();
var model = TenantData.GetFirst();
data.Result.Setup(m => m.Execute(It.IsAny <Loader <Tenant> >())).Returns(model);
data.Result.Setup(m => m.Execute(It.IsAny <TenantSave>())).Returns(model);
var controller = new TenantController(data, Logic)
{
CurrentUser = SuperUser
};
var viewModel = controller.Mapper.Map <TenantViewModel>(model);
var result = await controller.Post(viewModel) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().NotBeNull();
var check = result.Value as ConfirmViewModel;
check.Success.Should().BeTrue();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <TenantSave>()), Times.Once);
}
public ContactTenantTesting()
{
_tenantRepository = new Mock <IAsyncContactRepository <Tenant> >();
_userRepository = new Mock <IAsyncContactRepository <User> >();
_contactRepository = new Mock <IAsyncContactRepository <Contact> >();
_addressRepository = new Mock <IAsyncContactRepository <Address> >();
_tenantController = new TenantController(_tenantRepository.Object, _userRepository.Object, _contactRepository.Object, _addressRepository.Object);
}
public async Task UpdateAsyncShouldReturnStatusCode204()
{
//Arrange (create a moq repo and use it for the controller)
var mockRepo = ApiTestData.MockBatchRepo(ApiTestData.Batches.ToList());
var options = TestDbInitializer.InitializeDbOptions("GetAllBatchesByTCShouldGetAllByTCAsync");
using var db = TestDbInitializer.CreateTestDb(options);
var mapper = new Mapper();
var mockLogger = new Mock <ILogger <TenantController> >();
var mockAddressService = new Mock <IAddressService>();
var controller = new TenantController(mockRepo.Object, mockAddressService.Object, mockLogger.Object);
//Act
var apiTenant = new ApiTenant
{
Id = Guid.Parse("fa4d6c6e-9650-44c9-8c6b-5aebd3f9a67d"),
Email = "*****@*****.**",
Gender = "male",
FirstName = "Colton",
LastName = "Clary",
AddressId = Guid.Parse("fa4d6c6e-9650-44c9-8c6b-5aebd3f9a67d"),
TrainingCenter = Guid.Parse("fa4d6c6e-9650-44c9-8c6b-5aebd3f9a67d"),
ApiBatch = new ApiBatch
{
TrainingCenter = Guid.Parse("fa4d6c6e-9650-44c9-8c6b-5aebd3f9a67d"),
Id = 1,
BatchCurriculum = "c#"
},
ApiCar = new ApiCar
{
Id = 1,
Color = "y",
LicensePlate = "123",
Make = "s",
Model = "2",
State = "w",
Year = "l"
},
ApiAddress = new ApiAddress
{
State = "sdl",
AddressId = Guid.Parse("fa4d6c6e-9650-44c9-8c6b-5aebd3f9a67d"),
City = "l",
Country = "l",
Street = "s",
ZipCode = "l"
}
};
var result = await controller.UpdateAsync(apiTenant);
//Assert
_ = Assert.IsAssignableFrom <StatusCodeResult>(result);
}
public void Index()
{
// 1. Arrange
TenantController tenantController = new TenantController();
// 2. Act
ViewResult result = tenantController.Index() as ViewResult;
// 3. Assert
Assert.IsNotNull(result);
}
public void Update_ShouldFail_GivenTenantDoesntExist()
{
// Given
// TenantController over a mock service that would alway throw exceptions on Get & GetAsync
var tenantService = Substitute.For <IService <Tenant> >();
tenantService.When(s => s.GetAsync(Arg.Any <Guid>()))
.Do(v => throw new ItemNotFoundException(v[0].ToString(), "tenant"));
var tenantCreator = Substitute.For <ITenantCreator>();
var logger = Substitute.For <ILogger <TenantController> >();
var accountService = Substitute.For <IAccountService>();
var inspectionService = Substitute.For <IInspectionService>();
var employeeService = Substitute.For <IEmployeeService>();
var branchOfficeService = Substitute.For <IService <BranchOffice> >();
var departmentService = Substitute.For <IService <Department> >();
var tenantController = new TenantController(
tenantService,
tenantCreator,
accountService,
inspectionService,
employeeService,
branchOfficeService,
departmentService,
logger);
var tenantId = Guid.NewGuid();
var tenantDto = new TenantDto
{
Id = tenantId.ToString(),
Name = "Tenant",
PrimaryContact = new ContactInfoDto
{
Email = "*****@*****.**"
},
ServiceDetails = new ServiceDetailsDto
{
}
};
// When
// Put is called on the controller
AsyncTestDelegate action = async() => await tenantController.Put(tenantId, tenantDto);
// Then
// The controller should thrown ItemNotFoundException
Assert.ThrowsAsync <ItemNotFoundException>(action);
}
private string GetConnStr()
{
if (HttpContext.User.Identity is ClaimsIdentity identity)
{
var tid = identity.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid").Value;
string upn = identity?.Name;
TenantController tc = new TenantController();
return(tc.GetConnStr(tid, upn));
}
else
{
return("");
}
}
public void Update_ShouldSucceed_GivenTenantExists()
{
// Given
var id = Guid.NewGuid();
var tenant = new Tenant()
{
Id = id,
Name = "Tenant 1",
ServiceDetails = new TenantServiceDetails {
},
PrimaryContact = new ContactInfo {
}
};
var tenantService = Substitute.For <IService <Tenant> >();
tenantService.When(s => s.UpdateAsync(Arg.Any <Tenant>())).Do(c => { });
tenantService.GetAsync(Arg.Any <Guid>()).Returns(tenant);
var tenantCreator = Substitute.For <ITenantCreator>();
var logger = Substitute.For <ILogger <TenantController> >();
var accountService = Substitute.For <IAccountService>();
var inspectionService = Substitute.For <IInspectionService>();
var employeeService = Substitute.For <IEmployeeService>();
var branchOfficeService = Substitute.For <IService <BranchOffice> >();
var departmentService = Substitute.For <IService <Department> >();
var tenantController = new TenantController(
tenantService,
tenantCreator,
accountService,
inspectionService,
employeeService,
branchOfficeService,
departmentService,
logger);
var updatedTenantModel = Mapper.Map <TenantDto>(tenant);
// When
var actionResult = tenantController.Put(tenant.Id, updatedTenantModel).Result;
// Then
tenantService.Received().UpdateAsync(Arg.Is <Tenant>(c => c.Id == tenant.Id));
var result = (NoContentResult)actionResult;
Assert.That(result.StatusCode, Is.EqualTo((int)HttpStatusCode.NoContent));
}
public void GetTenants_Should_Return_OkObjectResult_With_EnumerableOfTenants()
{
// Given
var id = Guid.NewGuid();
var tenant = new Tenant()
{
Id = id, Name = "Tenant 1"
};
var id2 = Guid.NewGuid();
var tenant2 = new Tenant()
{
Id = id2, Name = "Tenant 2"
};
var tenantService = Substitute.For <IService <Tenant> >();
tenantService.GetAllAsync(Arg.Any <int?>(), Arg.Any <int?>()).Returns(new[] { tenant, tenant2 });
var tenantCreator = Substitute.For <ITenantCreator>();
var logger = Substitute.For <ILogger <TenantController> >();
var accountService = Substitute.For <IAccountService>();
var inspectionService = Substitute.For <IInspectionService>();
var employeeService = Substitute.For <IEmployeeService>();
var branchOfficeService = Substitute.For <IService <BranchOffice> >();
var departmentService = Substitute.For <IService <Department> >();
var tenantController = new TenantController(
tenantService,
tenantCreator,
accountService,
inspectionService,
employeeService,
branchOfficeService,
departmentService,
logger);
// When
var actionResult = tenantController.GetAll().Result;
// Then
tenantService.Received().GetAllAsync(Arg.Any <int?>(), Arg.Any <int?>());
var objectResult = (OkObjectResult)actionResult;
var tenantModels = (IEnumerable <TenantDto>)objectResult.Value;
Assert.That(tenantModels.Any(), Is.True);
Assert.That(tenantModels.Where(c => c.Id == id.ToString()).Any());
Assert.That(tenantModels.Where(c => c.Id == id2.ToString()).Any());
}
public void ConstructorShouldConstruct()
{
// arrange (create database)
var mockLogger = new Mock <ILogger <TenantController> >();
var mockAddressService = new Mock <IAddressService>();
var options = TestDbInitializer.InitializeDbOptions("TestTenantControllerConstructor");
using var database = TestDbInitializer.CreateTestDb(options);
var mapper = new Mapper();
// act (pass repository with database into controller)
var test = new TenantController(new TenantRepository(database, mapper), mockAddressService.Object, mockLogger.Object);
// assert (test passes if no exception thrown)
}
public void Get_NoFiltersRequest_OKResult()
{
//Arrange
var logger = Mock.Of <ILogger <TenantController> >();
var controller = new TenantController(logger);
//Act
var actionResult = controller.Get();
//Assert
var result = actionResult.Result as OkObjectResult;
Assert.NotNull(result);
var modelResult = result.Value as IEnumerable <TenantViewModel>;
Assert.NotNull(modelResult);
}
public async void Get_Not_Exists()
{
TenantControllerMockFacade mock = new TenantControllerMockFacade();
mock.ServiceMock.Setup(x => x.Get(It.IsAny <string>())).Returns(Task.FromResult <ApiTenantResponseModel>(null));
TenantController controller = new TenantController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.Get(default(string));
response.Should().BeOfType <StatusCodeResult>();
(response as StatusCodeResult).StatusCode.Should().Be((int)HttpStatusCode.NotFound);
mock.ServiceMock.Verify(x => x.Get(It.IsAny <string>()));
}
public void FetchBuildingTenants_RegularValues_OkResults()
{
//Arrange
var tenant = new Mock <ITenant>();
tenant.SetupGet(a => a.Id).Returns(2);
var newTenant = new Mock <ITenant>();
newTenant.SetupGet(a => a.Id).Returns(3);
var tenantList = new List <ITenant>()
{
tenant.Object, newTenant.Object
};
facade.Setup(f => f.FetchTenants("3445")).Returns(tenantList);
var controller = new TenantController(facade.Object)
{
ControllerContext = controllerContext
};
//Act
var result = controller.FetchBuildingTenants();
//Assert
Assert.NotNull(result);
var okresult = Assert.IsType <OkNegotiatedContentResult <IEnumerable <ITenant> > >(result);
Assert.NotNull(okresult.Content);
Assert.Equal(2, okresult.Content.Count());
var enumerator = okresult.Content.GetEnumerator();
enumerator.MoveNext();
Assert.NotNull(enumerator.Current);
Assert.Equal(2, enumerator.Current.Id);
enumerator.MoveNext();
Assert.NotNull(enumerator.Current);
Assert.Equal(3, enumerator.Current.Id);
enumerator.Dispose();
}
public void Create()
{
Tenant tenant = new Tenant();
Property property = new Property();
tenant.ID = "0";
tenant.Name = "Jeff Bezos";
tenant.Phone = "123-456-7890";
tenant.Property = property;
tenant.Password = "******";
TenantController tenantController = new TenantController();
ViewResult result = tenantController.Create(tenant) as ViewResult;
Assert.IsNotNull(tenant, result.ViewBag.Message);
}
public async Task GetAsyncShouldReturnRoomList()
{
// arrange
var mockRepo = new Mock <IRepository>();
var mockLogger = new Mock <ILogger <TenantController> >();
var controller = new TenantController(mockRepo.Object, mockLogger.Object);
var gender = "nonbinary";
var dateTime = new DateTime();
// act
var result = await controller.GetAsync(gender, dateTime);
// assert
Assert.NotNull(result);
Assert.IsAssignableFrom <OkObjectResult>(result);
}
public void ChangeApartment_ThrowsError_BadModel()
{
//Arrange
var controller = new TenantController(facade.Object)
{
ControllerContext = controllerContext
};
controller.ModelState.AddModelError("Key", "ErrorMessage");
//Act
var result = controller.ChangeApartment(model);
//Assert
Assert.NotNull(result);
Assert.IsType <InvalidModelStateResult>(result);
}
public async Task TenantControllerDisplayNull()
{
var data = new FakeApiDataResultHandler <Tenant, TenantDisplay>();
data.Result.Setup(m => m.Execute(It.IsAny <TenantDisplayById>())).Returns(null);
var controller = new TenantController(data, Logic)
{
CurrentUser = StandardUser
};
var result = await controller.Display(TenantData.FirstId) as NotFoundResult;
result.Should().NotBeNull();
result.Should().BeOfType <NotFoundResult>();
data.HasExecuted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <TenantDisplayById>()), Times.Once());
}
public async Task GetByIdShouldGetByIdAsync()
{
// Arrange (create a moq repo and use it for the controller)
var mockLogger = new Mock <ILogger <TenantController> >();
var mockAddressService = new Mock <IAddressService>();
var mockRepo = ApiTestData.MockTenantRepo(ApiTestData.Tenants.ToList());
var controller = new TenantController(mockRepo.Object, mockAddressService.Object, mockLogger.Object);
// Act (get a Tenant with an id)
var colton = Guid.Parse("fa4d6c6e-9650-44c9-8c6b-5aebd3f9a67d");
var result = await controller.GetByIdAsync(colton);
// Assert (ensure the provider is returned with the correct values)
var ok = Assert.IsAssignableFrom <OkObjectResult>(result.Result);
var tenant = Assert.IsAssignableFrom <ApiTenant>(ok.Value);
Assert.NotNull(tenant);
}
