public void BasicActionTest() { //Setup Application Contact with mocks. Sets ApplicaitonContext.Current var appCtx = ApplicationContext.EnsureContext( new DatabaseContext(Mock.Of <IDatabaseFactory>(), Mock.Of <ILogger>(), new SqlSyntaxProviders(new[] { Mock.Of <ISqlSyntaxProvider>() })), new ServiceContext(), CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger( Mock.Of <ILogger>(), Mock.Of <IProfiler>()), true); //Setup UmbracoContext with mocks. Sets UmbracoContext.Current UmbracoContext.EnsureContext( Mock.Of <HttpContextBase>(), appCtx, new Mock <WebSecurity>(null, null).Object, Mock.Of <IUmbracoSettingsSection>(), Enumerable.Empty <IUrlProvider>(), true); var controller = new BasicTestSurfaceController(); var res = controller.BasicTestAction(); var model = res.Model as object; Assert.IsNotNull(model); }
public void HelperDynamicContentMediaTest() { var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); var contentName = "contentName"; var mediaName = "mediaName"; var contentId = 20; var mediaId = 30; //create content items to be returned var mediaItem = BasicHelpers.GetPublishedContentMock(name: mediaName, id: mediaId); var contentItem = BasicHelpers.GetPublishedContentMock(name: contentName, id: contentId); //we create a mock of the dynamic query, which is used internally by the Umbraco helper var mockedDynamicQuery = new Mock <IDynamicPublishedContentQuery>(); mockedDynamicQuery.Setup(s => s.Content(contentId)).Returns(contentItem.Object); mockedDynamicQuery.Setup(s => s.Media(mediaId)).Returns(mediaItem.Object); //give our dynamic query mock to the longer version of the UmbracoHelper constructor var helper = UmbracoUnitTestHelper.GetUmbracoHelper(ctx, dynamicQuery: mockedDynamicQuery.Object); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicDynamicContentMediaAction(contentId, mediaId); var model = res.Model as Tuple <string, string>; Assert.AreEqual(contentItem.Object.Name, model.Item1); Assert.AreEqual(mediaItem.Object.Name, model.Item2); }
public void HelperContentTypeTest() { var mocks = new MockServiceContext(); var appCtx = UmbracoUnitTestHelper.GetApplicationContext(serviceContext: mocks.ServiceContext); var ctx = UmbracoUnitTestHelper.GetUmbracoContext(appCtx); //pass in emtpy proprty types to avoid uninitialized resolver issue. To bypass, must use CoreBootManager UmbracoUnitTestHelper.SetupServicesForPublishedContentTypeResolution(mocks, new PropertyType[] { }); var alias = "test_alias"; var contentType = UmbracoUnitTestHelper.GetPublishedContentType(alias: alias); var contentId = 2; //get a mocked IPublishedContent var contentMock = UmbracoUnitTestHelper.GetPublishedContentMock(contentType: contentType); var mockedTypedQuery = new Mock <ITypedPublishedContentQuery>(); mockedTypedQuery.Setup(s => s.TypedContent(It.IsAny <int>())).Returns(contentMock.Object); //give our dynamic query mock to the longer version of the UmbracoHelper constructor var helper = UmbracoUnitTestHelper.GetUmbracoHelper(ctx, typedQuery: mockedTypedQuery.Object); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicContentTypeAction(contentId); var model = (string)res.Model; Assert.AreEqual(alias, model); }
public void BasicPublishedContent3Test() { var appCtx = ApplicationContext.EnsureContext( new DatabaseContext(Mock.Of <IDatabaseFactory>(), Mock.Of <ILogger>(), new SqlSyntaxProviders(new[] { Mock.Of <ISqlSyntaxProvider>() })), new ServiceContext(), CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger( Mock.Of <ILogger>(), Mock.Of <IProfiler>()), true); var ctx = UmbracoContext.EnsureContext( Mock.Of <HttpContextBase>(), appCtx, new Mock <WebSecurity>(null, null).Object, Mock.Of <IUmbracoSettingsSection>(), Enumerable.Empty <IUrlProvider>(), true); var test_name = "test"; //using a helper that I made to setup common fields var mockContent = BasicHelpers.GetPublishedContentMock(test_name); //setup umbracohelper.assignedcontentitem by setting the publishedcontent request of the umbracocontext ctx.PublishedContentRequest = new PublishedContentRequest(new Uri("http://test.com"), ctx.RoutingContext, Mock.Of <IWebRoutingSection>(section => section.UrlProviderMode == UrlProviderMode.AutoLegacy.ToString()), s => new string[] { }) { PublishedContent = mockContent.Object }; var res = new BasicTestSurfaceController().BasicPublishedContentAction(); var model = res.Model as string; Assert.AreEqual(test_name, model); }
public void BasicPublishedContent2Test() { var appCtx = ApplicationContext.EnsureContext( new DatabaseContext(Mock.Of <IDatabaseFactory>(), Mock.Of <ILogger>(), new SqlSyntaxProviders(new[] { Mock.Of <ISqlSyntaxProvider>() })), new ServiceContext(), CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger( Mock.Of <ILogger>(), Mock.Of <IProfiler>()), true); var ctx = UmbracoContext.EnsureContext( Mock.Of <HttpContextBase>(), appCtx, new Mock <WebSecurity>(null, null).Object, Mock.Of <IUmbracoSettingsSection>(), Enumerable.Empty <IUrlProvider>(), true); //instead of using the implemenation of IPublishedContent, we mock IPublishedContent var mockContent = new Mock <IPublishedContent>(); //We need to manually setup each field that is needed mockContent.Setup(s => s.Name).Returns("test"); //give our content to the umbraco helper which will be given to the controller var helper = new UmbracoHelper(ctx, mockContent.Object); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicPublishedContentAction(); var model = res.Model as string; Assert.IsNotNull(mockContent.Object.Name, model); }
public void BasicPublishedContent1Test() { var appCtx = ApplicationContext.EnsureContext( new DatabaseContext(Mock.Of <IDatabaseFactory>(), Mock.Of <ILogger>(), new SqlSyntaxProviders(new[] { Mock.Of <ISqlSyntaxProvider>() })), new ServiceContext(), CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger( Mock.Of <ILogger>(), Mock.Of <IProfiler>()), true); var ctx = UmbracoContext.EnsureContext( Mock.Of <HttpContextBase>(), appCtx, new Mock <WebSecurity>(null, null).Object, Mock.Of <IUmbracoSettingsSection>(), Enumerable.Empty <IUrlProvider>(), true); var test_name = "test"; //create an instance of our test implemention of IPublisheContent var content = new TestPublishedContent() { Name = test_name }; //setup a helper object which will be given to the surface controller var helper = new UmbracoHelper(ctx, content); //we use a surface controller that takes in th context and helper so that we can setup them for our needs var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicPublishedContentAction(); var model = res.Model as string; Assert.AreEqual(test_name, model); }
public void NuGetEngineActionTest() { //Now we can run a basic situation with no Umbraco boilerplate! var controller = new BasicTestSurfaceController(); var res = controller.BasicTestAction(); var model = res.Model as object; Assert.IsNotNull(model); }
public void EnginePublishedContent1Test() { var content = _unitTestEngine.WithCurrentPage("Test"); //Setup UmbracoContext with mocks. Sets UmbracoContext.Current var controller = new BasicTestSurfaceController(_unitTestEngine.UmbracoContext, _unitTestEngine.UmbracoHelper); var res = controller.BasicPublishedContentAction(); var model = res.Model as string; Assert.AreEqual(content.Name, model); }
public void EngineRelationTypeAliasTest() { var relation = _unitTestEngine.WithRelation(); var controller = new BasicTestSurfaceController(_unitTestEngine.UmbracoContext, _unitTestEngine.UmbracoHelper); var res = controller.RelationAliasAction(relation.RelationType.Alias); var model = (int)res.Model; Assert.AreEqual(relation.Id, model); }
public void EnginePositionTest() { var content = _unitTestEngine.WithPublishedContentPage(index: 1); var controller = new BasicTestSurfaceController(_unitTestEngine.UmbracoContext, _unitTestEngine.UmbracoHelper); var res = controller.BasicPositionAction(content.Id); var model = (bool)res.Model; Assert.IsFalse(model); }
public void HelperActionTest() { //Setup UmbracoContext with mocks. Sets UmbracoContext.Current var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); var controller = new BasicTestSurfaceController(); var res = controller.BasicTestAction(); var model = res.Model as object; Assert.IsNotNull(model); }
public void EngineContentTypeTest() { var content = _unitTestEngine.WithPublishedContentPage(contentType: _unitTestEngine.WithPublishedContentType()); var controller = new BasicTestSurfaceController(_unitTestEngine.UmbracoContext, _unitTestEngine.UmbracoHelper); _unitTestEngine.RegisterController(controller); var res = controller.BasicContentTypeAction(content.Id); var model = (string)res.Model; Assert.AreEqual(content.ContentType.Alias, model); }
public void EngineCurrentPageTest() { var content = _unitTestEngine.WithCurrentPage("Test"); var controller = new BasicTestSurfaceController(); _unitTestEngine.RegisterController(controller); var res = controller.BasicCurrentPageAction(); var model = res.Model as string; Assert.AreEqual(content.Name, model); }
public void EngineGetPropertyValueTypeTest() { var value = "testValue"; var alias = "testAlias"; var content = _unitTestEngine.WithPublishedContentPage(properties: new[] { UmbracoUnitTestHelper.GetPublishedProperty(value: value, alias: alias) }); var controller = new BasicTestSurfaceController(_unitTestEngine.UmbracoContext, _unitTestEngine.UmbracoHelper); var res = controller.BasicGetPropertyValueTypeAction(content.Id, content.Properties.First().PropertyTypeAlias); var model = (string)res.Model; Assert.AreEqual(content.Properties.First().Value, model); }
public void BasicGetPropertyTest() { var appCtx = ApplicationContext.EnsureContext( new DatabaseContext(Mock.Of <IDatabaseFactory>(), Mock.Of <ILogger>(), new SqlSyntaxProviders(new[] { Mock.Of <ISqlSyntaxProvider>() })), new ServiceContext(), CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger( Mock.Of <ILogger>(), Mock.Of <IProfiler>()), true); var ctx = UmbracoContext.EnsureContext( Mock.Of <HttpContextBase>(), appCtx, new Mock <WebSecurity>(null, null).Object, Mock.Of <IUmbracoSettingsSection>(), Enumerable.Empty <IUrlProvider>(), true); string propertyName = "testProp"; string propValue = "testValue"; var propertyMock = new Mock <IPublishedProperty>(); propertyMock.Setup(s => s.Value).Returns(propValue); var contentId = 2; //get a mocked IPublishedContent var contentMock = BasicHelpers.GetPublishedContentMock(); contentMock.Setup(s => s.GetProperty(propertyName)).Returns(propertyMock.Object); var mockedTypedQuery = new Mock <ITypedPublishedContentQuery>(); mockedTypedQuery.Setup(s => s.TypedContent(contentId)).Returns(contentMock.Object); //give our dynamic query mock to the longer version of the UmbracoHelper constructor var helper = new UmbracoHelper(ctx, Mock.Of <IPublishedContent>(), mockedTypedQuery.Object, Mock.Of <IDynamicPublishedContentQuery>(), Mock.Of <ITagQuery>(), Mock.Of <IDataTypeService>(), new UrlProvider(ctx, Mock.Of <IWebRoutingSection>(section => section.UrlProviderMode == UrlProviderMode.Auto.ToString()), new[] { Mock.Of <IUrlProvider>() }), Mock.Of <ICultureDictionary>(), Mock.Of <IUmbracoComponentRenderer>(), new MembershipHelper(ctx, Mock.Of <MembershipProvider>(), Mock.Of <RoleProvider>())); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicGetPropertyAction(contentId, propertyName); var model = (string)res.Model; Assert.AreEqual(propValue, model); }
public void BasicCurrentPageTest() { var appCtx = ApplicationContext.EnsureContext( new DatabaseContext(Mock.Of <IDatabaseFactory>(), Mock.Of <ILogger>(), new SqlSyntaxProviders(new[] { Mock.Of <ISqlSyntaxProvider>() })), new ServiceContext(), CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger( Mock.Of <ILogger>(), Mock.Of <IProfiler>()), true); var ctx = UmbracoContext.EnsureContext( Mock.Of <HttpContextBase>(), appCtx, new Mock <WebSecurity>(null, null).Object, Mock.Of <IUmbracoSettingsSection>(), Enumerable.Empty <IUrlProvider>(), true); var contentMock = new Mock <IPublishedContent>(); contentMock.Setup(s => s.Name).Returns("test"); var content = contentMock.Object; //setup published content request. This sets the current content on the Umbraco Context and will be used later ctx.PublishedContentRequest = new PublishedContentRequest(new Uri("http://test.com"), ctx.RoutingContext, Mock.Of <IWebRoutingSection>(section => section.UrlProviderMode == UrlProviderMode.AutoLegacy.ToString()), s => new string[] { }) { PublishedContent = content }; //The reoute definition will contain the current page request object and be passed into the route data var routeDefinition = new RouteDefinition { PublishedContentRequest = ctx.PublishedContentRequest }; //We create a route data object to be given to the Controller context var routeData = new RouteData(); routeData.DataTokens.Add("umbraco-route-def", routeDefinition); var controller = new BasicTestSurfaceController(); //Setting the controller context will provide the route data, route def, publushed content request, and current page to the surface controller controller.ControllerContext = new System.Web.Mvc.ControllerContext(ctx.HttpContext, routeData, controller); var res = controller.BasicCurrentPageAction(); var model = res.Model as string; Assert.AreEqual(content.Name, model); }
public void HelperPublishedContent3Test() { var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); var mockContent = UmbracoUnitTestHelper.GetPublishedContentMock(name: "test"); UmbracoUnitTestHelper.SetPublishedContentRequest(ctx, UmbracoUnitTestHelper.GetPublishedContentRequest(ctx, currentContent: mockContent.Object)); var res = new BasicTestSurfaceController().BasicPublishedContentAction(); var model = res.Model as string; Assert.AreEqual(mockContent.Object.Name, model); }
public void EngineDynamicContentMediaTest() { //Auto fixture will take care of the name and unit test engine will assign an ID var content = _unitTestEngine.WithPublishedContentPage(); var media = _unitTestEngine.WithPublishedMedia(); var controller = new BasicTestSurfaceController(_unitTestEngine.UmbracoContext, _unitTestEngine.UmbracoHelper); var res = controller.BasicDynamicContentMediaAction(content.Id, media.Id); var model = res.Model as Tuple <string, string>; Assert.AreEqual(content.Name, model.Item1); Assert.AreEqual(media.Name, model.Item2); }
public void EngineHasPropertyTest() { string propertyName = "testProp"; var content = _unitTestEngine.WithPublishedContentPage(contentType: _unitTestEngine.WithPublishedContentType(propertyTypes: new[] { UmbracoUnitTestHelper.GetPropertyType(alias: propertyName) })); var controller = new BasicTestSurfaceController(_unitTestEngine.UmbracoContext, _unitTestEngine.UmbracoHelper); _unitTestEngine.RegisterController(controller); var res = controller.BasicHasPropertyAction(content.Id, propertyName); var model = (bool)res.Model; Assert.IsTrue(model); }
public void BasicDynamicContentMediaTest() { var appCtx = ApplicationContext.EnsureContext( new DatabaseContext(Mock.Of <IDatabaseFactory>(), Mock.Of <ILogger>(), new SqlSyntaxProviders(new[] { Mock.Of <ISqlSyntaxProvider>() })), new ServiceContext(), CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger( Mock.Of <ILogger>(), Mock.Of <IProfiler>()), true); var ctx = UmbracoContext.EnsureContext( Mock.Of <HttpContextBase>(), appCtx, new Mock <WebSecurity>(null, null).Object, Mock.Of <IUmbracoSettingsSection>(), Enumerable.Empty <IUrlProvider>(), true); var contentName = "contentName"; var mediaName = "mediaName"; var contentId = 20; var mediaId = 30; //create content items to be returned var mediaItem = BasicHelpers.GetPublishedContentMock(name: mediaName, id: mediaId); var contentItem = BasicHelpers.GetPublishedContentMock(name: contentName, id: contentId); //we create a mock of the dynamic query, which is used internally by the Umbraco helper var mockedDynamicQuery = new Mock <IDynamicPublishedContentQuery>(); mockedDynamicQuery.Setup(s => s.Content(contentId)).Returns(contentItem.Object); mockedDynamicQuery.Setup(s => s.Media(mediaId)).Returns(mediaItem.Object); //give our dynamic query mock to the longer version of the UmbracoHelper constructor var helper = new UmbracoHelper(ctx, Mock.Of <IPublishedContent>(), Mock.Of <ITypedPublishedContentQuery>(), mockedDynamicQuery.Object, Mock.Of <ITagQuery>(), Mock.Of <IDataTypeService>(), new UrlProvider(ctx, Mock.Of <IWebRoutingSection>(section => section.UrlProviderMode == UrlProviderMode.Auto.ToString()), new[] { Mock.Of <IUrlProvider>() }), Mock.Of <ICultureDictionary>(), Mock.Of <IUmbracoComponentRenderer>(), new MembershipHelper(ctx, Mock.Of <MembershipProvider>(), Mock.Of <RoleProvider>())); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicDynamicContentMediaAction(contentId, mediaId); var model = res.Model as Tuple <string, string>; Assert.AreEqual(contentItem.Object.Name, model.Item1); Assert.AreEqual(mediaItem.Object.Name, model.Item2); }
public void BasicDictionaryTest() { var appCtx = ApplicationContext.EnsureContext( new DatabaseContext(Mock.Of <IDatabaseFactory>(), Mock.Of <ILogger>(), new SqlSyntaxProviders(new[] { Mock.Of <ISqlSyntaxProvider>() })), new ServiceContext(), CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger( Mock.Of <ILogger>(), Mock.Of <IProfiler>()), true); var ctx = UmbracoContext.EnsureContext( Mock.Of <HttpContextBase>(), appCtx, new Mock <WebSecurity>(null, null).Object, Mock.Of <IUmbracoSettingsSection>(), Enumerable.Empty <IUrlProvider>(), true); //Set ApplicationContext and UmbracoContext var test_value = "test"; var valueDict = new Dictionary <string, string>() { { "Test Key", test_value } }; //we can create a mock of the culture dictionary interface and set any value we want var mockDict = new Mock <ICultureDictionary>(); //setup our mock dictionary to passthrough to our local dictionary mockDict.Setup(s => s[It.IsAny <string>()]).Returns <string>(key => valueDict[key]); //This time we use the larger constructor for the Helper. In ther we will set the dictionary that we mocked var helper = new UmbracoHelper(ctx, Mock.Of <IPublishedContent>(), Mock.Of <ITypedPublishedContentQuery>(), Mock.Of <IDynamicPublishedContentQuery>(), Mock.Of <ITagQuery>(), Mock.Of <IDataTypeService>(), new UrlProvider(ctx, Mock.Of <IWebRoutingSection>(section => section.UrlProviderMode == UrlProviderMode.Auto.ToString()), new[] { Mock.Of <IUrlProvider>() }), mockDict.Object, //<--- set the dictionary Mock.Of <IUmbracoComponentRenderer>(), new MembershipHelper(ctx, Mock.Of <MembershipProvider>(), Mock.Of <RoleProvider>())); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicDictionaryAction(); var model = res.Model as string; Assert.AreEqual(test_value, model); }
public void NuGetEngineDictionaryTest() { var key = "Test Key"; var value = "test"; _unitTestEngine.WithDictionaryValue(key, value); var controller = new BasicTestSurfaceController(_unitTestEngine.UmbracoContext, _unitTestEngine.UmbracoHelper); _unitTestEngine.RegisterController(controller); var res = controller.BasicDictionaryAction(); var model = res.Model as string; Assert.AreEqual(value, model); }
public void HelperPublishedContent2Test() { //Setup UmbracoContext with mocks. Sets UmbracoContext.Current var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); //instead of using the implemenation of IPublishedContent, we mock IPublishedContent var mockContent = UmbracoUnitTestHelper.GetPublishedContentMock(name: "test").Object; //give our content to the umbraco helper which will be given to the controller var helper = UmbracoUnitTestHelper.GetUmbracoHelper(ctx, content: mockContent); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicPublishedContentAction(); var model = res.Model as string; Assert.IsNotNull(mockContent.Name, model); }
public void BasicTypedSearchActionTest() { var appCtx = ApplicationContext.EnsureContext( new DatabaseContext(Mock.Of <IDatabaseFactory>(), Mock.Of <ILogger>(), new SqlSyntaxProviders(new[] { Mock.Of <ISqlSyntaxProvider>() })), new ServiceContext(), CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger( Mock.Of <ILogger>(), Mock.Of <IProfiler>()), true); var ctx = UmbracoContext.EnsureContext( Mock.Of <HttpContextBase>(), appCtx, new Mock <WebSecurity>(null, null).Object, Mock.Of <IUmbracoSettingsSection>(), Enumerable.Empty <IUrlProvider>(), true); var searchTerm = "test"; //Create some content to be returned by search var searchItems = new IPublishedContent[] { BasicHelpers.GetPublishedContent(), BasicHelpers.GetPublishedContent() }; //mock the search call of the typed query var mockedTypedQuery = new Mock <ITypedPublishedContentQuery>(); mockedTypedQuery.Setup(s => s.TypedSearch(searchTerm, true, null)).Returns(searchItems); //give our typed query mock to the longer version of the UmbracoHelper constructor var helper = new UmbracoHelper(ctx, Mock.Of <IPublishedContent>(), mockedTypedQuery.Object, Mock.Of <IDynamicPublishedContentQuery>(), Mock.Of <ITagQuery>(), Mock.Of <IDataTypeService>(), new UrlProvider(ctx, Mock.Of <IWebRoutingSection>(section => section.UrlProviderMode == UrlProviderMode.Auto.ToString()), new[] { Mock.Of <IUrlProvider>() }), Mock.Of <ICultureDictionary>(), Mock.Of <IUmbracoComponentRenderer>(), new MembershipHelper(ctx, Mock.Of <MembershipProvider>(), Mock.Of <RoleProvider>())); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicTypedSearchAction(searchTerm); var model = (int)res.Model; Assert.AreEqual(searchItems.Count(), model); }
public void HelperPublishedContent1Test() { //Setup UmbracoContext with mocks. Sets UmbracoContext.Current var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); //create an instance of our test implemention of IPublisheContent var content = new TestPublishedContent() { Name = "test" }; //setup a helper object which will be given to the surface controller var helper = UmbracoUnitTestHelper.GetUmbracoHelper(context: ctx, content: content); //we use a surface controller that takes in th context and helper so that we can setup them for our needs var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicPublishedContentAction(); var model = res.Model as string; Assert.AreEqual(content.Name, model); }
public void HelperCurrentPageTest() { //Setup UmbracoContext with mocks. Sets UmbracoContext.Current var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); var content = new TestPublishedContent() { Name = "test" }; var controller = new BasicTestSurfaceController(); //Setting the controller context will provide the route data, route def, publushed content request, and current page to the surface controller controller.ControllerContext = UmbracoUnitTestHelper.GetControllerContext(ctx, controller, UmbracoUnitTestHelper.GetPublishedContentRequest(ctx, currentContent: content)); var res = controller.BasicCurrentPageAction(); var model = res.Model as string; Assert.AreEqual(content.Name, model); }
public void HelperPositionTest() { var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); var contentId = 2; //get a mocked IPublishedContent var contentMock = UmbracoUnitTestHelper.GetPublishedContentMock(index: 1); var mockedTypedQuery = new Mock <ITypedPublishedContentQuery>(); mockedTypedQuery.Setup(s => s.TypedContent(contentId)).Returns(contentMock.Object); //give our dynamic query mock to the longer version of the UmbracoHelper constructor var helper = UmbracoUnitTestHelper.GetUmbracoHelper(ctx, typedQuery: mockedTypedQuery.Object); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicPositionAction(contentId); var model = (bool)res.Model; Assert.IsFalse(model); }
public void HelperGetPropertyTest() { var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); var contentId = 2; //get a mocked IPublishedContent var contentMock = UmbracoUnitTestHelper.GetPublishedContentMock(properties: new[] { UmbracoUnitTestHelper.GetPublishedProperty(value: "testValue", alias: "testProp") }); var mockedTypedQuery = new Mock <ITypedPublishedContentQuery>(); mockedTypedQuery.Setup(s => s.TypedContent(contentId)).Returns(contentMock.Object); //give our dynamic query mock to the longer version of the UmbracoHelper constructor var helper = UmbracoUnitTestHelper.GetUmbracoHelper(ctx, typedQuery: mockedTypedQuery.Object); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicGetPropertyAction(contentId, contentMock.Object.Properties.First().PropertyTypeAlias); var model = (string)res.Model; Assert.AreEqual(contentMock.Object.Properties.First().Value, model); }
public void HelperTypedSearchActionTest() { var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); var searchTerm = "test"; //Create some content to be returned by search var searchItems = new IPublishedContent[] { BasicHelpers.GetPublishedContent(), BasicHelpers.GetPublishedContent() }; //mock the search call of the typed query var mockedTypedQuery = new Mock <ITypedPublishedContentQuery>(); mockedTypedQuery.Setup(s => s.TypedSearch(searchTerm, true, null)).Returns(searchItems); //give our typed query mock to the longer version of the UmbracoHelper constructor var helper = UmbracoUnitTestHelper.GetUmbracoHelper(ctx, typedQuery: mockedTypedQuery.Object); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicTypedSearchAction(searchTerm); var model = (int)res.Model; Assert.AreEqual(searchItems.Count(), model); }
public void HelperDictionaryTest() { var ctx = UmbracoUnitTestHelper.GetUmbracoContext(); var valueDict = new Dictionary <string, string>() { { "Test Key", "test" } }; //we can create a mock of the culture dictionary interface and set any value we want var mockDict = new Mock <ICultureDictionary>(); //setup our mock dictionary to passthrough to our local dictionary mockDict.Setup(s => s[It.IsAny <string>()]).Returns <string>(key => valueDict[key]); var helper = UmbracoUnitTestHelper.GetUmbracoHelper(ctx, cultureDictionary: mockDict.Object); var controller = new BasicTestSurfaceController(ctx, helper); var res = controller.BasicDictionaryAction(); var model = res.Model as string; Assert.AreEqual(valueDict["Test Key"], model); }