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