public void TopicController_Ctor_WhenCreatingAnInstanceOfController_TopicsWillBeInitialized()
{
var wasGetTopicsInitialized = false;
TopicController.GetTopicsCollection = () =>
{
wasGetTopicsInitialized = true;
return(new List <Topic>());
};
TopicController.Init();
var controller = new TopicController();
Assert.IsTrue(wasGetTopicsInitialized);
}
public void TopicController_Ctor_WhenCreatingAnInstanceTwice_TopicsWillBeInitializedOnlyOnce()
{
var callCount = 0;
TopicController.GetTopicsCollection = () =>
{
callCount++;
return(new List <Topic>());
};
TopicController.Init();
new TopicController();
new TopicController();
Assert.AreEqual(1, callCount);
}
public async Task TopicController_IndexAsync_ReturnsTopicViewResult() {
var controller = new TopicController(_topicRepository, _topicMappingService) {
ControllerContext = _context
};
var result = await controller.IndexAsync(_topic.GetWebPath()).ConfigureAwait(false) as TopicViewResult;
var model = result.Model as PageTopicViewModel;
controller.Dispose();
Assert.IsNotNull(model);
Assert.AreEqual<string>("Web_0_1_1", model.Title);
}
public void Add_New_Topic_Test()
{
Mock <ITopicRepository> topicRepo = new Mock <ITopicRepository>();
Mock <IIntermediateCategoryRepository> interRepo = new Mock <IIntermediateCategoryRepository>();
TopicController controller = new TopicController(topicRepo.Object, interRepo.Object, () => "koral2323");
int id = 5;
int result = controller.Add_New_Topic(id).ViewBag.InterId;
Assert.AreEqual(id, result);
Assert.AreNotEqual(1, result);
}
public async Task TopicController_IndexAsync() {
var topicRoutingService = new MvcTopicRoutingService(_topicRepository, _uri, _routeData);
var mappingService = new TopicMappingService(_topicRepository, new TopicViewModelLookupService());
var controller = new TopicController(_topicRepository, topicRoutingService, mappingService);
var result = await controller.IndexAsync(_topic.GetWebPath()).ConfigureAwait(false) as TopicViewResult;
var model = result.Model as PageTopicViewModel;
controller.Dispose();
Assert.IsNotNull(model);
Assert.AreEqual<string>("Web_0_1_1", model.Title);
}
public void TopicController_Get_WhenTheRepositoryDoesNotFindATopicForTheGivenIdAndTuorialName_WillReturnA404()
{
_topicsRepository.Setup(g => g.Where(It.IsAny <Expression <Func <Topic, bool> > >())).Returns(new List <Topic> {
});
var controller = new TopicController(_topicsRepository.Object);
SetUpHttpRequestParameters(controller);
var response = controller.Get(1, "ASP.NET Core on Ubuntu");
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
ExpandoObject expando;
Assert.IsTrue(response.TryGetContentValue(out expando));
var expandoDict = (IDictionary <string, object>)expando;
Assert.AreEqual("The tutorial you requested was not found", expandoDict["message"]);
}
public void TopicController_Delete_WhenTheTopicIsDeletedSuccessfully_WillReturnAnOKStatusAndASuccessMessage()
{
var controller = new TopicController(_topicsRepository.Object);
SetUpHttpRequestParameters(controller);
var response = controller.Delete(1);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
ExpandoObject expando;
Assert.IsTrue(response.TryGetContentValue(out expando));
var expandoDict = (IDictionary <string, object>)expando;
Assert.AreEqual("The topic was deleted successfully", expandoDict["message"]);
_topicsRepository.Verify(t => t.Delete(It.IsAny <int>()), Times.Once());
_topicsRepository.Verify(c => c.Save(), Times.Once());
}
public void Add_New_Topic_Dont_Save_InValid_Changes()
{
Mock <ITopicRepository> repositoryTopic = new Mock <ITopicRepository>();
Mock <IIntermediateCategoryRepository> repositoryInter = new Mock <IIntermediateCategoryRepository>();
TopicController controller = new TopicController(repositoryTopic.Object, repositoryInter.Object, () => "ewa2323");
Topic topic = new Topic()
{
TopicName = null, TopicData = null
};
controller.ModelState.AddModelError("TopicName", "Pole nie może pozostawać puste");
controller.ModelState.AddModelError("TopicData", "Pole nie może pozostawać puste");
ActionResult result = controller.Add_New_Topic(topic);
repositoryTopic.Verify(x => x.Add_To_Topics_And_User(It.IsAny <Topic>(), It.IsAny <string>()), Times.Never);
}
public void Add_New_Topic_Dont_Save_Changes_Return_View_Add_New_Topic()
{
Mock <ITopicRepository> repositoryTopic = new Mock <ITopicRepository>();
Mock <IIntermediateCategoryRepository> repositoryInter = new Mock <IIntermediateCategoryRepository>();
TopicController controller = new TopicController(repositoryTopic.Object, repositoryInter.Object, () => "ewa2323");
Topic topic = new Topic()
{
TopicName = null, TopicData = null
};
controller.ModelState.AddModelError("TopicName", "Pole nie może pozostawać puste");
controller.ModelState.AddModelError("TopicData", "Pole nie może pozostawać puste");
ViewResult result = (ViewResult)controller.Add_New_Topic(topic);
Assert.AreEqual("Add_New_Topic", result.ViewName);
}
public void Redirect_To_Action_Create_New_Topic()
{
//Arrange
var testValue = new TopicViewModel()
{
Id = 2
};
var service = Substitute.For <ITopicService>();
TopicController controller = new TopicController(service);
//Act
var expected = controller.CreateNewTopic(testValue) as RedirectToActionResult;
//Assert
Assert.Equal(expected.ActionName, "Index");
Assert.Equal(expected.ControllerName, "Home");
}
private async Task And_a_topic()
{
_topicController = new TopicController(
_serviceProvider.GetService <ITopicDomainService>(),
_serviceProvider.GetService <ITopicRepository>(),
_serviceProvider.GetService <ICapabilityRepository>(),
_serviceProvider.GetService <IKafkaJanitorRestClient>()
);
await _topicController.AddTopicToCapability(
_capability.Id.ToString(),
new TopicInput { Name = "the topic of the future", Description = "The way topics should be", Partitions = 2, KafkaClusterId = _clusterA.Id.ToString(), DryRun = false });
// Creation of a Topic as it is now needs to be refactored to avoid having to put a random delay/sleep here.
Thread.Sleep(2000);
}
public void SetUp()
{
topicList = new List <Topic>
{
new Topic(23, "Test1", 1),
new Topic(24, "Test2", 1),
new Topic(25, "Test3", 1)
};
topicListAdmin = new List <TopicAdmin>
{
new TopicAdmin(26, "Test4", 1, "Test4"),
new TopicAdmin(27, "Test5", 1, "Test5"),
new TopicAdmin(28, "Test6", 1, "Test6")
};
validation = Substitute.For <ITopic>();
topicController = new TopicController(validation);
}
private async Task When_a_topic_is_added()
{
_topicController = new TopicController(
_serviceProvider.GetService <ITopicDomainService>(),
_serviceProvider.GetService <ITopicRepository>(),
_serviceProvider.GetService <ICapabilityRepository>(),
_serviceProvider.GetService <IKafkaJanitorRestClient>()
);
await _topicController.AddTopicToCapability(
_capability.Id.ToString(),
new TopicInput
{
Name = "the topic of the future",
Description = "The way topics should be",
DryRun = true
});
}
public void Return_Model_Index_Method()
{
//Arrange
var testValue = new TopicViewModel()
{
Id = 1
};
var service = Substitute.For <ITopicService>();
service.GetTopic(1).Returns(testValue);
TopicController controller = new TopicController(service);
//Act
var expected = controller.Index(1) as ViewResult;
//Assert
Assert.Equal(expected.Model, testValue);
Assert.NotNull(expected);
}
public void Add_New_Comment_Dont_Save_InValid_Changes()
{
Mock <ITopicRepository> repositoryTopic = new Mock <ITopicRepository>();
Mock <IIntermediateCategoryRepository> repositoryInter = new Mock <IIntermediateCategoryRepository>();
TopicController controller = new TopicController(repositoryTopic.Object, repositoryInter.Object, () => "ewa2323");
Comment comment = new Comment()
{
CommentContent = null
};
controller.ModelState.AddModelError("CommentContent", "Pole nie może pozostawać puste");
ActionResult result = controller.Add_New_Comment(comment);
ViewResult resultView = (ViewResult)result;
repositoryTopic.Verify(x => x.Add_Comment(It.IsAny <Comment>(), It.IsAny <string>()), Times.Never);
Assert.AreEqual(resultView.ViewName, "Add_New_Comment");
}
public void Show_Topics_Test_id_out_of_range()
{
ICollection <IntermediateCategory> intercat = new List <IntermediateCategory> {
new IntermediateCategory()
{
IntermediateCategoryId = 1, NameOfMainCategory = "Zdrowie ", MainCategoryByCitiesId = 1
},
new IntermediateCategory()
{
IntermediateCategoryId = 2, NameOfMainCategory = "Kuchnia ", MainCategoryByCitiesId = 1
},
new IntermediateCategory()
{
IntermediateCategoryId = 3, NameOfMainCategory = "Sport ", MainCategoryByCitiesId = 1
},
new IntermediateCategory()
{
IntermediateCategoryId = 4, NameOfMainCategory = "Kino", MainCategoryByCitiesId = 1
},
new IntermediateCategory()
{
IntermediateCategoryId = 0, NameOfMainCategory = "Error", Topic = new List <Topic>()
}
}.ToList();
Mock <IIntermediateCategoryRepository> mockI = new Mock <IIntermediateCategoryRepository>();
mockI.Setup(m => m.Get(666)).Returns(new IntermediateCategory()
{
IntermediateCategoryId = 1, NameOfMainCategory = "Error", Topic = new List <Topic>()
});
Mock <ITopicRepository> mockT = new Mock <ITopicRepository>();
TopicController controller = new TopicController(mockT.Object, mockI.Object);
ViewResult result = controller.Show_Topics(666) as ViewResult;
string viewName = result.ViewName;
Assert.AreEqual(result.ViewName.ToString(), "Error");
}
public void TopicController_Get_WhenTheRepositoryDoesNotFindARequestedTopic_WillReturnA404()
{
_topicsRepository.Setup(g => g.Find(It.IsAny <int>()))
.Returns((Topic)null)
.Verifiable();
var controller = new TopicController(_topicsRepository.Object);
SetUpHttpRequestParameters(controller);
var response = controller.Get(3);
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
ExpandoObject expando;
Assert.IsTrue(response.TryGetContentValue(out expando));
var expandoDict = (IDictionary <string, object>)expando;
Assert.AreEqual("The topic you requested was not found", expandoDict["message"]);
}
private async Task When_a_topic_with_too_many_partitions_is_added()
{
_topicController = new TopicController(
_serviceProvider.GetService <ITopicDomainService>(),
_serviceProvider.GetService <ITopicRepository>(),
_serviceProvider.GetService <ICapabilityRepository>(),
_serviceProvider.GetService <IKafkaJanitorRestClient>()
);
addTopicToCapabilityActionResult = await _topicController.AddTopicToCapability(
_capability.Id.ToString(),
new TopicInput
{
Name = "the topic of the future",
Description = "The way topics should be",
Partitions = Int32.MaxValue
});
}
public void ShouldCreateTopicAndNotifyTheUser()
{
var professionalDevelopment = new Topic {
Id = 3, Colour = ColorTranslator.FromHtml("#000000"), Name = "Professional Development"
};
var formValues = new FormCollection
{
{ "Id", professionalDevelopment.Id.ToString() },
{ "Name", professionalDevelopment.Name },
{ "Colour", professionalDevelopment.ColourInWebHex().Trim('#') }
};
var controller = new TopicController();
var result = (RedirectToRouteResult)controller.Create(formValues);
Assert.Contains(professionalDevelopment, Topic.Topics);
Assert.AreEqual("Index", result.RouteValues["action"]);
Assert.AreEqual("Your topic has been added successfully.", controller.TempData["message"]);
}
private TopicController CreateControllerWithSettings(User user, SiteSettings siteSettings, Mock <IRepository <Topic> > topicRepo)
{
var userMock = new Mock <ICurrentUser>();
userMock.SetupGet(u => u.DiscussionUser).Returns(user);
var topicService = new DefaultTopicService(siteSettings, userMock.Object, topicRepo.Object, null, new SystemClock());
var topicController = new TopicController(topicRepo.Object, topicService, NullLogger <TopicController> .Instance)
{
ControllerContext =
{
HttpContext = new DefaultHttpContext
{
User = _app.User,RequestServices = _app.ApplicationServices
}
}
};
return(topicController);
}
public void Add_New_Comment_Test2()
{
Mock <ITopicRepository> topicRepo = new Mock <ITopicRepository>();
Mock <IIntermediateCategoryRepository> interRepo = new Mock <IIntermediateCategoryRepository>();
TopicController controller = new TopicController(topicRepo.Object, interRepo.Object, () => "koral2323");
RedirectToRouteResult result = controller.Add_New_Comment(new Comment()
{
CommentContent = "None", CommentID = 1, TopicID = 1
}) as RedirectToRouteResult;
Assert.AreEqual(result.RouteValues["action"], "Go_To_Topic");
Assert.AreEqual(result.RouteValues["controller"], "Topic");
Assert.AreEqual(result.RouteValues["id"], 1);
Assert.AreNotEqual(result.RouteValues["id"], 3);
}
public void TopicController_Get_WhenTheIdAndNameRequestedExists_WillReturnATopic()
{
TopicController.GetTopicsCollection = () =>
{
return(new List <Topic>
{
new Topic {
topic = "ASP.NET Core", id = 1, tutorials = (new List <Tutorial>
{
new Tutorial
{
name = "ASP.NET Core on Ubuntu",
type = "video",
url = "http://www.learninghabits.co.za/#/topics/ubuntu"
}
}).ToArray()
},
new Topic {
topic = "Docker for .NET Developers", id = 2
}
});
};
TopicController.Init();
var controller = new TopicController();
SetUpHttpRequestParameters(controller);
var response = controller.Get(1, "ASP.NET Core on Ubuntu");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
ExpandoObject expando;
Assert.IsTrue(response.TryGetContentValue(out expando));
var expandoDict = (IDictionary <string, object>)expando;
Assert.AreEqual(1, expandoDict["id"]);
var tutorials = expandoDict["tutorials"] as List <Tutorial>;
Assert.IsNotNull(tutorials);
Assert.AreEqual(1, tutorials.Count);
Assert.AreEqual("ASP.NET Core on Ubuntu", tutorials[0].name);
}
public void TopicController_Get_WhenTheRepositoryFindsATopicForTheGivenIdAndTutorialName_WillReturnATopic()
{
var topics = new List <Topic>
{
new Topic {
Name = "ASP.NET Core", Id = 1, Tutorials = new List <Tutorial>
{
new Tutorial
{
Name = "ASP.NET Core on Ubuntu",
Type = "video",
Url = "http://www.learninghabits.co.za/#/topics/ubuntu"
}
}
},
new Topic {
Name = "Docker for .NET Developers", Id = 2
}
};
_topicsRepository.Setup(g => g.Where(It.IsAny <Expression <Func <Topic, bool> > >())).Returns(topics);
var controller = new TopicController(_topicsRepository.Object);
SetUpHttpRequestParameters(controller);
var response = controller.Get(1, "ASP.NET Core on Ubuntu");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
ExpandoObject expando;
Assert.IsTrue(response.TryGetContentValue(out expando));
var expandoDict = (IDictionary <string, object>)expando;
Assert.AreEqual(1, expandoDict["id"]);
var tutorials = expandoDict["tutorials"] as IEnumerable <dynamic>;
Assert.IsNotNull(tutorials);
var tutorialArray = tutorials.ToArray();
Assert.AreEqual(1, tutorialArray.Length);
Assert.AreEqual("ASP.NET Core on Ubuntu", ((IDictionary <string, object>)tutorialArray[0])["name"]);
}
internal static bool IsLocked(long threadid)
{
bool result = true;
SqlConnection con = new SqlConnection(Program.Configuration["connectionStrings:splashConString"]);
con.Open();
SqlCommand command = new SqlCommand("SELECT threads.locked, threads.topicid FROM threads WHERE threadid = " + threadid, con);
SqlDataReader reader = command.ExecuteReader();
if (reader.Read())
{
result = reader.GetBoolean(0);
}
if (!result)
{
result = TopicController.IsLocked(reader.GetInt32(1));
}
reader.Dispose();
con.Close();
return(result);
}
public TopicControllerTest(Fixed.Fixture fixture)
{
this.addTopicUseCase = fixture.Container.Resolve <IAddTopicUseCase>();
this.addCategoryUseCase = fixture.Container.Resolve <IAddCategoryUseCase>();
this.updateTopicUseCase = fixture.Container.Resolve <IUpdateTopicUseCase>();
this.removeTopicUseCase = fixture.Container.Resolve <IRemoveTopicUseCase>();
this.getAllTopicUseCase = fixture.Container.Resolve <IGetAllTopicUseCase>();
this.getByIdTopicUseCase = fixture.Container.Resolve <IGetByIdTopicUseCase>();
this.category = new Category("Teste1");
this.topic = new Topic("Topic1", category);
this.guid = new Guid();
this.topicController = new TopicController(addTopicUseCase,
getAllTopicUseCase,
getByIdTopicUseCase,
updateTopicUseCase,
removeTopicUseCase,
getByIdCategoryUseCase,
getByIdUserUseCase
);
}
public void TopicController_Put_WhenTheTopicIsUpdatedSuccessfully_WillReturnAnOKStatusAndASuccessMessage()
{
var controller = new TopicController(_topicsRepository.Object);
SetUpHttpRequestParameters(controller);
var response = controller.Put(new Topic
{
Name = "Visual Studio on a Mac",
Tutorials = new List <Tutorial> {
}
});
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
ExpandoObject expando;
Assert.IsTrue(response.TryGetContentValue(out expando));
var expandoDict = (IDictionary <string, object>)expando;
Assert.AreEqual("topic is updated successfully", expandoDict["message"]);
_topicsRepository.Verify(t => t.Update(It.IsAny <Topic>()), Times.Once());
_topicsRepository.Verify(c => c.Save(), Times.Once());
}
private TopicController CreateControllerWithChatyApiService(ChatyApiService chatyApiService)
{
var mockUrlHelper = CreateMockUrlHelper("http://dotnetclub/download/file");
var chatHistoryImporter = new DefaultChatHistoryImporter(new SystemClock(),
mockUrlHelper,
_app.GetService <IRepository <FileRecord> >(),
_app.GetService <IRepository <WeChatAccount> >(),
_app.GetService <IFileSystem>(),
_app.GetService <ICurrentUser>(),
chatyApiService);
var httpContext = new DefaultHttpContext
{
User = _app.User, RequestServices = _app.ApplicationServices
};
var topicController = new TopicController(
_app.GetService <IRepository <Topic> >(),
_app.GetService <ITopicService>(),
_app.GetService <ILogger <TopicController> >(),
chatHistoryImporter,
_app.GetService <IRepository <Reply> >(),
_app.GetService <IRepository <WeChatAccount> >(),
chatyApiService)
.WithHttpContext(httpContext);
topicController.Url = mockUrlHelper;
_app.GetService <IHttpContextAccessor>().HttpContext = httpContext;
return(topicController);
IUrlHelper CreateMockUrlHelper(string fileLink)
{
var urlHelper = new Mock <IUrlHelper>();
urlHelper.Setup(url => url.Action(It.IsAny <UrlActionContext>())).Returns(fileLink);
return(urlHelper.Object);
}
}
protected T GetController <T>() where T : PluginController
{
PluginController controller;
if (typeof(T) == typeof(DisciplineController))
{
controller = new DisciplineController(this.DisciplineStorage);
}
else if (typeof(T) == typeof(ChapterController))
{
controller = new ChapterController(this.DisciplineStorage);
}
else if (typeof(T) == typeof(TopicController))
{
controller = new TopicController(this.DisciplineStorage);
}
else if (typeof(T) == typeof(CurriculumController))
{
controller = new CurriculumController(this.CurriculumStorage);
}
else if (typeof(T) == typeof(CurriculumChapterController))
{
controller = new CurriculumChapterController(this.CurriculumStorage);
}
else if (typeof(T) == typeof(CurriculumChapterTopicController))
{
controller = new CurriculumChapterTopicController(this.CurriculumStorage);
}
else
{
throw new NotImplementedException();
}
var mocks = new ContextMocks(controller);
mocks.RouteData.Values["action"] = "Index";
mocks.RouteData.Values["controller"] = typeof(T).Name;
return((T)controller);
}
public async Task ValidPostRequestToTopicSubscriberResourceCreatesSubscription()
{
var mockSubscriptionTrackingService = new Mock <ISubscriptionTrackingService>();
mockSubscriptionTrackingService.Setup(sts =>
sts.AddSubscription(It.IsAny <TopicName>(), It.IsAny <Uri>(), It.IsAny <TimeSpan>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(true));
var topics = new TopicName[] { "topic-1", "topic-2", "topic-3" };
var controller = new TopicController(mockSubscriptionTrackingService.Object, topics);
var mockRequest = new Mock <IHttpResourceRequest>();
var encodedSubscriberUri = new UrlEncoder().Encode("http://example.com/platibus");
var requestUri = new UriBuilder
{
Scheme = "http",
Host = "localhost",
Path = "/platibus/topic/topic-1/subscriber",
Query = string.Format("uri={0}&ttl=3600", encodedSubscriberUri)
}.Uri;
mockRequest.Setup(r => r.HttpMethod).Returns("POST");
mockRequest.Setup(r => r.Url).Returns(requestUri);
mockRequest.Setup(r => r.QueryString).Returns(new NameValueCollection
{
{ "uri", "http://example.com/platibus" },
{ "ttl", "3600" }
});
var mockResponse = new Mock <IHttpResourceResponse>();
await controller.Process(mockRequest.Object, mockResponse.Object, new[] { "topic-1", "subscriber", encodedSubscriberUri });
mockResponse.VerifySet(r => r.StatusCode = 200);
mockSubscriptionTrackingService.Verify(ts => ts.AddSubscription(
"topic-1", new Uri("http://example.com/platibus"), TimeSpan.FromSeconds(3600),
It.IsAny <CancellationToken>()));
}
public async void CreateTopic_Returns_Ok()
{
var request = new SaveTopicViewModel
{
Title = "Test topic",
ThemeId = Guid.NewGuid()
};
var viewModel = new TopicViewModel
{
Id = Guid.NewGuid()
};
var topicService = new Mock <ITopicService>();
topicService.Setup(s => s.CreateTopic(request)).ReturnsAsync(viewModel);
var controller = new TopicController(topicService.Object);
var result = await controller.CreateTopic(request);
Assert.Equal(viewModel, result.Value);
}
