public void PostPropertyCreatesProperty()
{
//Arrange: Instantiate PropertiesController so its methods can be called
var propertyController = new PropertiesController();
//Act:
// Create a PropertyModel object populated with test data,
// and call PostProperty
var newProperty = new PropertyModel
{
Name = "Huge Penthouse",
Address1 = "Some address",
City = "New York",
State = "NY"
};
IHttpActionResult result = propertyController.PostProperty(newProperty);
//Assert:
// Verify that the HTTP result is CreatedAtRouteNegotiatedContentResult
// Verify that the HTTP result body contains a nonzero property ID
Assert.IsInstanceOfType
(result, typeof(CreatedAtRouteNegotiatedContentResult <PropertyModel>));
CreatedAtRouteNegotiatedContentResult <PropertyModel> contentResult =
(CreatedAtRouteNegotiatedContentResult <PropertyModel>)result;
Assert.IsTrue(contentResult.Content.PropertyId != 0);
// Delete the test property
result = propertyController.DeleteProperty(contentResult.Content.PropertyId);
}
[TestMethod] //[3] | Create Property
public void PostPropertyCreatesProperty()
{
//Arrange
var propertiesController = new PropertiesController();
//act
var newProp = new PropertyModel
{
Name = "Wonder Mansion",
Address1 = "122 Wonka Way",
Address2 = "",
City = "Golden Coast",
Zip = "23123",
State = "CA"
};
//Result of the Post Request
IHttpActionResult result = propertiesController.PostProperty(newProp);
//Assert
Assert.IsInstanceOfType(result, typeof(CreatedAtRouteNegotiatedContentResult <PropertyModel>));
//Cast
CreatedAtRouteNegotiatedContentResult <PropertyModel> contentResult = (CreatedAtRouteNegotiatedContentResult <PropertyModel>)result;
Assert.IsTrue(contentResult.Content.PropertyId != 0);
}
public void PostBoxShouldReturnSingleBox()
{
//Arrange
BoxesModel box = new BoxesModel {
BoxId = 1, PawzeUserId = "test1", SubscriptionId = 1
};
//Act
IHttpActionResult result = controller.PostBox(box);
//Assert
CreatedAtRouteNegotiatedContentResult <BoxesModel> okResult = (CreatedAtRouteNegotiatedContentResult <BoxesModel>)result;
var actualBox = okResult.Content;
// TODO: Cameron's last thought on testing
// _boxRepository.Verify(e => e.)
//Assert
BoxesModel expected = new BoxesModel {
BoxId = 1, PawzeUserId = "test1", SubscriptionId = 1
};
Assert.AreEqual(expected.BoxId, actualBox.BoxId);
}
public void BeAbleToPostNewPaymentIntoRepository()
{
List <IField> emptyFields = new List <IField>();
NumberField field = new NumberField("Monto");
emptyFields.Add(field);
IField filledField = field.FillAndClone("100");
List <IField> fullFields = new List <IField>();
fullFields.Add(filledField);
Provider provider = new Provider("Antel", 3, emptyFields);
Receipt receipt = new Receipt(provider, fullFields, 100);
List <Receipt> list = new List <Receipt>();
list.Add(receipt);
Payment payment = new Payment(new CashPayMethod(DateTime.Now), 100, list);
var mockPaymentService = new Mock <IPaymentService>();
mockPaymentService.Setup(x => x.CreatePayment(payment)).Returns(1);
PaymentsController controller = new PaymentsController(mockPaymentService.Object);
IHttpActionResult actionResult = controller.PostPayment(payment);
CreatedAtRouteNegotiatedContentResult <Payment> contentResult = (CreatedAtRouteNegotiatedContentResult <Payment>)actionResult;
Assert.AreSame(contentResult.Content, payment);
}
[TestMethod] // [2] Update Lease
public void PutLeaseUpdateLease()
{
//Arrange
var lCtrl = new LeasesController();
var newLease = new LeaseModel
{
PropertyId = 1,
TenantId = 1,
StartDate = DateTime.Now,
Rent = 2000
};
//The result of the PostRequest
IHttpActionResult result = lCtrl.PostLease(newLease);
//Cast result as the content result so I can gather information from Content Result
CreatedAtRouteNegotiatedContentResult <LeaseModel> contentResult = (CreatedAtRouteNegotiatedContentResult <LeaseModel>)result;
//REsult containts the property I had just created
result = lCtrl.GetLease(contentResult.Content.LeaseId);
//GET PropertyModel from Result
OkNegotiatedContentResult <LeaseModel> propertyResult = (OkNegotiatedContentResult <LeaseModel>)result;
//Act
result = lCtrl.PutLease(propertyResult.Content.LeaseId, newLease);
//Assert
Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
}
[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 DeleteLeaseDeletesLease()
{
//Arrange:
// Instantiate LeasesController so its methods can be called
// Create a new lease to be deleted, and get its lease ID
var leaseController = new LeasesController();
var lease = new LeaseModel
{
CreatedDate = new DateTime(2014, 9, 30),
PropertyId = 1,
TenantId = 1,
StartDate = new DateTime(2015, 1, 30),
Rent = 800,
LeaseType = Constants.RentPeriod.Monthly
};
IHttpActionResult result = leaseController.PostLease(lease);
CreatedAtRouteNegotiatedContentResult <LeaseModel> contentResult =
(CreatedAtRouteNegotiatedContentResult <LeaseModel>)result;
int leaseIdToDelete = contentResult.Content.LeaseId;
//Act: Call DeleteLease
result = leaseController.DeleteLease(leaseIdToDelete);
//Assert:
// Verify that HTTP result is OK
// Verify that reading deleted lease returns result not found
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <LeaseModel>));
result = leaseController.GetLease(leaseIdToDelete);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public void PostLeaseCreatesLease()
{
//Arrange: Instantiate LeasesController so its methods can be called
var leaseController = new LeasesController();
//Act:
// Create a LeaseModel object populated with test data,
// and call PostLease
var newLease = new LeaseModel
{
CreatedDate = new DateTime(2014, 9, 30),
PropertyId = 1,
TenantId = 1,
StartDate = new DateTime(2015, 1, 30),
Rent = 800,
LeaseType = Constants.RentPeriod.Monthly
};
IHttpActionResult result = leaseController.PostLease(newLease);
//Assert:
// Verify that the HTTP result is CreatedAtRouteNegotiatedContentResult
// Verify that the HTTP result body contains a nonzero lease ID
Assert.IsInstanceOfType
(result, typeof(CreatedAtRouteNegotiatedContentResult <LeaseModel>));
CreatedAtRouteNegotiatedContentResult <LeaseModel> contentResult =
(CreatedAtRouteNegotiatedContentResult <LeaseModel>)result;
Assert.IsTrue(contentResult.Content.LeaseId != 0);
// Delete the test lease
result = leaseController.DeleteLease(contentResult.Content.LeaseId);
}
[TestMethod] //[2] | Update Property
public void PutPropertyUpdatesProperty()
{
//Arrange
var propertiesController = new PropertiesController();
var newProp = new PropertyModel
{
Name = "Wonder Mansion",
Address1 = "122 Wonka Way",
Address2 = "",
City = "Golden Coast",
Zip = "23123",
State = "CA"
};
//The result of the PostRequest
IHttpActionResult result = propertiesController.PostProperty(newProp);
//Cast result as the content result so I can gather information from Content Result
CreatedAtRouteNegotiatedContentResult <PropertyModel> contentResult = (CreatedAtRouteNegotiatedContentResult <PropertyModel>)result;
//REsult containts the property I had just created
result = propertiesController.GetProperty(contentResult.Content.PropertyId);
//GET PropertyModel from Result
OkNegotiatedContentResult <PropertyModel> propertyResult = (OkNegotiatedContentResult <PropertyModel>)result;
//Act
result = propertiesController.PutProperty(propertyResult.Content.PropertyId, newProp);
//Assert
Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
}
public void DeletePropertyDeletesProperty()
{
//Arrange:
// Instantiate PropertiesController so its methods can be called
// Create a new property to be deleted, and get its property ID
var propertyController = new PropertiesController();
var property = new PropertyModel
{
Name = "Office Space",
Address1 = "101 Broadway",
City = "San Francisco",
State = "CA"
};
IHttpActionResult propertyResult = propertyController.PostProperty(property);
CreatedAtRouteNegotiatedContentResult <PropertyModel> contentResult =
(CreatedAtRouteNegotiatedContentResult <PropertyModel>)propertyResult;
int propertyIdToDelete = contentResult.Content.PropertyId;
// Add a lease corresponding to the property
int createdLeaseId;
using (var leaseController = new LeasesController())
{
var lease = new LeaseModel
{
CreatedDate = new DateTime(2014, 9, 30),
PropertyId = propertyIdToDelete,
TenantId = 1,
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 DeleteProperty
propertyResult = propertyController.DeleteProperty(propertyIdToDelete);
//Assert:
// Verify that HTTP result is OK
// Verify that reading deleted property returns result not found
Assert.IsInstanceOfType(propertyResult, typeof(OkNegotiatedContentResult <PropertyModel>));
propertyResult = propertyController.GetProperty(propertyIdToDelete);
Assert.IsInstanceOfType(propertyResult, 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 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 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 BeAbleToPostNewPaymentIntoRepository()
{
Payment payment = CreateNewRandomPayment();
IHttpActionResult actionResult = CONTROLLER.PostPayment(payment);
CreatedAtRouteNegotiatedContentResult <Payment> contentResult = (CreatedAtRouteNegotiatedContentResult <Payment>)actionResult;
Assert.AreEqual(contentResult.Content, payment);
}
public void BeAbleToPostNewClientIntoRepository()
{
Client singleClient = new Client("Super Mega", "49018830", "26666666", "1112 28th NE");
IHttpActionResult actionResult = CONTROLLER.PostClient(singleClient);
CreatedAtRouteNegotiatedContentResult <Client> contentResult = (CreatedAtRouteNegotiatedContentResult <Client>)actionResult;
Assert.AreEqual(contentResult.Content, singleClient);
CONTROLLER.DeleteClient(singleClient.ID);
}
public void BeAbleToPostNewProviderIntoRepository()
{
Provider oneProvider = new Provider("Microsoft", 10, new List <IField>());
IHttpActionResult actionResult = CONTROLLER.PostProvider(oneProvider);
CreatedAtRouteNegotiatedContentResult <Provider> contentResult = (CreatedAtRouteNegotiatedContentResult <Provider>)actionResult;
Assert.AreEqual(contentResult.Content, oneProvider);
CONTROLLER.DeleteProvider(contentResult.Content.ID);
}
public void BeAbleToPostNewUserIntoRepository()
{
User newUser = new User("Gonzalo", "*****@*****.**", "OtraPass123!", CashierRole.GetInstance());
IHttpActionResult actionResult = CONTROLLER.PostUser(newUser);
CreatedAtRouteNegotiatedContentResult <User> contentResult = (CreatedAtRouteNegotiatedContentResult <User>)actionResult;
Assert.AreEqual(contentResult.Content, newUser);
CONTROLLER.DeleteUser(newUser.ID);
}
public void BeAbleToPostNewProviderIntoRepository()
{
Provider oneProvider = new Provider("Antel", 10, new List <IField>());
var mockProviderService = new Mock <IProviderService>();
mockProviderService.Setup(x => x.CreateProvider(oneProvider, It.IsAny <string>())).Returns(1);
ProvidersController controller = new ProvidersController(mockProviderService.Object);
IHttpActionResult actionResult = controller.PostProvider(oneProvider);
CreatedAtRouteNegotiatedContentResult <Provider> contentResult = (CreatedAtRouteNegotiatedContentResult <Provider>)actionResult;
Assert.AreSame(contentResult.Content, oneProvider);
}
public void BeAbleToPostNewClientIntoRepository()
{
Client singleClient = new Client("Ruben Rada", "11111111", "26666666", "1112 28th NE");
var mockClientService = new Mock <IClientService>();
mockClientService.Setup(x => x.CreateClient(singleClient, It.IsAny <String>())).Returns(1);
ClientsController controller = new ClientsController(mockClientService.Object);
IHttpActionResult actionResult = controller.PostClient(singleClient);
CreatedAtRouteNegotiatedContentResult <Client> contentResult = (CreatedAtRouteNegotiatedContentResult <Client>)actionResult;
Assert.AreEqual(contentResult.Content, singleClient);
}
public void BeAbleToPostNewUserIntoRepository()
{
User singleUser = new User("Gabriel", "*****@*****.**", "Wololo1234!", CashierRole.GetInstance());
var mockUserService = new Mock <IUserService>();
mockUserService.Setup(x => x.CreateUser(singleUser, It.IsAny <String>())).Returns(1);
UsersController controller = new UsersController(mockUserService.Object);
IHttpActionResult actionResult = controller.PostUser(singleUser);
CreatedAtRouteNegotiatedContentResult <User> contentResult = (CreatedAtRouteNegotiatedContentResult <User>)actionResult;
Assert.AreEqual(contentResult.Content, singleUser);
}
public void Suppliers_PostSUPPLIER_ShouldReturnSameSupplier()
{
//Arrange
//Initialize();
SUPPLIER supplier = new SUPPLIER {
SUPLNO = "6", SUPLNAME = "Hp", SUPLADDR = "US"
};
//Act
CreatedAtRouteNegotiatedContentResult <SUPPLIER> result = supplierController.PostSUPPLIER(supplier) as CreatedAtRouteNegotiatedContentResult <SUPPLIER>;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.RouteName, "DefaultApi");
Assert.AreEqual(result.RouteValues["id"], result.Content.SUPLNO);
Assert.AreEqual(result.Content.SUPLNAME, supplier.SUPLNAME);
}
public void Pomasters_PostPomaster_ShouldReturnSamePomaster()
{
//Arrange
//Initialize();
POMASTER pOMASTER = new POMASTER {
PONO = "6", PODATE = DateTime.Now, SUPLNO = "4"
};
//Act
CreatedAtRouteNegotiatedContentResult <POMASTER> result = pomasterController.PostPOMASTER(pOMASTER) as CreatedAtRouteNegotiatedContentResult <POMASTER>;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.RouteName, "DefaultApi");
Assert.AreEqual(result.RouteValues["id"], result.Content.PONO);
Assert.AreEqual(result.Content.SUPLNO, pOMASTER.SUPLNO);
}
public void Items_PostItem_ShouldReturnSameItem()
{
//Arrange
//Initialize();
ITEM item = new ITEM {
ITCODE = "6", ITDESC = "Chair", ITRATE = 200
};
//Act
CreatedAtRouteNegotiatedContentResult <ITEM> result = itemController.PostITEM(item) as CreatedAtRouteNegotiatedContentResult <ITEM>;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.RouteName, "DefaultApi");
Assert.AreEqual(result.RouteValues["id"], result.Content.ITCODE);
Assert.AreEqual(result.Content.ITCODE, item.ITCODE);
}
public void Podetails_PostPodetail_ShouldReturnSamePodetail()
{
//Arrange
//Initialize();
PODETAIL pODETAIL = new PODETAIL {
PONO = "6", ITCODE = "2", QTY = 543
};
//Act
CreatedAtRouteNegotiatedContentResult <PODETAIL> result = podetailController.PostPODETAIL(pODETAIL) as CreatedAtRouteNegotiatedContentResult <PODETAIL>;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.RouteName, "DefaultApi");
Assert.AreEqual(result.RouteValues["id"], result.Content.PONO);
Assert.AreEqual(result.Content.ITCODE, pODETAIL.ITCODE);
}
public void AddNewRestaurant_RestaurantIsCreated()
{
// Arrange
SetupData();
var restaurant = new Restaurant
{
Id = 3,
Name = "Restaurante 3 "
};
// Act
CreatedAtRouteNegotiatedContentResult <Restaurant> result = (CreatedAtRouteNegotiatedContentResult <Restaurant>)restaurantController.PostRestaurant(restaurant);
// Assert
Assert.AreEqual(restaurant.Id, result.Content.Id);
Assert.AreEqual(restaurant.Name, result.Content.Name);
}
public void CreateDatabase_DatabaseServiceCreatesDatabase_ReturnsCreatedAtRouteResult()
{
// Arrange
string dbName = "testDatabase";
// Arrange - create target
DatabaseApiController target = new DatabaseApiController(this._dbServiceMock.Object);
// Act
IHttpActionResult actionResult = target.CreateDatabase(dbName);
CreatedAtRouteNegotiatedContentResult <string> createdResult =
actionResult as CreatedAtRouteNegotiatedContentResult <string>;
// Assert
Assert.IsNotNull(createdResult);
Assert.AreEqual("GetDatabase", createdResult.RouteName);
Assert.AreEqual(dbName, createdResult.RouteValues["dbName"]);
this._dbServiceMock.Verify(s => s.CreateDatabase(dbName), Times.Once);
}
// POST /api/category
public IHttpActionResult Post(CategoryModel category)
{
if (ModelState.IsValid)
{
try
{
Category entity = Mapper.Map <CategoryModel, Category>(category);
_categoryService.Insert(entity);
CreatedAtRouteNegotiatedContentResult <CategoryModel> response = CreatedAtRoute("DefaultApi",
new { id = category.Id }, category);
return(response);
}
catch (Exception ex)
{
HttpResponseMessage responseMessage = Request.CreateErrorResponse(HttpStatusCode.ExpectationFailed,
ex.Message);
return(ResponseMessage(responseMessage));
}
}
return(BadRequest(ModelState));
}
[TestMethod] // [4] | Delete Property
public void DeletePropertyDeleteProperty()
{
//Arrange
var propertiesController = new PropertiesController();
//act
var dbProp = new PropertyModel
{
Name = "Wonder Mansion",
Address1 = "122 Wonka Way",
Address2 = "",
City = "Golden Coast",
Zip = "23123",
State = "CA"
};
//Add 'new property to database using post'
//Save returned value as RESULT
IHttpActionResult result = propertiesController.PostProperty(dbProp);
//Cast result as Content Result so I can gathere information from the content result
CreatedAtRouteNegotiatedContentResult <PropertyModel> contentResult = (CreatedAtRouteNegotiatedContentResult <PropertyModel>)result;
//Result contains the property I had just created
result = propertiesController.GetProperty(contentResult.Content.PropertyId);
//Get PropertyModel from result
OkNegotiatedContentResult <PropertyModel> propertyResult = (OkNegotiatedContentResult <PropertyModel>)result;
//Act
result = propertiesController.DeleteProperty(contentResult.Content.PropertyId);
//Assert
//If action returns not found
Assert.IsNotInstanceOfType(result, typeof(NotFoundResult));
//If action retruns OK()
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <PropertyModel>));
}
public void CreateTable_DatabaseServiceCreatesTable_ReturnsCreatedAtRouteResult()
{
// Arrange
string dbName = "testDatabase";
TableScheme tableScheme = new TableScheme("testTable", new List <Domain.Models.Attribute>());
// Arrange - create target
DatabaseApiController target = new DatabaseApiController(this._dbServiceMock.Object);
// Act
IHttpActionResult actionResult = target.CreateTable(dbName, tableScheme);
CreatedAtRouteNegotiatedContentResult <TableScheme> createdResult =
actionResult as CreatedAtRouteNegotiatedContentResult <TableScheme>;
// Assert
Assert.IsNotNull(createdResult);
Assert.AreEqual("GetTable", createdResult.RouteName);
Assert.AreEqual(dbName, createdResult.RouteValues["dbName"]);
Assert.AreEqual(tableScheme.Name, createdResult.RouteValues["tableName"]);
this._dbServiceMock.Verify(s => s.CreateTable(dbName, tableScheme), Times.Once);
}
[TestMethod] // [4] Delete Lease
public void DeleteLeaseDeleteLease()
{
//Arrange
var lCtrl = new LeasesController();
var newLease = new LeaseModel
{
PropertyId = 1,
TenantId = 1,
StartDate = DateTime.Now,
Rent = 2000
};
//Add 'new property to database using post'
//Save returned value as RESULT
IHttpActionResult result = lCtrl.PostLease(newLease);
//Cast result as Content Result so I can gathere information from the content result
CreatedAtRouteNegotiatedContentResult <LeaseModel> contentResult = (CreatedAtRouteNegotiatedContentResult <LeaseModel>)result;
//Result contains the property I had just created
result = lCtrl.GetLease(contentResult.Content.PropertyId);
//Get PropertyModel from result
OkNegotiatedContentResult <LeaseModel> leaseResult = (OkNegotiatedContentResult <LeaseModel>)result;
//Act
result = lCtrl.DeleteLease(contentResult.Content.LeaseId);
//Assert
//If action returns not found
Assert.IsNotInstanceOfType(result, typeof(NotFoundResult));
//If action retruns OK()
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <LeaseModel>));
}
[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>));
}
