public async Task <ActionResult <Device> > PostDevice(Device device)
{
if (_Context.Devices.Where(d => d.MAC == device.MAC).ToList().Count() > 0)
{
BadRequestErrorMessageResult badRequestErrorMessageResult = new BadRequestErrorMessageResult($"This MAC address({device.MAC}) is already used");
return(BadRequest(badRequestErrorMessageResult));
}
if (Validator.MacValidate(device.MAC))
{
_Context.Devices.Add(device);
await _Context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetDevice), new { id = device.MAC }, device));
}
else
{
return(BadRequest(new BadRequestErrorMessageResult($"Bad MAC address({device.MAC})")));
}
}
public void PostInvalidPointTest()
{
PointDTO mockedPoint = this.getMockedPoints().ElementAt(0);
this.pointsAdminService.CreatePoint(Arg.Any <PointDTO>()).Returns(mockedPoint);
PointDTO point = new PointDTO()
{
Id = 1,
Name = "A"
};
IHttpActionResult actionResult = this.pointsController.Post(point);
// assertions
this.pointsAdminService.DidNotReceive().CreatePoint(point);
BadRequestErrorMessageResult badRequestMessage = actionResult as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequestMessage);
Assert.AreEqual(badRequestMessage.Message, "Point Id cannot be defined for new entity.");
}
public void ConfirmRetrieval_DoesNotExist()
{
// Arrange
var controller = new RetrievalAPIController()
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration(),
Context = context,
};
// Act
IHttpActionResult actionResult = controller.ConfirmRetrieval(new ConfirmRetrievalViewModel()
{
RetrievalId = "RETCONTROLTEST",
Email = "*****@*****.**",
});
BadRequestErrorMessageResult badRequest = actionResult as BadRequestErrorMessageResult;
// Assert
Assert.IsInstanceOfType(actionResult, typeof(BadRequestErrorMessageResult));
Assert.AreEqual("Retrieval does not exist", badRequest.Message);
}
//[TestMethod]
async public Task CreateClaimWithOutVehicleInfo()
{
var claim = new MitchellClaimType();
claim.ClaimNumber = "22c9c23bac142856018ce14a26b6c2991";
claim.ClaimantFirstName = "George";
claim.ClaimantLastName = "Washington";
claim.Status = StatusCode.OPEN;
claim.LossDate = Convert.ToDateTime("2014-07-09T17:19:13.631-07:00");
claim.LossInfo = new LossInfoType()
{
CauseOfLoss = CauseOfLossCode.Collision,
ReportedDate = Convert.ToDateTime("2014-07-10T17:19:13.676-07:00"),
LossDescription = "Crashed into an apple tree"
};
claim.AssignedAdjusterID = 23424;
var result = await controller.Post(claim);
BadRequestErrorMessageResult badRequestResult = result as BadRequestErrorMessageResult;
Assert.AreEqual("Vehicle Details not availble in input request", badRequestResult.Message);
}
//[TestMethod]
async public Task CreateClaimWithOutClaimNumber()
{
var claim = new MitchellClaimType();
claim.ClaimantFirstName = "George";
claim.ClaimantLastName = "Washington";
claim.Status = StatusCode.OPEN;
claim.LossDate = Convert.ToDateTime("2014-07-09T17:19:13.631-07:00");
claim.LossInfo = new LossInfoType()
{
CauseOfLoss = CauseOfLossCode.Collision,
ReportedDate = Convert.ToDateTime("2014-07-10T17:19:13.676-07:00"),
LossDescription = "Crashed into an apple tree"
};
claim.AssignedAdjusterID = 23424;
VehicleInfoType[] vehiclesInfo = new VehicleInfoType[1];
vehiclesInfo[0] = new VehicleInfoType()
{
Vin = "1M8GDM9AXKP042788",
ModelYear = 2015,
MakeDescription = "Ford",
ModelDescription = "Mustang",
EngineDescription = "EcoBoost",
ExteriorColor = "Deep Impact Blue",
LicPlate = "NO1PRES",
LicPlateState = "VA",
LicPlateExpDate = Convert.ToDateTime("2015-03-10-07:00"),
DamageDescription = "Front end smashed in. Apple dents in roof.",
Mileage = 1776
};
claim.Vehicles = vehiclesInfo;
var result = await controller.Post(claim);
BadRequestErrorMessageResult badRequestResult = result as BadRequestErrorMessageResult;
Assert.AreEqual("ClaimNumber is required", badRequestResult.Message);
}
public void ChangeRepresentative_NoRights_BadRequest()
{
// Arrange
var expected = "User does not have managerial rights";
var controller = new DepartmentAPIController()
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration(),
Context = context,
};
// Act
IHttpActionResult actionResult = controller.ChangeRepresentative(new ChangeRepresentativeViewModel()
{
RepresentativeEmail = "*****@*****.**",
HeadEmail = "*****@*****.**",
});
BadRequestErrorMessageResult badRequest = actionResult as BadRequestErrorMessageResult;
// Assert
Assert.IsInstanceOfType(actionResult, typeof(BadRequestErrorMessageResult));
Assert.AreEqual(expected, badRequest.Message);
}
public async Task ShouldReturnBadReQuestIfDuplicateTelemetryPosted()
{
using (new FakeHttpContext.FakeHttpContext())
{
IHttpActionResult result = await _controller.Post(_dto);
IHttpActionResult res2 = await _controller.Post(_dto2);
IHttpActionResult res3 = await _controller.Post(_dto2);
var createdResult = result as CreatedAtRouteNegotiatedContentResult <Telemetry>;
var createdResult2 = res2 as CreatedAtRouteNegotiatedContentResult <Telemetry>;
res3.ShouldBeOfType <BadRequestErrorMessageResult>();
BadRequestErrorMessageResult doubeAddResult = res3.ShouldBeOfType <BadRequestErrorMessageResult>();
createdResult.ShouldNotBeNull();
createdResult2.ShouldNotBeNull();
doubeAddResult.Message.ShouldBe("Duplicate not allowed. A lap can track a car at most once");
}
}
public void DrogueRunPosition_Controller_Post_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
DrogueRunPositionController drogueRunPositionController = new DrogueRunPositionController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(drogueRunPositionController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, drogueRunPositionController.DatabaseType);
DrogueRunPosition drogueRunPositionLast = new DrogueRunPosition();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
DrogueRunPositionService drogueRunPositionService = new DrogueRunPositionService(query, db, ContactID);
drogueRunPositionLast = (from c in db.DrogueRunPositions select c).FirstOrDefault();
}
// ok with DrogueRunPosition info
IHttpActionResult jsonRet = drogueRunPositionController.GetDrogueRunPositionWithID(drogueRunPositionLast.DrogueRunPositionID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <DrogueRunPosition> Ret = jsonRet as OkNegotiatedContentResult <DrogueRunPosition>;
DrogueRunPosition drogueRunPositionRet = Ret.Content;
Assert.AreEqual(drogueRunPositionLast.DrogueRunPositionID, drogueRunPositionRet.DrogueRunPositionID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return CSSPError because DrogueRunPositionID exist
IHttpActionResult jsonRet2 = drogueRunPositionController.Post(drogueRunPositionRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <DrogueRunPosition> drogueRunPositionRet2 = jsonRet2 as OkNegotiatedContentResult <DrogueRunPosition>;
Assert.IsNull(drogueRunPositionRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest2);
// Post to return newly added DrogueRunPosition
drogueRunPositionRet.DrogueRunPositionID = 0;
drogueRunPositionController.Request = new System.Net.Http.HttpRequestMessage();
drogueRunPositionController.Request.RequestUri = new System.Uri("http://localhost:5000/api/drogueRunPosition");
IHttpActionResult jsonRet3 = drogueRunPositionController.Post(drogueRunPositionRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <DrogueRunPosition> drogueRunPositionRet3 = jsonRet3 as CreatedNegotiatedContentResult <DrogueRunPosition>;
Assert.IsNotNull(drogueRunPositionRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
IHttpActionResult jsonRet4 = drogueRunPositionController.Delete(drogueRunPositionRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <DrogueRunPosition> drogueRunPositionRet4 = jsonRet4 as OkNegotiatedContentResult <DrogueRunPosition>;
Assert.IsNotNull(drogueRunPositionRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest4);
}
}
}
public void MWQMSubsector_Controller_Post_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
MWQMSubsectorController mwqmSubsectorController = new MWQMSubsectorController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(mwqmSubsectorController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, mwqmSubsectorController.DatabaseType);
MWQMSubsector mwqmSubsectorLast = new MWQMSubsector();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
MWQMSubsectorService mwqmSubsectorService = new MWQMSubsectorService(query, db, ContactID);
mwqmSubsectorLast = (from c in db.MWQMSubsectors select c).FirstOrDefault();
}
// ok with MWQMSubsector info
IHttpActionResult jsonRet = mwqmSubsectorController.GetMWQMSubsectorWithID(mwqmSubsectorLast.MWQMSubsectorID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <MWQMSubsector> Ret = jsonRet as OkNegotiatedContentResult <MWQMSubsector>;
MWQMSubsector mwqmSubsectorRet = Ret.Content;
Assert.AreEqual(mwqmSubsectorLast.MWQMSubsectorID, mwqmSubsectorRet.MWQMSubsectorID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return CSSPError because MWQMSubsectorID exist
IHttpActionResult jsonRet2 = mwqmSubsectorController.Post(mwqmSubsectorRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <MWQMSubsector> mwqmSubsectorRet2 = jsonRet2 as OkNegotiatedContentResult <MWQMSubsector>;
Assert.IsNull(mwqmSubsectorRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest2);
// Post to return newly added MWQMSubsector
mwqmSubsectorRet.MWQMSubsectorID = 0;
mwqmSubsectorController.Request = new System.Net.Http.HttpRequestMessage();
mwqmSubsectorController.Request.RequestUri = new System.Uri("http://localhost:5000/api/mwqmSubsector");
IHttpActionResult jsonRet3 = mwqmSubsectorController.Post(mwqmSubsectorRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <MWQMSubsector> mwqmSubsectorRet3 = jsonRet3 as CreatedNegotiatedContentResult <MWQMSubsector>;
Assert.IsNotNull(mwqmSubsectorRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
IHttpActionResult jsonRet4 = mwqmSubsectorController.Delete(mwqmSubsectorRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <MWQMSubsector> mwqmSubsectorRet4 = jsonRet4 as OkNegotiatedContentResult <MWQMSubsector>;
Assert.IsNotNull(mwqmSubsectorRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest4);
}
}
}
public void SamplingPlan_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
SamplingPlanController samplingPlanController = new SamplingPlanController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(samplingPlanController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, samplingPlanController.DatabaseType);
SamplingPlan samplingPlanLast = new SamplingPlan();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
SamplingPlanService samplingPlanService = new SamplingPlanService(query, db, ContactID);
samplingPlanLast = (from c in db.SamplingPlans select c).FirstOrDefault();
}
// ok with SamplingPlan info
IHttpActionResult jsonRet = samplingPlanController.GetSamplingPlanWithID(samplingPlanLast.SamplingPlanID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <SamplingPlan> Ret = jsonRet as OkNegotiatedContentResult <SamplingPlan>;
SamplingPlan samplingPlanRet = Ret.Content;
Assert.AreEqual(samplingPlanLast.SamplingPlanID, samplingPlanRet.SamplingPlanID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added SamplingPlan
samplingPlanRet.SamplingPlanID = 0;
samplingPlanRet.SamplingPlanName = samplingPlanRet.SamplingPlanName.Replace(".txt", "_a.txt");
samplingPlanController.Request = new System.Net.Http.HttpRequestMessage();
samplingPlanController.Request.RequestUri = new System.Uri("http://localhost:5000/api/samplingPlan");
IHttpActionResult jsonRet3 = samplingPlanController.Post(samplingPlanRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <SamplingPlan> samplingPlanRet3 = jsonRet3 as CreatedNegotiatedContentResult <SamplingPlan>;
Assert.IsNotNull(samplingPlanRet3);
SamplingPlan samplingPlan = samplingPlanRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = samplingPlanController.Delete(samplingPlanRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <SamplingPlan> samplingPlanRet2 = jsonRet2 as OkNegotiatedContentResult <SamplingPlan>;
Assert.IsNotNull(samplingPlanRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because SamplingPlanID of 0 does not exist
samplingPlanRet.SamplingPlanID = 0;
IHttpActionResult jsonRet4 = samplingPlanController.Delete(samplingPlanRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <SamplingPlan> samplingPlanRet4 = jsonRet4 as OkNegotiatedContentResult <SamplingPlan>;
Assert.IsNull(samplingPlanRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void LabSheetDetail_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
LabSheetDetailController labSheetDetailController = new LabSheetDetailController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(labSheetDetailController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, labSheetDetailController.DatabaseType);
LabSheetDetail labSheetDetailLast = new LabSheetDetail();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
LabSheetDetailService labSheetDetailService = new LabSheetDetailService(query, db, ContactID);
labSheetDetailLast = (from c in db.LabSheetDetails select c).FirstOrDefault();
}
// ok with LabSheetDetail info
IHttpActionResult jsonRet = labSheetDetailController.GetLabSheetDetailWithID(labSheetDetailLast.LabSheetDetailID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <LabSheetDetail> Ret = jsonRet as OkNegotiatedContentResult <LabSheetDetail>;
LabSheetDetail labSheetDetailRet = Ret.Content;
Assert.AreEqual(labSheetDetailLast.LabSheetDetailID, labSheetDetailRet.LabSheetDetailID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added LabSheetDetail
labSheetDetailRet.LabSheetDetailID = 0;
labSheetDetailController.Request = new System.Net.Http.HttpRequestMessage();
labSheetDetailController.Request.RequestUri = new System.Uri("http://localhost:5000/api/labSheetDetail");
IHttpActionResult jsonRet3 = labSheetDetailController.Post(labSheetDetailRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <LabSheetDetail> labSheetDetailRet3 = jsonRet3 as CreatedNegotiatedContentResult <LabSheetDetail>;
Assert.IsNotNull(labSheetDetailRet3);
LabSheetDetail labSheetDetail = labSheetDetailRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = labSheetDetailController.Delete(labSheetDetailRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <LabSheetDetail> labSheetDetailRet2 = jsonRet2 as OkNegotiatedContentResult <LabSheetDetail>;
Assert.IsNotNull(labSheetDetailRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because LabSheetDetailID of 0 does not exist
labSheetDetailRet.LabSheetDetailID = 0;
IHttpActionResult jsonRet4 = labSheetDetailController.Delete(labSheetDetailRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <LabSheetDetail> labSheetDetailRet4 = jsonRet4 as OkNegotiatedContentResult <LabSheetDetail>;
Assert.IsNull(labSheetDetailRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void HelpDoc_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
HelpDocController helpDocController = new HelpDocController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(helpDocController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, helpDocController.DatabaseType);
HelpDoc helpDocLast = new HelpDoc();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
HelpDocService helpDocService = new HelpDocService(query, db, ContactID);
helpDocLast = (from c in db.HelpDocs select c).FirstOrDefault();
}
// ok with HelpDoc info
IHttpActionResult jsonRet = helpDocController.GetHelpDocWithID(helpDocLast.HelpDocID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <HelpDoc> Ret = jsonRet as OkNegotiatedContentResult <HelpDoc>;
HelpDoc helpDocRet = Ret.Content;
Assert.AreEqual(helpDocLast.HelpDocID, helpDocRet.HelpDocID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added HelpDoc
helpDocRet.HelpDocID = 0;
helpDocController.Request = new System.Net.Http.HttpRequestMessage();
helpDocController.Request.RequestUri = new System.Uri("http://localhost:5000/api/helpDoc");
IHttpActionResult jsonRet3 = helpDocController.Post(helpDocRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <HelpDoc> helpDocRet3 = jsonRet3 as CreatedNegotiatedContentResult <HelpDoc>;
Assert.IsNotNull(helpDocRet3);
HelpDoc helpDoc = helpDocRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = helpDocController.Delete(helpDocRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <HelpDoc> helpDocRet2 = jsonRet2 as OkNegotiatedContentResult <HelpDoc>;
Assert.IsNotNull(helpDocRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because HelpDocID of 0 does not exist
helpDocRet.HelpDocID = 0;
IHttpActionResult jsonRet4 = helpDocController.Delete(helpDocRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <HelpDoc> helpDocRet4 = jsonRet4 as OkNegotiatedContentResult <HelpDoc>;
Assert.IsNull(helpDocRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void EmailDistributionListContact_Controller_Post_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
EmailDistributionListContactController emailDistributionListContactController = new EmailDistributionListContactController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(emailDistributionListContactController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, emailDistributionListContactController.DatabaseType);
EmailDistributionListContact emailDistributionListContactLast = new EmailDistributionListContact();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
EmailDistributionListContactService emailDistributionListContactService = new EmailDistributionListContactService(query, db, ContactID);
emailDistributionListContactLast = (from c in db.EmailDistributionListContacts select c).FirstOrDefault();
}
// ok with EmailDistributionListContact info
IHttpActionResult jsonRet = emailDistributionListContactController.GetEmailDistributionListContactWithID(emailDistributionListContactLast.EmailDistributionListContactID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <EmailDistributionListContact> Ret = jsonRet as OkNegotiatedContentResult <EmailDistributionListContact>;
EmailDistributionListContact emailDistributionListContactRet = Ret.Content;
Assert.AreEqual(emailDistributionListContactLast.EmailDistributionListContactID, emailDistributionListContactRet.EmailDistributionListContactID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return CSSPError because EmailDistributionListContactID exist
IHttpActionResult jsonRet2 = emailDistributionListContactController.Post(emailDistributionListContactRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <EmailDistributionListContact> emailDistributionListContactRet2 = jsonRet2 as OkNegotiatedContentResult <EmailDistributionListContact>;
Assert.IsNull(emailDistributionListContactRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest2);
// Post to return newly added EmailDistributionListContact
emailDistributionListContactRet.EmailDistributionListContactID = 0;
emailDistributionListContactController.Request = new System.Net.Http.HttpRequestMessage();
emailDistributionListContactController.Request.RequestUri = new System.Uri("http://localhost:5000/api/emailDistributionListContact");
IHttpActionResult jsonRet3 = emailDistributionListContactController.Post(emailDistributionListContactRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <EmailDistributionListContact> emailDistributionListContactRet3 = jsonRet3 as CreatedNegotiatedContentResult <EmailDistributionListContact>;
Assert.IsNotNull(emailDistributionListContactRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
IHttpActionResult jsonRet4 = emailDistributionListContactController.Delete(emailDistributionListContactRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <EmailDistributionListContact> emailDistributionListContactRet4 = jsonRet4 as OkNegotiatedContentResult <EmailDistributionListContact>;
Assert.IsNotNull(emailDistributionListContactRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest4);
}
}
}
public void BoxModelResult_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
BoxModelResultController boxModelResultController = new BoxModelResultController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(boxModelResultController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, boxModelResultController.DatabaseType);
BoxModelResult boxModelResultLast = new BoxModelResult();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
BoxModelResultService boxModelResultService = new BoxModelResultService(query, db, ContactID);
boxModelResultLast = (from c in db.BoxModelResults select c).FirstOrDefault();
}
// ok with BoxModelResult info
IHttpActionResult jsonRet = boxModelResultController.GetBoxModelResultWithID(boxModelResultLast.BoxModelResultID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <BoxModelResult> Ret = jsonRet as OkNegotiatedContentResult <BoxModelResult>;
BoxModelResult boxModelResultRet = Ret.Content;
Assert.AreEqual(boxModelResultLast.BoxModelResultID, boxModelResultRet.BoxModelResultID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added BoxModelResult
boxModelResultRet.BoxModelResultID = 0;
boxModelResultController.Request = new System.Net.Http.HttpRequestMessage();
boxModelResultController.Request.RequestUri = new System.Uri("http://localhost:5000/api/boxModelResult");
IHttpActionResult jsonRet3 = boxModelResultController.Post(boxModelResultRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <BoxModelResult> boxModelResultRet3 = jsonRet3 as CreatedNegotiatedContentResult <BoxModelResult>;
Assert.IsNotNull(boxModelResultRet3);
BoxModelResult boxModelResult = boxModelResultRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = boxModelResultController.Delete(boxModelResultRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <BoxModelResult> boxModelResultRet2 = jsonRet2 as OkNegotiatedContentResult <BoxModelResult>;
Assert.IsNotNull(boxModelResultRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because BoxModelResultID of 0 does not exist
boxModelResultRet.BoxModelResultID = 0;
IHttpActionResult jsonRet4 = boxModelResultController.Delete(boxModelResultRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <BoxModelResult> boxModelResultRet4 = jsonRet4 as OkNegotiatedContentResult <BoxModelResult>;
Assert.IsNull(boxModelResultRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void TVItemLanguage_Controller_Post_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TVItemLanguageController tvItemLanguageController = new TVItemLanguageController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tvItemLanguageController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tvItemLanguageController.DatabaseType);
TVItemLanguage tvItemLanguageLast = new TVItemLanguage();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
TVItemLanguageService tvItemLanguageService = new TVItemLanguageService(query, db, ContactID);
tvItemLanguageLast = (from c in db.TVItemLanguages select c).FirstOrDefault();
}
// ok with TVItemLanguage info
IHttpActionResult jsonRet = tvItemLanguageController.GetTVItemLanguageWithID(tvItemLanguageLast.TVItemLanguageID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TVItemLanguage> Ret = jsonRet as OkNegotiatedContentResult <TVItemLanguage>;
TVItemLanguage tvItemLanguageRet = Ret.Content;
Assert.AreEqual(tvItemLanguageLast.TVItemLanguageID, tvItemLanguageRet.TVItemLanguageID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return CSSPError because TVItemLanguageID exist
IHttpActionResult jsonRet2 = tvItemLanguageController.Post(tvItemLanguageRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TVItemLanguage> tvItemLanguageRet2 = jsonRet2 as OkNegotiatedContentResult <TVItemLanguage>;
Assert.IsNull(tvItemLanguageRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest2);
// Post to return newly added TVItemLanguage
tvItemLanguageRet.TVItemLanguageID = 0;
tvItemLanguageController.Request = new System.Net.Http.HttpRequestMessage();
tvItemLanguageController.Request.RequestUri = new System.Uri("http://localhost:5000/api/tvItemLanguage");
IHttpActionResult jsonRet3 = tvItemLanguageController.Post(tvItemLanguageRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <TVItemLanguage> tvItemLanguageRet3 = jsonRet3 as CreatedNegotiatedContentResult <TVItemLanguage>;
Assert.IsNotNull(tvItemLanguageRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
IHttpActionResult jsonRet4 = tvItemLanguageController.Delete(tvItemLanguageRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <TVItemLanguage> tvItemLanguageRet4 = jsonRet4 as OkNegotiatedContentResult <TVItemLanguage>;
Assert.IsNotNull(tvItemLanguageRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest4);
}
}
}
public void LogoutSuccessfulThenFailTest_ChecksThatUserLogsInThenLogsOutAndThenTriesTologoutAgainUsingTheSameApiKeyThenExceptionShouldBeThrown_VerifiesAndAssertsTheReturnedValueAndQueriesDatabase()
{
// Register User
RegistrationController registrationController = (RegistrationController)_applicationContext["RegistrationController"];
IHttpActionResult httpActionResult = registrationController.Register(new SignUpParam("*****@*****.**", "user", "123", "Pakistan",
TimeZone.CurrentTimeZone, ""));
OkNegotiatedContentResult <string> okResponseMessage =
(OkNegotiatedContentResult <string>)httpActionResult;
string activationKey = okResponseMessage.Content;
Assert.IsNotNullOrEmpty(activationKey);
// Activate Account
UserController userController = (UserController)_applicationContext["UserController"];
httpActionResult = userController.ActivateUser(new UserActivationParam("user", "123", activationKey));
OkNegotiatedContentResult <string> okResponseMessage1 =
(OkNegotiatedContentResult <string>)httpActionResult;
Assert.AreEqual(okResponseMessage1.Content, "activated");
// Login
LoginController loginController = (LoginController)_applicationContext["LoginController"];
httpActionResult = loginController.Login(new LoginParams("user", "123"));
OkNegotiatedContentResult <UserValidationEssentials> keys =
(OkNegotiatedContentResult <UserValidationEssentials>)httpActionResult;
Assert.IsNotNullOrEmpty(keys.Content.ApiKey);
Assert.IsNotNullOrEmpty(keys.Content.SecretKey);
Assert.IsNotNullOrEmpty(keys.Content.SessionLogoutTime.ToString());
// Verify that Security Keys are in the database
ISecurityKeysRepository securityKeysRepository = (ISecurityKeysRepository)_applicationContext["SecurityKeysPairRepository"];
SecurityKeysPair securityKeysPair = securityKeysRepository.GetByApiKey(keys.Content.ApiKey);
Assert.IsNotNull(securityKeysPair);
Assert.AreEqual(keys.Content.SecretKey, securityKeysPair.SecretKey);
Assert.IsTrue(securityKeysPair.SystemGenerated);
// Logout
LogoutController logoutController = (LogoutController)_applicationContext["LogoutController"];
logoutController.Request = new HttpRequestMessage(HttpMethod.Post, "");
logoutController.Request.Headers.Add("Auth", keys.Content.ApiKey);
IHttpActionResult logoutResult = logoutController.Logout();
OkNegotiatedContentResult <bool> logoutOkResponse = (OkNegotiatedContentResult <bool>)logoutResult;
Assert.IsNotNull(logoutOkResponse);
Assert.IsTrue(logoutOkResponse.Content);
// Verify that the Security Keys are not in the database
securityKeysPair = securityKeysRepository.GetByApiKey(keys.Content.ApiKey);
Assert.IsNull(securityKeysPair);
logoutController.Request = new HttpRequestMessage(HttpMethod.Post, "");
logoutController.Request.Headers.Add("Auth", keys.Content.ApiKey);
// Invalid Logout as the user has logged out already
logoutResult = logoutController.Logout();
BadRequestErrorMessageResult logoutBadResponse = (BadRequestErrorMessageResult)logoutResult;
Assert.IsNotNull(logoutBadResponse);
// Verify that the Security Keys are not in the database
securityKeysPair = securityKeysRepository.GetByApiKey(keys.Content.ApiKey);
Assert.IsNull(securityKeysPair);
}
public void VPScenario_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
VPScenarioController vpScenarioController = new VPScenarioController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(vpScenarioController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, vpScenarioController.DatabaseType);
VPScenario vpScenarioLast = new VPScenario();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
VPScenarioService vpScenarioService = new VPScenarioService(query, db, ContactID);
vpScenarioLast = (from c in db.VPScenarios select c).FirstOrDefault();
}
// ok with VPScenario info
IHttpActionResult jsonRet = vpScenarioController.GetVPScenarioWithID(vpScenarioLast.VPScenarioID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <VPScenario> Ret = jsonRet as OkNegotiatedContentResult <VPScenario>;
VPScenario vpScenarioRet = Ret.Content;
Assert.AreEqual(vpScenarioLast.VPScenarioID, vpScenarioRet.VPScenarioID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added VPScenario
vpScenarioRet.VPScenarioID = 0;
vpScenarioController.Request = new System.Net.Http.HttpRequestMessage();
vpScenarioController.Request.RequestUri = new System.Uri("http://localhost:5000/api/vpScenario");
IHttpActionResult jsonRet3 = vpScenarioController.Post(vpScenarioRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <VPScenario> vpScenarioRet3 = jsonRet3 as CreatedNegotiatedContentResult <VPScenario>;
Assert.IsNotNull(vpScenarioRet3);
VPScenario vpScenario = vpScenarioRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = vpScenarioController.Delete(vpScenarioRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <VPScenario> vpScenarioRet2 = jsonRet2 as OkNegotiatedContentResult <VPScenario>;
Assert.IsNotNull(vpScenarioRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because VPScenarioID of 0 does not exist
vpScenarioRet.VPScenarioID = 0;
IHttpActionResult jsonRet4 = vpScenarioController.Delete(vpScenarioRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <VPScenario> vpScenarioRet4 = jsonRet4 as OkNegotiatedContentResult <VPScenario>;
Assert.IsNull(vpScenarioRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void PolSourceSiteEffectTerm_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
PolSourceSiteEffectTermController polSourceSiteEffectTermController = new PolSourceSiteEffectTermController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(polSourceSiteEffectTermController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, polSourceSiteEffectTermController.DatabaseType);
PolSourceSiteEffectTerm polSourceSiteEffectTermLast = new PolSourceSiteEffectTerm();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
PolSourceSiteEffectTermService polSourceSiteEffectTermService = new PolSourceSiteEffectTermService(query, db, ContactID);
polSourceSiteEffectTermLast = (from c in db.PolSourceSiteEffectTerms select c).FirstOrDefault();
}
// ok with PolSourceSiteEffectTerm info
IHttpActionResult jsonRet = polSourceSiteEffectTermController.GetPolSourceSiteEffectTermWithID(polSourceSiteEffectTermLast.PolSourceSiteEffectTermID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <PolSourceSiteEffectTerm> Ret = jsonRet as OkNegotiatedContentResult <PolSourceSiteEffectTerm>;
PolSourceSiteEffectTerm polSourceSiteEffectTermRet = Ret.Content;
Assert.AreEqual(polSourceSiteEffectTermLast.PolSourceSiteEffectTermID, polSourceSiteEffectTermRet.PolSourceSiteEffectTermID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added PolSourceSiteEffectTerm
polSourceSiteEffectTermRet.PolSourceSiteEffectTermID = 0;
polSourceSiteEffectTermController.Request = new System.Net.Http.HttpRequestMessage();
polSourceSiteEffectTermController.Request.RequestUri = new System.Uri("http://localhost:5000/api/polSourceSiteEffectTerm");
IHttpActionResult jsonRet3 = polSourceSiteEffectTermController.Post(polSourceSiteEffectTermRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <PolSourceSiteEffectTerm> polSourceSiteEffectTermRet3 = jsonRet3 as CreatedNegotiatedContentResult <PolSourceSiteEffectTerm>;
Assert.IsNotNull(polSourceSiteEffectTermRet3);
PolSourceSiteEffectTerm polSourceSiteEffectTerm = polSourceSiteEffectTermRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = polSourceSiteEffectTermController.Delete(polSourceSiteEffectTermRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <PolSourceSiteEffectTerm> polSourceSiteEffectTermRet2 = jsonRet2 as OkNegotiatedContentResult <PolSourceSiteEffectTerm>;
Assert.IsNotNull(polSourceSiteEffectTermRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because PolSourceSiteEffectTermID of 0 does not exist
polSourceSiteEffectTermRet.PolSourceSiteEffectTermID = 0;
IHttpActionResult jsonRet4 = polSourceSiteEffectTermController.Delete(polSourceSiteEffectTermRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <PolSourceSiteEffectTerm> polSourceSiteEffectTermRet4 = jsonRet4 as OkNegotiatedContentResult <PolSourceSiteEffectTerm>;
Assert.IsNull(polSourceSiteEffectTermRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void Get_ConfirmEmail_Should_Return_BadRequest()
{
//Action
GenerateData("1", new[] { "NoRoles" });
RegisterController registerController = new RegisterController(userService.Object,
tokenValidation.Object,
incUserMapper.Object,
mesService.Object);
//Arrange
int userId = 1;
string code = "test";
var actual = registerController.ConfirmEmail(userId, code);
var badRequestResult = new BadRequestErrorMessageResult("Invalid data", registerController);
//Assert
Assert.IsNotNull(actual);
Assert.AreEqual(actual.GetType(), badRequestResult.GetType());
}
public void ValidateDiffWithSideMissing(BadRequestErrorMessageResult diffResult)
{
Assert.IsNotNull(diffResult);
Assert.IsTrue(diffResult.Message.Contains("There is a side data missing, please provide the left and right data in the record ID"));
}
public void AppTask_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
AppTaskController appTaskController = new AppTaskController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(appTaskController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, appTaskController.DatabaseType);
AppTask appTaskLast = new AppTask();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
AppTaskService appTaskService = new AppTaskService(query, db, ContactID);
appTaskLast = (from c in db.AppTasks select c).FirstOrDefault();
}
// ok with AppTask info
IHttpActionResult jsonRet = appTaskController.GetAppTaskWithID(appTaskLast.AppTaskID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <AppTask> Ret = jsonRet as OkNegotiatedContentResult <AppTask>;
AppTask appTaskRet = Ret.Content;
Assert.AreEqual(appTaskLast.AppTaskID, appTaskRet.AppTaskID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added AppTask
appTaskRet.AppTaskID = 0;
appTaskController.Request = new System.Net.Http.HttpRequestMessage();
appTaskController.Request.RequestUri = new System.Uri("http://localhost:5000/api/appTask");
IHttpActionResult jsonRet3 = appTaskController.Post(appTaskRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <AppTask> appTaskRet3 = jsonRet3 as CreatedNegotiatedContentResult <AppTask>;
Assert.IsNotNull(appTaskRet3);
AppTask appTask = appTaskRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = appTaskController.Delete(appTaskRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <AppTask> appTaskRet2 = jsonRet2 as OkNegotiatedContentResult <AppTask>;
Assert.IsNotNull(appTaskRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because AppTaskID of 0 does not exist
appTaskRet.AppTaskID = 0;
IHttpActionResult jsonRet4 = appTaskController.Delete(appTaskRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <AppTask> appTaskRet4 = jsonRet4 as OkNegotiatedContentResult <AppTask>;
Assert.IsNull(appTaskRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void ResetPassword_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ResetPasswordController resetPasswordController = new ResetPasswordController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(resetPasswordController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, resetPasswordController.DatabaseType);
ResetPassword resetPasswordLast = new ResetPassword();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
ResetPasswordService resetPasswordService = new ResetPasswordService(query, db, ContactID);
resetPasswordLast = (from c in db.ResetPasswords select c).FirstOrDefault();
}
// ok with ResetPassword info
IHttpActionResult jsonRet = resetPasswordController.GetResetPasswordWithID(resetPasswordLast.ResetPasswordID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <ResetPassword> Ret = jsonRet as OkNegotiatedContentResult <ResetPassword>;
ResetPassword resetPasswordRet = Ret.Content;
Assert.AreEqual(resetPasswordLast.ResetPasswordID, resetPasswordRet.ResetPasswordID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added ResetPassword
resetPasswordRet.ResetPasswordID = 0;
resetPasswordController.Request = new System.Net.Http.HttpRequestMessage();
resetPasswordController.Request.RequestUri = new System.Uri("http://localhost:5000/api/resetPassword");
IHttpActionResult jsonRet3 = resetPasswordController.Post(resetPasswordRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <ResetPassword> resetPasswordRet3 = jsonRet3 as CreatedNegotiatedContentResult <ResetPassword>;
Assert.IsNotNull(resetPasswordRet3);
ResetPassword resetPassword = resetPasswordRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = resetPasswordController.Delete(resetPasswordRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <ResetPassword> resetPasswordRet2 = jsonRet2 as OkNegotiatedContentResult <ResetPassword>;
Assert.IsNotNull(resetPasswordRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because ResetPasswordID of 0 does not exist
resetPasswordRet.ResetPasswordID = 0;
IHttpActionResult jsonRet4 = resetPasswordController.Delete(resetPasswordRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <ResetPassword> resetPasswordRet4 = jsonRet4 as OkNegotiatedContentResult <ResetPassword>;
Assert.IsNull(resetPasswordRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void ClimateDataValue_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ClimateDataValueController climateDataValueController = new ClimateDataValueController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(climateDataValueController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, climateDataValueController.DatabaseType);
ClimateDataValue climateDataValueLast = new ClimateDataValue();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
ClimateDataValueService climateDataValueService = new ClimateDataValueService(query, db, ContactID);
climateDataValueLast = (from c in db.ClimateDataValues select c).FirstOrDefault();
}
// ok with ClimateDataValue info
IHttpActionResult jsonRet = climateDataValueController.GetClimateDataValueWithID(climateDataValueLast.ClimateDataValueID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <ClimateDataValue> Ret = jsonRet as OkNegotiatedContentResult <ClimateDataValue>;
ClimateDataValue climateDataValueRet = Ret.Content;
Assert.AreEqual(climateDataValueLast.ClimateDataValueID, climateDataValueRet.ClimateDataValueID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added ClimateDataValue
climateDataValueRet.ClimateDataValueID = 0;
climateDataValueController.Request = new System.Net.Http.HttpRequestMessage();
climateDataValueController.Request.RequestUri = new System.Uri("http://localhost:5000/api/climateDataValue");
IHttpActionResult jsonRet3 = climateDataValueController.Post(climateDataValueRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <ClimateDataValue> climateDataValueRet3 = jsonRet3 as CreatedNegotiatedContentResult <ClimateDataValue>;
Assert.IsNotNull(climateDataValueRet3);
ClimateDataValue climateDataValue = climateDataValueRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = climateDataValueController.Delete(climateDataValueRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <ClimateDataValue> climateDataValueRet2 = jsonRet2 as OkNegotiatedContentResult <ClimateDataValue>;
Assert.IsNotNull(climateDataValueRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because ClimateDataValueID of 0 does not exist
climateDataValueRet.ClimateDataValueID = 0;
IHttpActionResult jsonRet4 = climateDataValueController.Delete(climateDataValueRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <ClimateDataValue> climateDataValueRet4 = jsonRet4 as OkNegotiatedContentResult <ClimateDataValue>;
Assert.IsNull(climateDataValueRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void ConfirmRetrieval_AlreadyConfirmed_BadRequest()
{
// Arrange
var requisitionRepository = new RequisitionRepository(context);
var departmentRepository = new DepartmentRepository(context);
var requisition = requisitionRepository.Save(new Requisition()
{
RequisitionId = "RETCONTROLTEST",
CollectionPoint = departmentRepository.FindById("ENGL").CollectionPoint,
Department = departmentRepository.FindById("ENGL"),
CreatedDateTime = DateTime.Now,
RequisitionDetails = new List <RequisitionDetail>()
{
new RequisitionDetail()
{
RequisitionId = "RETCONTROLTEST",
ItemCode = "E030",
Item = new ItemService(context).FindItemByItemCode("E030"),
Quantity = 30,
}
}
});
var retrieval = retrievalRepository.Save(new Retrieval()
{
RetrievalId = "RETCONTROLTEST",
Requisitions = new List <Requisition>()
{
requisition
},
CreatedDateTime = DateTime.Now,
Status = new StatusService(context).FindStatusByStatusId(20),
});
var disbursement = disbursementRepository.Save(new Disbursement()
{
DisbursementId = "RETCONTROLTEST",
Department = departmentRepository.FindById("ENGL"),
DisbursementDetails = new List <DisbursementDetail>()
{
new DisbursementDetail()
{
DisbursementId = "RETCONTROLTEST",
ItemCode = "E030",
Item = new ItemService(context).FindItemByItemCode("E030"),
PlanQuantity = 30,
ActualQuantity = 30,
Status = new StatusService(context).FindStatusByStatusId(18),
}
},
Retrieval = retrieval,
Status = new StatusService(context).FindStatusByStatusId(7),
CreatedDateTime = DateTime.Now,
});
var expectedStatus = new StatusService(context).FindStatusByStatusId(20);
var controller = new RetrievalAPIController()
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration(),
Context = context,
};
// Act
IHttpActionResult actionResult = controller.ConfirmRetrieval(new ConfirmRetrievalViewModel()
{
RetrievalId = "RETCONTROLTEST",
Email = "*****@*****.**",
});
BadRequestErrorMessageResult badRequest = actionResult as BadRequestErrorMessageResult;
// Assert
Assert.IsInstanceOfType(actionResult, typeof(BadRequestErrorMessageResult));
Assert.AreEqual("Retrieval already confirmed", badRequest.Message);
}
public void MikeBoundaryCondition_Controller_Delete_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
MikeBoundaryConditionController mikeBoundaryConditionController = new MikeBoundaryConditionController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(mikeBoundaryConditionController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, mikeBoundaryConditionController.DatabaseType);
MikeBoundaryCondition mikeBoundaryConditionLast = new MikeBoundaryCondition();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
MikeBoundaryConditionService mikeBoundaryConditionService = new MikeBoundaryConditionService(query, db, ContactID);
mikeBoundaryConditionLast = (from c in db.MikeBoundaryConditions select c).FirstOrDefault();
}
// ok with MikeBoundaryCondition info
IHttpActionResult jsonRet = mikeBoundaryConditionController.GetMikeBoundaryConditionWithID(mikeBoundaryConditionLast.MikeBoundaryConditionID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <MikeBoundaryCondition> Ret = jsonRet as OkNegotiatedContentResult <MikeBoundaryCondition>;
MikeBoundaryCondition mikeBoundaryConditionRet = Ret.Content;
Assert.AreEqual(mikeBoundaryConditionLast.MikeBoundaryConditionID, mikeBoundaryConditionRet.MikeBoundaryConditionID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return newly added MikeBoundaryCondition
mikeBoundaryConditionRet.MikeBoundaryConditionID = 0;
mikeBoundaryConditionController.Request = new System.Net.Http.HttpRequestMessage();
mikeBoundaryConditionController.Request.RequestUri = new System.Uri("http://localhost:5000/api/mikeBoundaryCondition");
IHttpActionResult jsonRet3 = mikeBoundaryConditionController.Post(mikeBoundaryConditionRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <MikeBoundaryCondition> mikeBoundaryConditionRet3 = jsonRet3 as CreatedNegotiatedContentResult <MikeBoundaryCondition>;
Assert.IsNotNull(mikeBoundaryConditionRet3);
MikeBoundaryCondition mikeBoundaryCondition = mikeBoundaryConditionRet3.Content;
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
// Delete to return success
IHttpActionResult jsonRet2 = mikeBoundaryConditionController.Delete(mikeBoundaryConditionRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <MikeBoundaryCondition> mikeBoundaryConditionRet2 = jsonRet2 as OkNegotiatedContentResult <MikeBoundaryCondition>;
Assert.IsNotNull(mikeBoundaryConditionRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Delete to return CSSPError because MikeBoundaryConditionID of 0 does not exist
mikeBoundaryConditionRet.MikeBoundaryConditionID = 0;
IHttpActionResult jsonRet4 = mikeBoundaryConditionController.Delete(mikeBoundaryConditionRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <MikeBoundaryCondition> mikeBoundaryConditionRet4 = jsonRet4 as OkNegotiatedContentResult <MikeBoundaryCondition>;
Assert.IsNull(mikeBoundaryConditionRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest4);
}
}
}
public void ValidateNullContentResult(BadRequestErrorMessageResult contentResult)
{
Assert.IsNotNull(contentResult);
Assert.AreEqual(contentResult.Message, "Please provide a JSON base64 encoded binary data");
}
