public void OnRequestAuditControllerIsNotNull() { var datafactory = new Mock <IDataFactory>(MockBehavior.Strict); var authorization = new Mock <IAuthorizationProvider>(MockBehavior.Strict); var controller = new AuditController(datafactory.Object, authorization.Object); Assert.IsNotNull(controller); }
public async Task GetAll_InvalidFrom_Todates_ReturnsBadRequest(string fromUtc, string toUtc) { var l = new Mock <ILogger <AuditController> >(); var ctrl = new AuditController(null, l.Object, null, null); var res = await ctrl.GetAll(fromUtc : fromUtc, toUtc : toUtc); res.ShouldBeOfType <BadRequestResult>(); }
public virtual void Arrange() { _mapper = new Mock <IMapper>(); ConfigureDefaultAuditMessageMapping(); _mediator = new Mock <IMediator>(); _logger = new Mock <ILogger>(); _controller = new AuditController(_mapper.Object, _mediator.Object, _logger.Object); }
public async Task GetAll_UnknownAuditRecordType_ReturnsBadRequest(string auditRecordTypes) { var l = new Mock <ILogger <AuditController> >(); var wc = new WorkContext { CurrentClientId = "1232" }; var ctrl = new AuditController(null, l.Object, wc, null); var res = await ctrl.GetAll(auditRecordTypes : auditRecordTypes); res.ShouldBeOfType <BadRequestResult>(); }
public void When_Convert_InValid_Params_Then_ReturnsNullException() { //Arrange var auditReader = A.Fake <IAuditReader>(); var sut = new AuditController(auditReader); //Assert var result = sut.GetAuditsByDate(null) as BadRequestObjectResult; Assert.NotNull(result); Assert.Equal("400", result.StatusCode.ToString()); }
public async Task Create_audit_bad_request() { //Arrange _mediatorMock.Setup(x => x.Send(It.IsAny <IdentifiedCommand <CreateAuditCommand, Result <long> > >(), default(CancellationToken))) .Returns(Task.FromResult(Result.Ok(10L))); //Act var auditController = new AuditController(_loggerMock.Object, _mediatorMock.Object); var actionResult = await auditController.CreateAuditAsync(new PublishAuditCommand(), String.Empty) as BadRequestObjectResult; //Assert Assert.AreEqual(actionResult.StatusCode, (int)System.Net.HttpStatusCode.BadRequest); }
public async Task Create_audit_with_requestId_success() { //Arrange _mediatorMock.Setup(x => x.Send(It.IsAny <IdentifiedCommand <PublishAuditCommand, Result <string> > >(), default(CancellationToken))) .Returns(Task.FromResult(Result.Ok(Constants.SuccessMessages.AuditPublishSuccess))); //Act var auditController = new AuditController(_loggerMock.Object, _mediatorMock.Object); var actionResult = await auditController.CreateAuditAsync(new PublishAuditCommand(), Guid.NewGuid().ToString()) as StatusCodeResult; //Assert Assert.AreEqual(actionResult.StatusCode, (int)System.Net.HttpStatusCode.Created); }
public void Test1Audit() { // Arrange var actionModel = new ActionAuditModel(); var mockrepo = new Mock <IAuditRepository>(); var mockhttp = new Mock <IHttpContextAccessor>(); mockrepo.Setup(serv => serv.AuditAction(actionModel)); var controller = new AuditController(mockrepo.Object, mockhttp.Object); // Act controller.Post(actionModel); }
public void PassingNullGroupidToAuditControllerResultsBadRequest() { //Mock data factory var datafactory = new Mock <IDataFactory>(MockBehavior.Strict); //Mock Authorization var authorization = new Mock <IAuthorizationProvider>(MockBehavior.Strict); var controller = new AuditController(datafactory.Object, authorization.Object); Task <IHttpActionResult> actionResult = controller.GetDataAsync(null, null); Assert.IsInstanceOfType(actionResult.Result, typeof(BadRequestResult)); }
public void PassingSomeunauthorizableGroupidToAuditControllerGetDataAsyncResultsUnauthorizedResult() { //Mock data factory var datafactory = new Mock <IDataFactory>(MockBehavior.Strict); //Mock Authorization var authorization = new Mock <IAuthorizationProvider>(MockBehavior.Strict); var controller = new AuditController(datafactory.Object, authorization.Object); authorization.Setup(m => m.IsAuthorized("1")).Returns(false); Task <IHttpActionResult> actionResult = controller.GetDataAsync("1", null); Assert.IsInstanceOfType(actionResult.Result, typeof(UnauthorizedResult)); }
public async Task Get_audit_success() { //Arrange var fakeDynamicResult = Result.Ok(new AuditDto()); _mediatorMock.Setup(x => x.Send(It.IsAny <GetAuditDetailsQuery>(), default(CancellationToken))) .Returns(Task.FromResult(fakeDynamicResult)); //Act var auditController = new AuditController(_loggerMock.Object, _mediatorMock.Object); var actionResult = await auditController.GetAuditAsync(10) as OkObjectResult; //Assert Assert.AreEqual((actionResult as OkObjectResult).StatusCode, (int)System.Net.HttpStatusCode.OK); }
public void AuditController_AuditList_JsonDataString_Invalid_Json_ShouldReturn_EmptyModel() { //----------------------------Arrange----------------------------- using (var controller = new AuditController()) { //-------------------Act--------------------------------- var result = controller.AuditList("invalidJson"); //-------------------Assert----------------------------------- Assert.IsInstanceOfType(result, typeof(ActionResult)); Assert.IsInstanceOfType(result, typeof(PartialViewResult)); var partialViewResult = (PartialViewResult)result; Assert.AreEqual("AuditList", partialViewResult.ViewName); }; }
public async Task GetAll_ReturnsPage() { var page = new AuditPagination { Data = new[] { new AuditRecord { Id = "a" }, new AuditRecord { Id = "b" }, new AuditRecord { Id = "c" }, new AuditRecord { Id = "d" }, } }; var aSrv = new Mock <IAuditManager>(); aSrv.Setup(c => c.GetAll(It.IsAny <AuditPagination>())) .ReturnsAsync(new ServiceResponse <AuditPagination> { Payload = page, Result = ServiceResult.Ok }); var l = new Mock <ILogger <AuditController> >(); var rm = new Mock <IServiceResponseMapper>(); ServiceResponse <AuditPagination> srvRes = null; rm.Setup(r => r.MapServiceResponse( It.Is <Type>(t => t == typeof(AuditPaginationModel)), It.IsAny <ServiceResponse>())) .Returns(new OkResult()) .Callback <Type, ServiceResponse>((t2, s) => srvRes = s as ServiceResponse <AuditPagination>); var wc = new WorkContext { CurrentClientId = "1232" }; var ctrl = new AuditController(aSrv.Object, l.Object, wc, rm.Object); var res = await ctrl.GetAll(auditRecordTypes : AuditRecordTypes.CREATE); srvRes.Payload.ShouldBe(page); }
private static void ProcessAudits(string auditGroupFile) { var colAudits = new AuditController(auditGroupFile); _auditTesting = new AuditTesting(colAudits.AuditGroup); // Wire up the events _auditTesting.AuditTestingStarting += _auditTesting_AuditTestingStarting; _auditTesting.CurrentAuditRunning += _auditTesting_CurrentAuditRunning; _auditTesting.CurrentAuditDone += _auditTesting_CurrentAuditDone; _auditTesting.RunAudits(); Console.WriteLine("DataAuditor ran {0} test(s).", _auditTesting.Audits.Count); // Try Unit Test Type report until the rest gets sorted out AuditUtils.SendAuditUnitTestReportEmail(colAudits.AuditGroup); Console.WriteLine("Sent results email to recipients."); }
public void Init() { var auditService = new Mock <IAuditService>(); auditService.Setup( t => t.GetChanges(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(new List <FieldChange>() { new FieldChange() { ChangeDate = DateTime.Today, ChangedBy = "MRX", ChangedValue = "XYZ", FieldName = "Name", PreviousValue = "MRY" } }); this._auditController = new AuditController(auditService.Object); }
public static List <Variance> Compare <T>(this T val1, T val2, string actiontype) { var variances = new List <Variance>(); var properties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (var property in properties) { var v = new Variance { FieldName = property.Name, OldValue = property.GetValue(val1), NewValue = property.GetValue(val2) }; if (v.OldValue == null && v.NewValue == null) { continue; } if (v.NewValue == null) { continue; } if ( (v.OldValue == null && v.NewValue != null) || (v.OldValue != null && v.NewValue == null) ) { variances.Add(v); continue; } if (!v.OldValue.Equals(v.NewValue)) { variances.Add(v); } } AuditController ac = new AuditController(); //ac.InsertAudit(variances, GetDisplayName<T>(), actiontype); return(variances); }
public void PassingCorrectGroupidToAuditControllerResultsInProcess() { //Mock Repository var repository = new Mock <IPortalRepository>(MockBehavior.Strict); //Mock data factory var datafactory = new Mock <IDataFactory>(MockBehavior.Strict); //Mock Authorization var authorization = new Mock <IAuthorizationProvider>(MockBehavior.Strict); datafactory.Setup(d => d.GetPortalRepository()).Returns(repository.Object); var controller = new AuditController(datafactory.Object, authorization.Object); authorization.Setup(m => m.IsAuthorized("11")).Returns(true); repository.Setup(x => x.GetDataLoadUploads(11, "", 1)) .ReturnsAsync(dataloads); Task <IHttpActionResult> actionResult = controller.GetDataAsync("11", "", 1); Assert.AreEqual(((OkNegotiatedContentResult <List <DataLoadUploads> >)actionResult.Result).Content.Capacity, 1); }
public void When_Convert_Valid_Params_Then_Response200OK() { //Arrange SearchInputModel input = new SearchInputModel { DateFrom = DateTime.Now, DateTo = DateTime.Now.AddMinutes(60) }; var auditReader = A.Fake <IAuditReader>(); List <Audit> audits = new List <Audit> { new Audit("Rates checked from GBP to USD", DateTime.Parse("2019-12-10T21:52:58.2858813+00:00")), new Audit("Rates checked from GBP to USD", DateTime.Parse("2019-12-10T21:58:08.7340439+00:00")) }; A.CallTo(() => auditReader.GetAuditsAsync(input.DateFrom, input.DateTo)).Returns(audits); var sut = new AuditController(auditReader); //Act var testResult = sut.GetAuditsByDate(input) as OkObjectResult;; //Assert Assert.NotNull(testResult); Assert.Equal("200", testResult.StatusCode.ToString()); }
public void AuditController_Resuming_Workflow_Does_Not_Require_Authentication_Given_allowLogIn_Is_False() { var request = new Mock <HttpRequestBase>(); var response = new Mock <HttpResponseBase>(); request.SetupGet(x => x.Headers).Returns( new WebHeaderCollection { { "X-Requested-With", "XMLHttpRequest" }, }); var context = new Mock <HttpContextBase>(); context.SetupGet(x => x.Request).Returns(request.Object); context.SetupGet(x => x.Response).Returns(response.Object); var controller = new AuditController(); controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller); controller.TempData.Add("allowLogin", false); controller.PerformResume(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()); response.VerifySet(res => res.StatusCode = 401, Times.AtLeastOnce); Assert.AreEqual(1, controller.TempData.Count); }
public void PassingInvalidGroupidToAuditControllerGetErrorDataAsyncResultsUnauthorizedResult() { //Mock Repository var repository = new Mock <IPortalRepository>(MockBehavior.Strict); //Mock data factory var datafactory = new Mock <IDataFactory>(MockBehavior.Strict); //Mock Authorization datafactory.Setup(d => d.GetPortalRepository()).Returns(repository.Object); var authorization = new Mock <IAuthorizationProvider>(MockBehavior.Strict); authorization.Setup(s => s.IsAuthorized(It.IsNotIn <string>(new List <string>() { "426" }))).Returns(false); var controller = new AuditController(datafactory.Object, authorization.Object); Task <IHttpActionResult> actionResult = controller.GetErrorDataAsync("123", ""); Assert.IsInstanceOfType(actionResult.Result, typeof(UnauthorizedResult)); }
private void LoadAuditGroup(string xmlGroup) { int nodeCount; lsvAudits.Items.Clear(); _auditController = new AuditController(xmlGroup); lblAuditGroup.Text = _auditController.AuditGroupName; foreach (Audit currItem in _auditController.AuditGroup) { var currAudit = currItem; var currViewItem = lsvAudits.Items.Add(currAudit.Name, 0); currViewItem.Tag = currAudit; currViewItem.SubItems[0].Text = currAudit.Name; currViewItem.SubItems.Add(""); currViewItem.SubItems.Add(""); } }
public void AuditController_Resuming_Workflow_Given_UnAuthorizedUser_Authentication() { //---------------------------------Arrange--------------------------------------- var url = "http://localhost:3142/secure/WorkflowResume"; var returnedExceptionMessage = "The remote server returned an error: (401) Unauthorized."; var mockContext = new Mock <HttpContextBase>(); var mockRequest = new Mock <HttpRequestBase>(); var mockWebClientFactory = new Mock <IWebClientFactory>(); var mockClientWrapper = new Mock <IWebClientWrapper>(); var tempData = new TempDataDictionary { { "allowLogin", true } }; mockRequest.SetupGet(x => x.Headers).Returns( new WebHeaderCollection { { "X-Requested-With", "XMLHttpRequest" }, { "Authorization", "Basic ZGV2MlxJbnRlcmdyYXRpb25UZXN0ZXI6STczNTczcjA=" }, }); mockContext.SetupGet(o => o.Request).Returns(mockRequest.Object); mockWebClientFactory.Setup(o => o.New(It.IsAny <string>(), It.IsAny <string>())).Returns(mockClientWrapper.Object); mockClientWrapper.Setup(o => o.UploadValues(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <NameValueCollection>())).Throws(new Exception(returnedExceptionMessage)); //---------------------------------Act------------------------------------------ using (var controller = new AuditController(mockWebClientFactory.Object)) { controller.TempData = tempData; controller.ControllerContext = new ControllerContext(mockContext.Object, new RouteData(), controller); //----------------------------Assert--------------------------------------- Assert.ThrowsException <Exception>(() => controller.PerformResume(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), url)); }; }
public AuditTests() { _service = new IDataAccessFake(); _controller = new AuditController(null, _service); }
public void Init() { _mockAuditDataProvider = new Mock <IAuditDataProvider>(); _mockMapper = new Mock <IMapper>(); auditController = new AuditController(_mockAuditDataProvider.Object, _mockMapper.Object); }
public AuditControllerTests() { _controller = new AuditController(_unitOfWork, _logger, _mapper); }