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);
}
