public async Task Must_Create_Template_Object()
{
var templateRepositoryMock = new Mock <ITemplateRepository>();
var template = new TemplateViewModel
{
TemplateBody = "Areva",
TemplateDescription = "Templates Descriptions",
TemplateName = "Template Name",
TemplateVariables = "Templates Variables"
};
// Arrange
templateRepositoryMock.Setup(x => x.InsertAsync(It.IsAny <Template>())).Returns(Task.FromResult <TemplateViewModel>(template));
var templateController = new TemplatesController(templateRepositoryMock.Object);
// Act
var result = await templateController.Post(template);
// Assert
Assert.NotNull(result);
var createdResult = result as CreatedResult;
Assert.NotNull(createdResult);
Assert.Equal(201, createdResult.StatusCode);
}
private Item ShowPopup(Department department)
{
Item textBoxItem = new Item("Department: ", department.Name);
Item trueFalseItem = new Item("Active: ", department.IsActive.ToString());
Item result = TemplatesController.ShowOneTextBoxTrueFalseForm(textBoxItem, trueFalseItem,
this.view.ParentControl);
return(result);
}
private Item ShowPopup(Item item)
{
Item textBoxItem = new Item("Group Name: ", item.Value);
Item trueFalseItem = new Item("Active: ", item.IsActive.ToString());
Item result = TemplatesController.ShowOneTextBoxTrueFalseForm(textBoxItem, trueFalseItem,
this.view.ParentControl);
return(result);
}
public void SetUp()
{
ServiceLocatorInitializer.Init();
templateManagementService =
MockRepository.GenerateMock <ITemplateManagementService>();
templatesController =
new TemplatesController(templateManagementService);
}
private Item ShowPopup()
{
Item textBoxItem = new Item("Item Value: ", this.selectedItem.Text);
Item trueFalseItem = new Item("Active: ", this.selectedItem.IsActive.ToString());
Item result = TemplatesController.ShowOneTextBoxTrueFalseForm(textBoxItem, trueFalseItem,
view.ParentControl);
return(result);
}
/// <summary>
/// Generates a controller and context, hands them off to be rendered by the view engine and
/// returns the result string
/// </summary>
/// <param name="viewName">Template Name</param>
/// <param name="model">Model for the view</param>
/// <param name="viewData">ViewData</param>
/// <returns>rendered string</returns>
private static string Execute(string viewName, ViewDataDictionary viewData, object model)
{
var controller = new TemplatesController();
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new HttpContextWrapper(HttpContext.Current);
controller.RouteData.DataTokens.Add("controller", "Templates");
controller.RouteData.Values.Add("controller", "Templates");
controller.ViewData = viewData;
return RenderView(controller, viewName, model);
}
public override void NewButtonClicked()
{
string result = TemplatesController.ShowOneTextBoxForm("List Name: ", "", this.view.ParentControl);
if (result != String.Empty)
{
InsertNewItem(result);
LoadView();
}
}
public TemplatesControllerTest()
{
_userRepository = new Mock <IUserRepository>();
_dayActivityRepository = new Mock <IDayActivityRepository>();
_activityRepository = new Mock <IActivityRepository>();
_dayRepository = new Mock <IDayRepository>();
_helperRepository = new Mock <IHelperRepository>();
_dummyDBContext = new DummyDBContext();
_controller = new TemplatesController(_dayRepository.Object, _activityRepository.Object, _userRepository.Object, _dayActivityRepository.Object, _helperRepository.Object);
}
/// <summary>
/// Generates a controller and context, hands them off to be rendered by the view engine and
/// returns the result string
/// </summary>
/// <param name="viewName">Template Name</param>
/// <param name="model">Model for the view</param>
/// <param name="viewData">ViewData</param>
/// <returns>rendered string</returns>
private static string Execute(string viewName, ViewDataDictionary viewData, object model)
{
var controller = new TemplatesController();
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new HttpContextWrapper(HttpContext.Current);
controller.RouteData.DataTokens.Add("controller", "Templates");
controller.RouteData.Values.Add("controller", "Templates");
controller.ViewData = viewData;
return(RenderView(controller, viewName, model));
}
public void GetDefaultTemplate_MoqTest()
{
mockITemplateQueryService.Setup(x => x.GetDefaultTemplate(It.IsAny <Guid>(), It.IsAny <ModuleType>()))
.Returns(template);
var controller = new TemplatesController(mockITemplateQueryService.Object, mockIUserQueryService.Object, mockITemplateCommandService.Object);
TriTech.InformRMS.Application.Contracts.Administration.DTO.TemplateAdmin.Template actionResult = controller.GetDefaultTemplate(It.IsAny <Guid>(), It.IsAny <ModuleType>());
Assert.AreEqual(template.DataEntryContractId, actionResult.DataEntryContractId);
Assert.AreEqual(template.ApiVersion, actionResult.ApiVersion);
Assert.AreEqual(template.ModuleType, actionResult.ModuleType);
Assert.AreEqual(template.IsDefault, actionResult.IsDefault);
}
public async Task Delete_TemplateDoesNotExists_ThrowException()
{
var id = Guid.Parse("cc846e51-132c-4a6a-bc96-c032491e383c");
var templateServiceMock = new Mock <ITemplateService>();
var commandDispatcherMock = new Mock <ICommandDispatcher>();
commandDispatcherMock.Setup(x => x.DispatchAsync <ICommand>(It.IsAny <ICommand>()))
.Throws(new ServiceException(ErrorCodes.TemplateNotFound));
var templatesController = new TemplatesController(commandDispatcherMock.Object, templateServiceMock.Object);
var exception = await Assert.ThrowsAsync <ServiceException>(() => templatesController.Delete(id));
exception.Code.Should().Be("template_not_found");
}
public async Task Post_TemplateDoesNotExistsAndItShouldBeCreated_MethodReturn201()
{
var command = new CreateTemplate()
{
};
var templateServiceMock = new Mock <ITemplateService>();
var commandDispatcherMock = new Mock <ICommandDispatcher>();
var templatesController = new TemplatesController(commandDispatcherMock.Object, templateServiceMock.Object);
var response = await templatesController.Post(command);
response.Should().NotBeNull();
response.Should().BeOfType <CreatedResult>();
(response as ObjectResult).StatusCode.Should().Be(201);
}
public void GetAllTemplates_MoqTest()
{
mockITemplateQueryService.Setup(x => x.GetAllTemplates())
.Returns(templateReference);
var controller = new TemplatesController(mockITemplateQueryService.Object, mockIUserQueryService.Object, mockITemplateCommandService.Object);
List <TemplateReference> actionResult = controller.GetAllTemplates(It.IsAny <Guid>());
Assert.AreEqual(templateReference.Count, actionResult.Count);
Assert.AreEqual(templateReference[0].Id, actionResult[0].Id);
Assert.AreEqual(templateReference[0].AgencyId, actionResult[0].AgencyId);
Assert.AreEqual(templateReference[0].ModuleType, actionResult[0].ModuleType);
Assert.AreEqual(templateReference[0].Name, actionResult[0].Name);
Assert.AreEqual(templateReference[0].IsActive, actionResult[0].IsActive);
Assert.AreEqual(templateReference[0].IsDefault, actionResult[0].IsDefault);
Assert.AreEqual(templateReference[0].IsSupplement, actionResult[0].IsSupplement);
}
public void Create_MoqTest()
{
mockITemplateCommandService.Setup(x => x.Create(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <TemplateDetails>()))
.Returns(dummyGuid);
var controller = new TemplatesController(mockITemplateQueryService.Object, mockIUserQueryService.Object, mockITemplateCommandService.Object);
HttpResponseMessage actionResult = controller.Create(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <Guid>(), templateDetails);
actionResult.Content.ReadAsStringAsync()
.ContinueWith(t =>
{
var value = t.Result;
Guid id;
Guid.TryParse(value, out id);
Assert.AreEqual(dummyGuid, actionResult.Content);
});
}
public async Task Get_TemplateExistsAndShouldBeReturned_MethodReturnJson(List <TemplateDto> data)
{
var command = new CreateTemplate()
{
};
var templateServiceMock = new Mock <ITemplateService>();
templateServiceMock.Setup(x => x.GetAsync())
.ReturnsAsync(data);
var commandDispatcherMock = new Mock <ICommandDispatcher>();
var templatesController = new TemplatesController(commandDispatcherMock.Object, templateServiceMock.Object);
var response = await templatesController.Get();
response.Should().NotBeNull();
response.Should().BeOfType <JsonResult>();
}
public void TemplatesController_IndexTest()
{
TemplatesController controller = new TemplatesController();
ViewResult result = controller.Index() as ViewResult;
Assert.IsNotNull(result, "Invalid Result");
Assert.IsNotNull(result.Model, "Invalid Model");
List <EF2OR.ViewModels.TemplateViewModel> model = result.Model as List <EF2OR.ViewModels.TemplateViewModel>;
Assert.IsNotNull(model, "Unable to cast model");
if (model.Count > 0)
{
var firstItem = model.First();
Assert.IsTrue(firstItem.NumberOfDownloads > 0, "Incorrect Number of Downloads");
Assert.IsTrue(!string.IsNullOrWhiteSpace(firstItem.AccessToken), "Empty Access Token");
Assert.IsTrue(!string.IsNullOrWhiteSpace(firstItem.AccessUrl), "Empty Access Token");
Assert.IsTrue(!string.IsNullOrWhiteSpace(firstItem.TemplateName), "Empty Template Name");
Assert.IsTrue(!string.IsNullOrWhiteSpace(firstItem.VendorName), "Empty Vendor Name");
}
}
public async Task Must_Return_Render_Templates_With_Variables_Added()
{
var _template = new Template
{
Id = TEMPLATE_ID_FOR_TESTING,
};
var templateRepositoryMock = new Mock <ITemplateRepository>();
templateRepositoryMock.Setup(x => x.GetAsync(It.IsAny <int>())).Returns(Task.FromResult <Template>(null));
var templateController = new TemplatesController(templateRepositoryMock.Object);
// Arrange
// Act
var result = await templateController.RenderTemplate(_template.Id);
Assert.NotNull(result);
var notfoundResult = result as NotFoundResult;
Assert.NotNull(notfoundResult);
Assert.Equal(404, notfoundResult.StatusCode);
}
public void TestInputShouldBeValidatedAndCleanedBeforeDeleting()
{
var storeService = Substitute.For <IStoreService>();
var templateService = Substitute.For <ITemplateService>();
templateService.IsValid(Arg.Any <string>()).ReturnsForAnyArgs(true);
templateService.Clean(Arg.Any <string>()).ReturnsForAnyArgs("");
storeService.DeleteTemplate(Arg.Any <string>()).Returns(true);
var controller = new TemplatesController(storeService, templateService);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
controller.Delete();
Received.InOrder(() => {
templateService.IsValid(Arg.Any <string>());
templateService.Clean(Arg.Any <string>());
storeService.DeleteTemplate(Arg.Any <string>());
});
}
public void Put_NullTemplate_ShouldReturnBadRequest()
{
var templatesController = new TemplatesController(_mockTemplateService.Object, _mockLogger.Object);
}
public void SetUp()
{
_controller = new TemplatesController(_mapper.Object, _templateManager.Object);
}
public void Get_WithID_ShouldReturnResults()
{
var templatesController = new TemplatesController(_mockTemplateService.Object, _mockLogger.Object);
}
public void Put_SaveFailed_ShouldReturnNotFound()
{
var templatesController = new TemplatesController(_mockTemplateService.Object, _mockLogger.Object);
}
public void Delete_ShouldReturnNotFound()
{
var templatesController = new TemplatesController(_mockTemplateService.Object, _mockLogger.Object);
}
public void Put_SaveSuccessful_ShouldReturnResults()
{
var templatesController = new TemplatesController(_mockTemplateService.Object, _mockLogger.Object);
}
