public void InsertTag_ValidTag_ReturnSuccess()
{
TagsController controller = new TagsController(mockTagService.Object);
this.SetupControllerTests(controller, "http://localhost/STCRMService/api/tags", HttpMethod.Post);
var mockResponse = mockRepository.Create <SaveTagResponse>();
TagViewModel newTag = new TagViewModel()
{
TagID = SAMPLE_TAG_ID
};
mockResponse.Setup(c => c.TagViewModel).Returns(newTag);
mockTagService.Setup(c => c.SaveTag(It.IsAny <SaveTagRequest>())).Returns(mockResponse.Object);
var httpResponseMessage = controller.PostTag(It.IsAny <TagViewModel>());
var postResponse = httpResponseMessage.Content.ReadAsAsync <SaveTagResponse>().ContinueWith(
t => { return(t.Result); }).Result;
var tagResponse = postResponse.TagViewModel;
mockRepository.VerifyAll();
Assert.IsTrue(postResponse.TagViewModel.TagID > 0, "Id is not greater than zero after insert.");
Assert.AreEqual(httpResponseMessage.StatusCode, HttpStatusCode.OK);
Assert.AreEqual(postResponse.Exception, null);
}
public void ShouldRetrieveTagPictures()
{
var tagName = "myTag";
var mockRepository = new Mock <ITagRepository>();
mockRepository.Setup(r => r.GetPictures(tagName)).Returns(() =>
{
var result = new List <PictureTag>();
result.Add(new PictureTag()
{
PictureId = Guid.NewGuid(), TagName = tagName
});
result.Add(new PictureTag()
{
PictureId = Guid.NewGuid(), TagName = tagName
});
return(result.AsQueryable());
});
var tagsController = new TagsController(mockRepository.Object);
var pictureTags = tagsController.Pictures(tagName);
Assert.AreEqual(pictureTags.Count(), 2);
foreach (var pictureTag in pictureTags)
{
Assert.AreEqual(pictureTag.TagName, tagName);
}
}
public async Task TagInfo_ReturnTagInfoViewOnException()
{
// Arrange
// mocking repository
var mockRepo = new Mock <IAsyncRepository>();
Dictionary <int, int> tempTagInfo = new Dictionary <int, int>();
tempTagInfo.Add(1, 1);
mockRepo.Setup(repo => repo.GetTagInfo()).ReturnsAsync(tempTagInfo).Verifiable();
List <Tag> tempTags = new List <Tag>();
Tag tempTag = new Tag {
Id = 1, Name = "Test Tag"
};
tempTags.Add(tempTag);
mockRepo.Setup(repo => repo.GetAllTags()).Throws(new Exception()).Verifiable();
var controller = new TagsController(mockRepo.Object, mapper);
// Act
var result = await controller.TagInfo();
// Assert
var requestResult = Assert.IsType <ViewResult>(result);
Assert.Equal("Error", requestResult.ViewName);
mockRepo.Verify(x => x.GetTagInfo(), Times.Once);
mockRepo.Verify(x => x.GetAllTags(), Times.Once);
}
public TagsControllerTests()
{
_mockRepository = new Mock <ITagsRepo>();
_mapper = Mapper.Configuration.CreateMapper();
_mockLogger = new Mock <ILogger <TagsController> >();
_controller = new TagsController(_mockRepository.Object, _mapper, _mockLogger.Object);
}
public async Task AddTagGet_ReturnErrorViewOnException()
{
// Arrange
// mocking repository
var mockRepo = new Mock <IAsyncRepository>();
Question tempQuestion = new Question {
Id = 1, Title = "Test Title"
};
mockRepo.Setup(repo => repo.GetQuestionByIdWithoutDetailsAsync(It.IsAny <int>())).ReturnsAsync(tempQuestion).Verifiable();
mockRepo.Setup(repo => repo.GetAllTagsNoDuplicates(It.IsAny <int>())).Throws(new Exception()).Verifiable();
// adding a real mapper
var myProfile = new AskMateProfiles();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(myProfile));
var realMapper = new Mapper(configuration);
var controller = new TagsController(mockRepo.Object, realMapper);
// Act
var result = await controller.AddTag(1);
// Assert
var requestResult = Assert.IsType <ViewResult>(result);
Assert.Equal("Error", requestResult.ViewName);
mockRepo.Verify(x => x.GetQuestionByIdWithoutDetailsAsync(It.IsAny <int>()), Times.Once);
mockRepo.Verify(x => x.GetAllTagsNoDuplicates(It.IsAny <int>()), Times.Once);
}
public void Can_Get_All_Tags_From_Controller()
{
var controller = new TagsController();
var allTags = controller.Get().ToList();
Assert.That(allTags, Has.Count.GreaterThan(0));
}
public async void Patch_No_Errors()
{
TagsControllerMockFacade mock = new TagsControllerMockFacade();
var mockResult = new Mock <UpdateResponse <ApiTagsResponseModel> >();
mockResult.SetupGet(x => x.Success).Returns(true);
mock.ServiceMock.Setup(x => x.Update(It.IsAny <int>(), It.IsAny <ApiTagsRequestModel>()))
.Callback <int, ApiTagsRequestModel>(
(id, model) => model.Count.Should().Be(1)
)
.Returns(Task.FromResult <UpdateResponse <ApiTagsResponseModel> >(mockResult.Object));
mock.ServiceMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <ApiTagsResponseModel>(new ApiTagsResponseModel()));
TagsController controller = new TagsController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, new ApiTagsModelMapper());
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var patch = new JsonPatchDocument <ApiTagsRequestModel>();
patch.Replace(x => x.Count, 1);
IActionResult response = await controller.Patch(default(int), patch);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
mock.ServiceMock.Verify(x => x.Update(It.IsAny <int>(), It.IsAny <ApiTagsRequestModel>()));
}
public async Task Index_ReturnsAViewResult_WithAListOfBrainstormSessions()
{
// Arrange
var mockTagRepo = new Mock <ITagService>();
mockTagRepo.Setup(repo => repo.GetAllTagsAsync())
.ReturnsAsync(GetTagsTest());
var autoMapperConfiguration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Tag, TagResponse>();
}
);
var mapper = autoMapperConfiguration.CreateMapper();
var controller = new TagsController(mapper, mockTagRepo.Object);
// Act
var result = await controller.GetAll();
// Assert
var objectResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <List <TagResponse> >(objectResult.Value);
Assert.Equal(2, model.Count);
}
public void GetTopTags_GetResult_NotFail_Test()
{
var expected = new List <Tag>()
{
new Tag()
};
bool called = false;
int organizerId = 1;
IEventDefinitionRepository eventDefinitionService = new StubIEventDefinitionRepository()
{
GetTopTagsInt32 = (id) =>
{
called = true;
return(expected);
}
};
var target = new TagsController(eventDefinitionService);
IEnumerable <Tag> actual = target.GetTopTags(organizerId);
Assert.IsTrue(called);
Assert.AreEqual(expected.Count, actual.Count());
}
public async void BulkInsert_No_Errors()
{
TagsControllerMockFacade mock = new TagsControllerMockFacade();
var mockResponse = new CreateResponse <ApiTagsResponseModel>(new FluentValidation.Results.ValidationResult());
mockResponse.SetRecord(new ApiTagsResponseModel());
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiTagsRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiTagsResponseModel> >(mockResponse));
TagsController controller = new TagsController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var records = new List <ApiTagsRequestModel>();
records.Add(new ApiTagsRequestModel());
IActionResult response = await controller.BulkInsert(records);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
var result = (response as OkObjectResult).Value as List <ApiTagsResponseModel>;
result.Should().NotBeEmpty();
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiTagsRequestModel>()));
}
public async Task LoadTopTags()
{
var repository = new Mock <ITagsRepository>(MockBehavior.Strict);
repository
.Setup(mock => mock.LoadTopTags(16))
.ReturnsAsync(new[]
{
new Tag
{
Id = Guid.Parse("c2fa02b7-b107-4261-8306-9465178f2949"),
Name = "artsy"
}
});
var controller = new TagsController(repository.Object);
var result = await controller.LoadTopTags();
result.ShouldDeepEqual(new[]
{
new TagViewModel
{
Name = "artsy"
}
});
}
public void TestsSetup()
{
AutoMapperConfig.RegisterMappings();
this.tagsServiceMock = ServicesObjectFactory.GetTagsService();
this.controller = new TagsController(this.tagsServiceMock);
this.controller.Cache = new HttpCacheService();
}
public void Setup()
{
_mediatorMock
.Setup(x => x.Send(It.IsAny <GetTagsForExportQuery>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new SuccessResult <ExportDto>(_exportDto) as Result <ExportDto>));
_excelConverterMock = new Mock <IExcelConverter>();
_excelConverterMock.Setup(x => x.Convert(_exportDto)).Returns(new MemoryStream());
_dut = new TagsController(_mediatorMock.Object, _excelConverterMock.Object);
}
public void TestCleanup()
{
this.helper.Users.Clear();
this.helper.HashTags.Clear();
this.helper.Tweets.Clear();
this.uowData = null;
this.controllerContext = null;
this.controller = null;
}
public void Can_Get_Tag_By_Id_From_Controller()
{
const int id = 1;
var controller = new TagsController();
var tag = controller.Get(id);
Assert.That(tag.Id, Is.EqualTo(id));
}
private async Task CreateTagsAsync()
{
var c = new TagsController(_context);
foreach (var tag in tags)
{
var result = await c.Create(new TagModel { TagID = tag.TagID, ActivityID = tag.ActivityID });
}
}
public void GetTags(int page, int pageSize)
{
// Act
var controller = new TagsController(_logger, _entityBL, _commonBL);
var result = controller.GetTags(string.Empty, page, pageSize) as OkNegotiatedContentResult <PagedList>;
// Assert
Assert.AreEqual(result.Content.Content.Count, pageSize);
}
// Plumbing
private TagsController ArrangeController(IClaimsProvider claimsProvider, IDataManager <Tag> dataManager)
{
TagsController controller = new TagsController(claimsProvider, dataManager);
controller.Request = new HttpRequestMessage()
{
Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } }
};
return(controller);
}
public void Setup()
{
_mediatorMock
.Setup(x => x.Send(It.IsAny <CreateTagsCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new SuccessResult <List <int> >(new List <int> {
5
}) as Result <List <int> >));
_excelConverterMock = new Mock <IExcelConverter>();
_dut = new TagsController(_mediatorMock.Object, _excelConverterMock.Object);
}
public void Post_And_Saves()
{
var tag = new Tag();
var tagRepo = Substitute.For <ITagRepository>();
var underTest = new TagsController(tagRepo);
underTest.Post(tag, 42);
tagRepo.Received().Create(tag);
}
public TagsControllerTests()
{
_fixture = new Fixture();
_fixture.Behaviors.OfType <ThrowingRecursionBehavior>().ToList().ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_logger = new Mock <ILogger <TagsController> >();
_photosService = new Mock <IPhotoService>();
_tagsController = new TagsController(_logger.Object, _photosService.Object);
}
public void GetTags(int id)
{
// Act
var controller = new TagsController(_logger, _entityBL, _commonBL);
var result = controller.GetTags(id) as OkNegotiatedContentResult <Tag>;
// Assert
Assert.NotNull(result);
Assert.NotNull(result.Content);
Assert.AreEqual(id, result.Content.Id);
}
public void InsertTagsData()
{
// Arrange
var tags = new TagsController();
// Act
// Assert
}
public async void TagsController_Delete()
{
var ctrlr = new TagsController(_dbContext);
var result = await ctrlr.DeleteConfirmed(2);
var resultView = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal(0, _dbContext.Tag.Count(d => d.TagId == 2));
Assert.Equal(1, _dbContext.ArticleTag.Count());
Assert.Equal(2, _dbContext.MediaKitFileTag.Count());
}
public void Post_AddNullTag_TagShouldNotBeAdded()
{
// Arrange
var controller = new TagsController(tagService);
TagViewModel tag = null;
// Act
IHttpActionResult result = controller.Post(tag);
// Assert
Assert.IsInstanceOfType(result, typeof(BadRequestResult));
}
public TagControllerTest()
{
SetUp();
_tagServiceMock = new Mock <ITagService>();
var loggerMock = new Mock <ILogger <TagsController> >();
_sut = new TagsController(
_tagServiceMock.Object,
Mapper,
loggerMock.Object);
}
public async void TagsController_Edit()
{
var ctrlr = new TagsController(_dbContext);
Tag tag = _dbContext.Tag.SingleOrDefault(d => d.TagId == 1);
tag.TagName = "more stuff";
var result = await ctrlr.Edit(tag.TagId, tag);
var resultView = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal(1, _dbContext.Tag.Count(d => d.TagName == "more stuff"));
}
public void Init()
{
_ctrl = new TagsController(new FakeTagsRepository());
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/be/api");
var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "tags" } });
_ctrl.ControllerContext = new HttpControllerContext(config, routeData, request);
_ctrl.Request = request;
_ctrl.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
}
public void GetAll_Returns_All_Tags_For_Given_Review()
{
var reviewId = 42;
var expectedModel = new List <Tag>();
var tagRepo = Substitute.For <ITagRepository>();
tagRepo.GetTagsForReviewId(reviewId).Returns(expectedModel);
var underTest = new TagsController(tagRepo);
var model = underTest.Get(reviewId);
Assert.Same(expectedModel, model);
}
public async void TagsController_Index()
{
//TO DO write test to check usagecnt
var ctrlr = new TagsController(_dbContext);
var result = await ctrlr.Index();
var resultView = Assert.IsType <ViewResult>(result);
var viewModel = Assert.IsType <List <TagViewModel> >(resultView.ViewData.Model).ToList();
Assert.True(1 <= viewModel.Count(d => d.TagName == "stuff"));
Assert.True(1 <= viewModel.Count(d => d.TagName == "category"));
Assert.True(1 <= viewModel.Count(d => d.TagName == "interest"));
}
public void CheckControllerDecoratedWithValidateAntiForgeryToken()
{
var mockTagsService = new Mock <ITagsService>();
TagsController controller = new TagsController(
mockTagsService.Object);
var type = controller.GetType();
var methodInfo = type.GetMethod("AutoCompleteSearch", new Type[] { typeof(string) });
var attributes = methodInfo.GetCustomAttributes(typeof(ValidateAntiForgeryTokenAttribute), true);
Assert.True(attributes.Any(), "No ValidateAntiForgeryTokenAttribute found on AutoCompleteSearch method");
}
public async Task GetWithParamsShouldReturnOkResult()
{
// Arrange
var fakeSql = Substitute.For<IDatabase>();
var controller = new TagsController(fakeSql);
// Act
var result = await controller.Get(1);
// Assert
var viewResult = Assert.IsType<OkNegotiatedContentResult<Tag>>(result);
Assert.NotNull(viewResult);
}
public async Task PostShouldReturnOkResultWhenResultGreaterThanOne()
{
// Arrange
var model = new Tag();
var fakeSql = Substitute.For<IDatabase>();
fakeSql.CreateAsync(model).Returns(Task.FromResult(1));
var controller = new TagsController(fakeSql);
// Act
var result = await controller.Post(model);
// Assert
var viewResult = Assert.IsType<OkNegotiatedContentResult<Tag>>(result);
Assert.NotNull(viewResult);
}
public void InitTagsController()
{
TagsController = new TagsController();
}
public async Task PutShouldReturnInvalidModelStateResultWhenInvalidModel()
{
// Arrange
var model = new Tag();
var fakeSql = Substitute.For<IDatabase>();
fakeSql.CreateAsync(model).Returns(Task.FromResult(1));
var controller = new TagsController(fakeSql)
{
Configuration = new HttpConfiguration()
};
controller.ModelState.AddModelError("FakeError", "This is a Fake Error!");
// Act
var result = await controller.Put(1, model);
// Assert
var viewResult = Assert.IsType<InvalidModelStateResult>(result);
Assert.NotNull(viewResult);
}
public async Task PutShouldReturnReturnOkResultWithModelIdSetToId()
{
// Arrange
var model = new Tag { Id = 1 };
var fakeSql = Substitute.For<IDatabase>();
fakeSql.UpdateAsync(model).Returns(Task.FromResult(true));
var controller = new TagsController(fakeSql);
// Act
var result = await controller.Put(2, model);
// Assert
var viewResult = Assert.IsType<OkNegotiatedContentResult<Tag>>(result);
Assert.Equal(viewResult.Content.Id, 2);
}
public async Task DeleteShouldReturnBadRequestResultWhenResultFalse()
{
// Arrange
var model = new Tag();
var fakeSql = Substitute.For<IDatabase>();
fakeSql.DeleteAsync(model).ReturnsForAnyArgs(Task.FromResult(false));
var controller = new TagsController(fakeSql);
// Act
var result = await controller.Delete(1);
// Assert
var viewResult = Assert.IsType<BadRequestResult>(result);
Assert.NotNull(viewResult);
}
public async Task DeleteShouldReturnOkResultWithModelId()
{
// Arrange
var model = new Tag();
var fakeSql = Substitute.For<IDatabase>();
fakeSql.DeleteAsync(model).ReturnsForAnyArgs(Task.FromResult(true));
var controller = new TagsController(fakeSql);
// Act
var result = await controller.Delete(1);
// Assert
var viewResult = Assert.IsType<OkNegotiatedContentResult<int>>(result);
Assert.Equal(viewResult.Content, 1);
}
public async Task PostShouldReturnBadRequestResultWhenResultLessThanOne()
{
// Arrange
var model = new Tag();
var fakeSql = Substitute.For<IDatabase>();
fakeSql.CreateAsync(model).Returns(Task.FromResult(0));
var controller = new TagsController(fakeSql);
// Act
var result = await controller.Post(model);
// Assert
var viewResult = Assert.IsType<BadRequestResult>(result);
Assert.NotNull(viewResult);
}
