[TestMethod] // [2] Update Tenant
public void PutTenantUpdatesTenant()
{
//Arrange
var tCtrl = new TenantsController();
var newTenant = new TenantModel
{
FirstName = "Test",
LastName = "LastNameTest",
Telephone = "12223334444",
EmailAddress = "*****@*****.**"
};
//The result of the Post Request
IHttpActionResult result = tCtrl.PostTenant(newTenant);
//Cast result of the content result so that I can gether information form the Contente
CreatedAtRouteNegotiatedContentResult <TenantModel> contentResult = (CreatedAtRouteNegotiatedContentResult <TenantModel>)result;
//Result containts the tenant I have just created
result = tCtrl.GetTenant(contentResult.Content.TenantId);
//Get tenant model from result
OkNegotiatedContentResult <TenantModel> tenantResult = (OkNegotiatedContentResult <TenantModel>)result;
//Act
result = tCtrl.PutTenant(tenantResult.Content.TenantId, newTenant);
//Assert
Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
}
public void SetupController()
{
var mockTenantRepository = new Mock <ITenantRepository>();
var mockLogger = new Mock <ILogger <TenantsController> >();
mockTenantRepository.Setup(r => r.GetTenants()).Returns(GetTenants());
mockTenantRepository.Setup(r => r.GetTenant(It.IsAny <Guid>())).Returns(GetTenant());
mockTenantRepository.Setup(r => r.CreateTenant(It.IsAny <Tenant>())).Returns(GetTenant());
mockTenantRepository.Setup(r => r.TenantExists(It.IsAny <Guid>())).Returns(true);
mockTenantRepository.Setup(r => r.DeleteTenant(It.IsAny <Guid>()));
mockTenantRepository.Setup(r => r.UpdateTenant(It.IsAny <Guid>()));
var mockUnitofWork = new Mock <IUnitOfWork>();
mockUnitofWork.Setup(u => u.TenantRepository).Returns(mockTenantRepository.Object);
tenantsController = new TenantsController(mockUnitofWork.Object, Mapper, mockLogger.Object);
var objectValidator = new Mock <IObjectModelValidator>();
objectValidator.Setup(o => o.Validate(It.IsAny <ActionContext>(),
It.IsAny <ValidationStateDictionary>(),
It.IsAny <string>(),
It.IsAny <Object>()));
tenantsController.ObjectValidator = objectValidator.Object;
}
public void GetTenantForPropertyReturnsOkAndSingleTenant()
{
// Arrange
var tenantId = new Guid();
var propertyId = new Guid();
var fakeTenant = new Faker <Tenant>()
.RuleFor(t => t.Id, t => tenantId);
var tenantList = new List <Tenant>();
tenantList.Add(fakeTenant);
var mockRepository = new Mock <IPropertyRepository>();
mockRepository.Setup(r => r.PropertyExist(propertyId))
.Returns(true);
mockRepository.Setup(r => r.GetTenantsForProperty(propertyId))
.Returns(tenantList);
var sut = new TenantsController(mockRepository.Object);
// Act
var result = sut.GetTenantForProperty(propertyId, tenantId) as OkObjectResult;
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.StatusCode, Is.EqualTo(200));
Assert.That(result.Value, Is.TypeOf <TenantDto>());
mockRepository.Verify(r => r.GetTenantsForProperty(propertyId), Times.Once);
}
public void PostTenantCreatesTenant()
{
//Arrange: Instantiate TenantsController so its methods can be called
var tenantController = new TenantsController();
//Act:
// Create a TenantModel object populated with test data,
// and call PostTenant
var newTenant = new TenantModel
{
FirstName = "Testy",
LastName = "McTest",
Telephone = "555-1212",
EmailAddress = "*****@*****.**"
};
IHttpActionResult result = tenantController.PostTenant(newTenant);
//Assert:
// Verify that the HTTP result is CreatedAtRouteNegotiatedContentResult
// Verify that the HTTP result body contains a nonzero tenant ID
Assert.IsInstanceOfType
(result, typeof(CreatedAtRouteNegotiatedContentResult <TenantModel>));
CreatedAtRouteNegotiatedContentResult <TenantModel> contentResult =
(CreatedAtRouteNegotiatedContentResult <TenantModel>)result;
Assert.IsTrue(contentResult.Content.TenantId != 0);
// Delete the test tenant
result = tenantController.DeleteTenant(contentResult.Content.TenantId);
}
public void CreateTenantForPropertyReturnsCreatedAtRouteNewRouteAndTenant()
{
// Arrange
var propertyId = new Guid();
var fakeTenant = new Faker <TenantForCreationDto>().Generate();
var mockRepository = new Mock <IPropertyRepository>();
mockRepository.Setup(r => r.PropertyExist(propertyId)).Returns(true);
mockRepository.Setup(r => r.Save()).Returns(true);
var sut = new TenantsController(mockRepository.Object);
var tenant = Mapper.Map <Tenant>(fakeTenant);
var tenantDto = Mapper.Map <TenantDto>(tenant);
// Act
var result = sut.CreateTenantForProperty(propertyId, fakeTenant) as CreatedAtRouteResult;
// Assert
mockRepository.Verify(r => r.PropertyExist(propertyId), Times.Once);
mockRepository.Verify(r => r.Save(), Times.Once);
Assert.That(result.StatusCode, Is.EqualTo(201));
Assert.That(result.RouteName, Is.EqualTo("GetTenant"));
Assert.That(result.Value, Is.TypeOf <TenantDto>());
}
public void GetTenantsForPropertyReturnsOkAndTenantDtoCollection()
{
// Arrange
var propertyId = new Guid();
var fakeTenants = new List <Tenant>();
fakeTenants.Add(
new Faker <Tenant>()
.RuleFor(t => t.Id, t => new Guid())
.RuleFor(t => t.PropertyId, t => propertyId));
var mockRepository = new Mock <IPropertyRepository>();
mockRepository.Setup(r => r.PropertyExist(propertyId))
.Returns(true);
mockRepository.Setup(r => r.GetTenantsForProperty(propertyId))
.Returns(fakeTenants);
var sut = new TenantsController(mockRepository.Object);
// Act
var result = sut.GetTenantsForProperty(propertyId) as OkObjectResult;
// Assert
Assert.That(result, Is.TypeOf <OkObjectResult>());
Assert.That(result.StatusCode, Is.EqualTo(200));
Assert.That(result.Value, Is.TypeOf <List <TenantDto> >());
}
public void DeleteTenantDeletesTenant()
{
//Arrange:
// Instantiate TenantsController so its methods can be called
// Create a new tenant to be deleted, and get its tenant ID
var tenantController = new TenantsController();
var tenant = new TenantModel
{
FirstName = "Testy",
LastName = "Testering",
Telephone = "555-1212",
EmailAddress = "*****@*****.**"
};
IHttpActionResult result = tenantController.PostTenant(tenant);
CreatedAtRouteNegotiatedContentResult <TenantModel> contentResult =
(CreatedAtRouteNegotiatedContentResult <TenantModel>)result;
int tenantIdToDelete = contentResult.Content.TenantId;
// Add a lease corresponding to the tenant
int createdLeaseId;
using (var leaseController = new LeasesController())
{
var lease = new LeaseModel
{
CreatedDate = new DateTime(2014, 9, 30),
PropertyId = 1,
TenantId = tenantIdToDelete,
StartDate = new DateTime(2015, 1, 30),
Rent = 800,
LeaseType = Constants.RentPeriod.Monthly
};
IHttpActionResult leaseResult = leaseController.PostLease(lease);
CreatedAtRouteNegotiatedContentResult <LeaseModel> leaseContentResult =
(CreatedAtRouteNegotiatedContentResult <LeaseModel>)leaseResult;
createdLeaseId = leaseContentResult.Content.LeaseId;
}
//Act: Call DeleteTenant
result = tenantController.DeleteTenant(tenantIdToDelete);
//Assert:
// Verify that HTTP result is OK
// Verify that reading deleted tenant returns result not found
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <TenantModel>));
result = tenantController.GetTenant(tenantIdToDelete);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
// Verify that the lease created above was deleted
using (var leaseController = new LeasesController())
{
IHttpActionResult leaseResult = leaseController.GetLease(createdLeaseId);
Assert.IsInstanceOfType(leaseResult, typeof(NotFoundResult));
}
}
public void PutTenantUpdatesTenant()
{
int tenantIdForTest = 1;
string tenantFirstNameForTest = "Testy";
string tenantLastNameForTest = "Testerson";
//Arrange: Instantiate TenantsController so its methods can be called
var tenantController = new TenantsController();
//Act:
// Get an existing tenant, change it, and
// pass it to PutTenant
IHttpActionResult result = tenantController.GetTenant(tenantIdForTest);
OkNegotiatedContentResult <TenantModel> contentResult =
(OkNegotiatedContentResult <TenantModel>)result;
TenantModel updatedTenant = (TenantModel)contentResult.Content;
string tenantFirstNameBeforeUpdate = updatedTenant.FirstName;
string tenantLastNameBeforeUpdate = updatedTenant.LastName;
updatedTenant.FirstName = tenantFirstNameForTest;
updatedTenant.LastName = tenantLastNameForTest;
result = tenantController.PutTenant
(updatedTenant.TenantId, updatedTenant);
//Assert:
// Verify that HTTP status code is OK
// Get the tenant and verify that it was updated
var statusCode = (StatusCodeResult)result;
Assert.IsTrue(statusCode.StatusCode == System.Net.HttpStatusCode.NoContent);
result = tenantController.GetTenant(tenantIdForTest);
Assert.IsInstanceOfType(result,
typeof(OkNegotiatedContentResult <TenantModel>));
OkNegotiatedContentResult <TenantModel> readContentResult =
(OkNegotiatedContentResult <TenantModel>)result;
updatedTenant = (TenantModel)readContentResult.Content;
Assert.IsTrue(updatedTenant.FirstName == tenantFirstNameForTest);
Assert.IsTrue(updatedTenant.LastName == tenantLastNameForTest);
updatedTenant.FirstName = tenantFirstNameBeforeUpdate;
updatedTenant.LastName = tenantLastNameBeforeUpdate;
result = tenantController.PutTenant
(updatedTenant.TenantId, updatedTenant);
}
public void GetTanantsTestMethod()
{
TenantsController controller = new TenantsController(context);
IActionResult actionResult = controller.Tenants();
OkObjectResult result = actionResult as OkObjectResult;
List <Tenant> tenants = result.Value as List <Tenant>;
Assert.IsNotNull(result);
Assert.AreEqual(result.StatusCode, 200);
Assert.AreNotEqual(tenants.Count, 0);
}
[TestMethod] // [0] | Get Tenants
public void GetTenantsReturnTenants()
{
//Arrange
//Properties go here
var tenantsController = new TenantsController();
//Act
IEnumerable <TenantModel> tenant = tenantsController.GetTenants();
//Assert
Assert.IsTrue(tenant.Count() > 0);
}
public void GetTenantsReturnsTenants()
{
//Arrange: Instantiate TenantsController so its methods can be called
using (var tenantController = new TenantsController())
{
//Act: Call the GetTenants method
IEnumerable <TenantModel> tenants = tenantController.GetTenants();
//Assert: Verify that an array was returned with at least one element
Assert.IsTrue(tenants.Count() > 0);
}
}
[TestMethod] // [1] | Get Tenant
public void GetTenantFromIDReturnTenant()
{
//Arrange
var Tctrl = new TenantsController();
//Act
IHttpActionResult result = Tctrl.GetTenant(1);
//If action returns: NotFound()
Assert.IsNotInstanceOfType(result, typeof(NotFoundResult));
//if Acction returns: Ok();
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <TenantModel>));
}
public void AddTenantsExistsTestMethod()
{
TenantsController controller = new TenantsController(context);
Tenant tenant = new Tenant()
{
tenant_id = "Gerardo-Longo"
};
IActionResult actionResult = controller.Tenants(tenant);
BadRequestObjectResult result = actionResult as BadRequestObjectResult;
Assert.IsNotNull(result);
Assert.AreEqual(result.StatusCode, 400);
}
public void AddTenantsTestMethod()
{
TenantsController controller = new TenantsController(context);
Tenant tenant = new Tenant()
{
tenant_id = "pluto"
};
IActionResult actionResult = controller.Tenants(tenant);
OkObjectResult result = actionResult as OkObjectResult;
Tenant tenantResult = result.Value as Tenant;
Assert.IsNotNull(result);
Assert.AreEqual(result.StatusCode, 200);
Assert.AreEqual(tenant.tenant_id, "pluto");
}
public void CreateTenantForPropertyRerturnsBadRequestIfTenantIsNull()
{
// Arrange
TenantForCreationDto tenant = null;
var propertyId = new Guid();
var mockRepository = new Mock <IPropertyRepository>();
var sut = new TenantsController(mockRepository.Object);
// Act
var result = sut.CreateTenantForProperty(propertyId, tenant) as BadRequestResult;
// Assert
Assert.That(result, Is.TypeOf <BadRequestResult>());
Assert.That(result.StatusCode, Is.EqualTo(400));
mockRepository.Verify(r => r.PropertyExist(propertyId), Times.Never);
}
public async Task TenantGet()
{
//Mock obujects
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:58578/aparte/Tenant");
ODataModelBuilder builder = Aparte.ModelBuilder.AparteModelBuilder.GetOdataModelBuilder();
var model = builder.GetEdmModel();
HttpRouteCollection routes = new HttpRouteCollection();
HttpConfiguration config = new HttpConfiguration(routes)
{
IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always
};
config.MapODataServiceRoute("ODataV4Route", "aparte", model);
config.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
config.EnableDependencyInjection();
//Check all the routes are properly initialized.
config.EnsureInitialized();
request.SetConfiguration(config);
ODataQueryContext context = new ODataQueryContext(
model,
typeof(Tenant),
new ODataPath(
new Microsoft.OData.UriParser.EntitySetSegment(
model.EntityContainer.FindEntitySet("Tenants"))
)
);
var controller = new TenantsController();
controller.Request = request;
var options = new ODataQueryOptions <Tenant>(context, request);
var response = await(controller.Get() as IHttpActionResult).ExecuteAsync(CancellationToken.None);
List <Tenant> tenants = await response.Content.ReadAsAsync <List <Tenant> >();
Assert.IsTrue(tenants.Any());
}
[TestMethod]// [3] Create Tenant
public void PostTenantCreatesTenant()
{
//arrange
var Tcrtl = new TenantsController();
//Act
var newTenant = new TenantModel
{
FirstName = "Test",
LastName = "LastNameTest",
Telephone = "12223334444",
EmailAddress = "*****@*****.**"
};
//Result of the post request
IHttpActionResult result = Tcrtl.PostTenant(newTenant);
//Assert
Assert.IsInstanceOfType(result, typeof(CreatedAtRouteNegotiatedContentResult <TenantModel>));
}
public void GetTenantReturnsTenant()
{
int TenantIdForTest = 1;
//Arrange: Instantiate TenantsController so its methods can be called
var tenantController = new TenantsController();
//Act: Call the GetTenant method
IHttpActionResult result = tenantController.GetTenant(TenantIdForTest);
//Assert:
// Verify that HTTP status code is OK
// Verify that returned tenant ID is correct
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <TenantModel>));
OkNegotiatedContentResult <TenantModel> contentResult =
(OkNegotiatedContentResult <TenantModel>)result;
Assert.IsTrue(contentResult.Content.TenantId == TenantIdForTest);
}
public void GetTenantsForPropertyReturnsNotFoundIdDoesNotExist()
{
// Arrange
var propertyId = new Guid();
var mockRepository = new Mock <IPropertyRepository>();
mockRepository.Setup(r => r.PropertyExist(propertyId))
.Returns(false);
var sut = new TenantsController(mockRepository.Object);
// Act
var result = sut.GetTenantsForProperty(propertyId) as NotFoundResult;
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.TypeOf <NotFoundResult>());
Assert.That(result.StatusCode, Is.EqualTo(404));
mockRepository.Verify(m => m.PropertyExist(propertyId), Times.Once);
}
public void CreateTenantForPropertyReturnsNotFoundIfPropertyDoesNotExist()
{
// Arrange
var propertyId = new Guid();
var newTenant = new Faker <TenantForCreationDto>().Generate();
var mockRepository = new Mock <IPropertyRepository>();
mockRepository.Setup(r => r.PropertyExist(propertyId))
.Returns(false);
var sut = new TenantsController(mockRepository.Object);
// Act
var result = sut.CreateTenantForProperty(propertyId, newTenant) as NotFoundResult;
// Assert
Assert.That(result, Is.TypeOf <NotFoundResult>());
Assert.That(result.StatusCode, Is.EqualTo(404));
mockRepository.Verify(r => r.PropertyExist(propertyId), Times.Once);
}
public void CreateTenantForPropertyThrowsExceptionIfRepositorySaveFails()
{
// Arrange
var propertyId = new Guid();
var fakeTenant = new Faker <TenantForCreationDto>().Generate();
var mockRepository = new Mock <IPropertyRepository>();
mockRepository.Setup(r => r.PropertyExist(propertyId)).Returns(true);
mockRepository.Setup(r => r.Save()).Returns(false);
var sut = new TenantsController(mockRepository.Object);
var tenantDto = Mapper.Map <Tenant>(fakeTenant);
// Act
sut.CreateTenantForProperty(propertyId, fakeTenant);
// Assert
mockRepository.Verify(r => r.PropertyExist(propertyId), Times.Once);
Assert.Throws <Exception>(
() => sut.CreateTenantForProperty(propertyId, fakeTenant));
}
[TestMethod] // [4] Delete Tenant
public void DeletePropertyDeleteProperty()
{
//Arrange
var tctrl = new TenantsController();
//Act
var newTenant = new TenantModel
{
FirstName = "Test",
LastName = "LastNameTest",
Telephone = "12223334444",
EmailAddress = "*****@*****.**"
};
//Add 'new tenant' to database using post
//save returned value as result
IHttpActionResult result = tctrl.PostTenant(newTenant);
//Cast result as content result so I can gather intel on it
CreatedAtRouteNegotiatedContentResult <TenantModel> contentResult = (CreatedAtRouteNegotiatedContentResult <TenantModel>)result;
//Result contains the property I had just created
result = tctrl.GetTenant(contentResult.Content.TenantId);
//get tenantmodel from result
OkNegotiatedContentResult <TenantModel> tenantResult = (OkNegotiatedContentResult <TenantModel>)result;
//Act
result = tctrl.DeleteTenant(contentResult.Content.TenantId);
//Assert
//If action returns not found
Assert.IsNotInstanceOfType(result, typeof(NotFoundResult));
//If action retruns OK()
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <TenantModel>));
}
