public void DynamicWidgets_ChildWidget_DisplayHotelsFromCurrentlyOpenedCityWithoutCityWidget()
{
string hotelSuff;
string citySuff;
string url;
string responseContent;
try
{
var hotelsWidget = this.CreateMvcWidget(ResolveTypeHotel, WidgetNameHotels, ParentFilterMode.CurrentlyOpen, ResolveTypeCity);
var controls = new List <System.Web.UI.Control>();
controls.Add(hotelsWidget);
PageContentGenerator.AddControlsToPage(this.pageId, controls);
for (int i = 1; i <= 3; i++)
{
citySuff = i.ToString(CultureInfo.InvariantCulture);
url = UrlPath.ResolveAbsoluteUrl("~/" + PageName + "/country1/country1city" + citySuff);
responseContent = PageInvoker.ExecuteWebRequest(url);
for (int j = 1; j <= 3; j++)
{
hotelSuff = j.ToString(CultureInfo.InvariantCulture);
Assert.IsTrue(responseContent.Contains("Country1City" + citySuff + "Hotel" + hotelSuff), "The dynamic item with this title was NOT found: Country1City" + citySuff + "Hotel" + hotelSuff);
}
}
}
finally
{
ServerOperations.Pages().DeleteAllPages();
}
}
public void DynamicWidgets_HierarchicalWidgetsOnPage_DisplayHotelsFromCurrentlyOpenedCity()
{
string url;
string responseContent;
string suff;
try
{
var countriesWidget = this.CreateMvcWidget(ResolveTypeCountry, WidgetNameCountries);
var citiesWidget = this.CreateMvcWidget(ResolveTypeCity, WidgetNameCities, ParentFilterMode.CurrentlyOpen, ResolveTypeCountry);
var hotelsWidget = this.CreateMvcWidget(ResolveTypeHotel, WidgetNameHotels, ParentFilterMode.CurrentlyOpen, ResolveTypeCity);
var controls = new List <System.Web.UI.Control>();
controls.Add(countriesWidget);
controls.Add(citiesWidget);
controls.Add(hotelsWidget);
PageContentGenerator.AddControlsToPage(this.pageId, controls);
url = UrlPath.ResolveAbsoluteUrl("~/" + PageName + "/country1/country1city1");
responseContent = PageInvoker.ExecuteWebRequest(url);
for (int i = 1; i <= 3; i++)
{
suff = i.ToString(CultureInfo.InvariantCulture);
Assert.IsTrue(responseContent.Contains("Country1City1Hotel" + suff), "The dynamic item with this title was NOT found: Country1City1Hotel" + suff);
Assert.IsFalse(responseContent.Contains("Country1City2Hotel" + suff), "The dynamic item with this title was found: Country1City2Hotel" + suff);
Assert.IsFalse(responseContent.Contains("Country1City3Hotel" + suff), "The dynamic item with this title was found: Country1City3Hotel" + suff);
}
url = UrlPath.ResolveAbsoluteUrl("~/" + PageName + "/country1/country1city2");
responseContent = PageInvoker.ExecuteWebRequest(url);
for (int i = 1; i <= 3; i++)
{
suff = i.ToString(CultureInfo.InvariantCulture);
Assert.IsTrue(responseContent.Contains("Country1City2Hotel" + suff), "The dynamic item with this title was NOT found: Country1City2Hotel" + suff);
Assert.IsFalse(responseContent.Contains("Country1City1Hotel" + suff), "The dynamic item with this title was found: Country1City1Hotel" + suff);
Assert.IsFalse(responseContent.Contains("Country1City3Hotel" + suff), "The dynamic item with this title was found: Country1City3Hotel" + suff);
}
url = UrlPath.ResolveAbsoluteUrl("~/" + PageName + "/country2/country2city2");
responseContent = PageInvoker.ExecuteWebRequest(url);
for (int i = 1; i <= 3; i++)
{
suff = i.ToString(CultureInfo.InvariantCulture);
Assert.IsFalse(responseContent.Contains("Country2City1Hotel" + suff), "The dynamic item with this title was found: Country2City1Hotel" + suff);
Assert.IsTrue(responseContent.Contains("Country2City2Hotel" + suff), "The dynamic item with this title was NOT found: Country2City2Hotel" + suff);
Assert.IsFalse(responseContent.Contains("Country2City3Hotel" + suff), "The dynamic item with this title was found: Country2City3Hotel" + suff);
}
}
finally
{
ServerOperations.Pages().DeleteAllPages();
}
}
public void NewsWidget_VerifyOpenSingleItemInSamePage()
{
string testName = System.Reflection.MethodInfo.GetCurrentMethod().Name;
string pageNamePrefix = testName + "NewsPage";
string pageTitlePrefix = testName + "News Page";
string urlNamePrefix = testName + "news-page";
int pageIndex = 1;
string pageUrl = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + pageIndex);
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(NewsController).FullName;
var newsController = new NewsController();
newsController.OpenInSamePage = true;
mvcProxy.Settings = new ControllerSettings(newsController);
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, pageIndex);
var items = newsController.Model.CreateListViewModel(null, 1).Items.ToArray();
Assert.AreEqual(this.newsCount, items.Length, "The count of the news item is not as expected");
var expectedDetailNews = (NewsItem)items[0].DataItem;
string detailNewsUrl = pageUrl + expectedDetailNews.ItemDefaultUrl;
ActionExecutionRegister.ExecutedActionInfos.Clear();
PageInvoker.ExecuteWebRequest(detailNewsUrl);
this.AssertDetailActionInvokation(expectedDetailNews);
}
public void NewsWidget_OnBootstrapPageTemplate()
{
string templateName = "Bootstrap.defaultNew3";
string placeHolder = "Contentplaceholder1";
string url = UrlPath.ResolveAbsoluteUrl("~/" + UrlNamePrefix);
Guid templateId = default(Guid);
try
{
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(NewsController).FullName;
var newsController = new NewsController();
mvcProxy.Settings = new ControllerSettings(newsController);
templateId = this.templateOperation.DuplicatePageTemplate(OldTemplateName, templateName);
this.templateOperation.AddControlToTemplate(templateId, mvcProxy, placeHolder, CaptionNews);
Guid pageId = this.locationGenerator.CreatePage(PageNamePrefix, PageTitlePrefix, UrlNamePrefix, null, null);
Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.Templates().SetTemplateToPage(pageId, templateId);
Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.News().CreateNewsItem(NewsTitle);
string responseContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsTrue(responseContent.Contains(NewsTitle), "The news with this title was not found!");
}
finally
{
Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.Pages().DeleteAllPages();
Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.Templates().DeletePageTemplate(templateId);
}
}
public void ContentBlockWidget_ValidateOnEditPage()
{
string testName = "ContentBlockWidgetEditSharedContent";
string pageNamePrefix = testName + "ContentBlockPage";
string pageTitlePrefix = testName + "Content Block";
string urlNamePrefix = testName + "content-block";
int pageIndex = 1;
var content = App.WorkWith().ContentItems()
.Where(c => c.Title == ContentBlockTitle && c.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master)
.Get().Single();
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(ContentBlockController).FullName;
var contentBlockController = new ContentBlockController();
contentBlockController.SharedContentID = content.Id;
mvcProxy.Settings = new ControllerSettings(contentBlockController);
var pageId = this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, pageIndex);
PageManager manager = PageManager.GetManager();
var page = manager.GetPageNode(pageId);
var pageUrl = page.GetFullUrl();
pageUrl = RouteHelper.GetAbsoluteUrl(pageUrl) + "/Action/Edit";
string responseContent = PageInvoker.ExecuteWebRequest(pageUrl);
Assert.IsTrue(responseContent.Contains(ContentBlockContent), "The content block with this text was not found!");
}
public void ContentBlockWidget_EditSharedContent()
{
string testName = "ContentBlockWidgetEditSharedContent";
string pageNamePrefix = testName + "ContentBlockPage";
string pageTitlePrefix = testName + "Content Block";
string urlNamePrefix = testName + "content-block";
int pageIndex = 1;
string url = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + pageIndex);
var content = App.WorkWith().ContentItems()
.Where(c => c.Title == ContentBlockTitle && c.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master)
.Get().Single();
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(ContentBlockController).FullName;
var contentBlockController = new ContentBlockController();
contentBlockController.SharedContentID = content.Id;
mvcProxy.Settings = new ControllerSettings(contentBlockController);
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, pageIndex);
App.WorkWith().ContentItem(content.Id).CheckOut().Do(cI =>
{
cI.Content = ContentBlockContentEdited;
cI.LastModified = DateTime.UtcNow;
})
.CheckIn().Publish().SaveChanges();
string responseContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsTrue(responseContent.Contains(ContentBlockContentEdited), "The content block with this title was not found!");
}
public void EventWidget_VerifyOpenSingleItemInSamePage()
{
string testName = System.Reflection.MethodInfo.GetCurrentMethod().Name;
string pageNamePrefix = testName + "EventsPage";
string pageTitlePrefix = testName + "Events Page";
string urlNamePrefix = testName + "events-page";
int pageIndex = 1;
string pageUrl = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + pageIndex);
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(EventController).FullName;
var eventController = new EventController();
eventController.OpenInSamePage = true;
mvcProxy.Settings = new ControllerSettings(eventController);
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, pageIndex);
var items = eventController.Model.CreateListViewModel(null, 1).Items.ToArray();
Assert.AreEqual(EventWidgetDetailSettingsTests.EventsCount, items.Length, "The count of the events is not as expected");
var expectedDetailEvent = (Event)items[0].DataItem;
string expectedDetailEventUrl = pageUrl + expectedDetailEvent.ItemDefaultUrl;
string responseContent = PageInvoker.ExecuteWebRequest(pageUrl);
Assert.IsTrue(responseContent.Contains(expectedDetailEventUrl), "The expected details event url was not found!");
}
public void ContentBlockWidget_AdvancedSettings()
{
string testName = "ContentBlockWidgetAdvancedSettings";
string pageNamePrefix = testName + "ContentBlockPage";
string pageTitlePrefix = testName + "Content Block";
string urlNamePrefix = testName + "content-block";
int pageIndex = 1;
string url = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + pageIndex);
var content = App.WorkWith().ContentItems()
.Published()
.Where(c => c.Title == ContentBlockTitle)
.Get().Single();
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(ContentBlockController).FullName;
var contentBlockController = new ContentBlockController();
contentBlockController.SharedContentID = content.Id;
mvcProxy.Settings = new ControllerSettings(contentBlockController);
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, pageIndex);
string responseContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsTrue(responseContent.Contains(ContentBlockContent), "The content block with this title was not found!");
}
private void VerifyCorrectItemsOnPages(MvcControllerProxy mvcProxy, string pageNamePrefix, string pageTitlePrefix, string urlNamePrefix, int index, string url, string url2, string url3, string[] selectedDynamicTitles)
{
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, index);
string responseContent = PageInvoker.ExecuteWebRequest(url);
string responseContent2 = PageInvoker.ExecuteWebRequest(url2);
string responseContent3 = PageInvoker.ExecuteWebRequest(url3);
for (int i = 0; i < selectedDynamicTitles.Count(); i++)
{
if (i <= 2)
{
Assert.IsTrue(responseContent.Contains(selectedDynamicTitles[i]), "The items with this title was not found!");
Assert.IsFalse(responseContent2.Contains(selectedDynamicTitles[i]), "The items with this title was found!");
Assert.IsFalse(responseContent3.Contains(selectedDynamicTitles[i]), "The items with this title was found!");
}
else if (i > 2 && i <= selectedDynamicTitles.Count() - 4)
{
Assert.IsTrue(responseContent2.Contains(selectedDynamicTitles[i]), "The items with this title was not found!");
Assert.IsFalse(responseContent.Contains(selectedDynamicTitles[i]), "The items with this title was found!");
Assert.IsFalse(responseContent3.Contains(selectedDynamicTitles[i]), "The items with this title was found!");
}
else
{
Assert.IsTrue(responseContent3.Contains(selectedDynamicTitles[i]), "The items with this title was not found!");
Assert.IsFalse(responseContent.Contains(selectedDynamicTitles[i]), "The items with this title was found!");
Assert.IsFalse(responseContent2.Contains(selectedDynamicTitles[i]), "The items with this title was found!");
}
}
}
public void BlogsWidget_DisplayBlogsWithMoreThan_0_Posts()
{
string blog1Title = "Blog1";
string blog2Title = "Blog2";
string pageTitle = "PageWithBlogsWidget";
string blog1PostTitle = "Blog1_PublishedPost";
try
{
Guid blog1Id = ServerOperations.Blogs().CreateBlog(blog1Title);
ServerOperations.Blogs().CreatePublishedBlogPost(blog1PostTitle, blog1Id);
ServerOperations.Blogs().CreateBlog(blog2Title);
Guid pageId = ServerOperations.Pages().CreatePage(pageTitle);
var blogsWidget = this.CreateBlogsMvcWidgetFilteredSelectionMode(FilteredSelectionMode.MinPostsCount, minPostsCount: 0, maxPostsAge: 1);
var controls = new List <System.Web.UI.Control>();
controls.Add(blogsWidget);
PageContentGenerator.AddControlsToPage(pageId, controls);
string url = UrlPath.ResolveAbsoluteUrl("~/" + pageTitle);
string responseContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsTrue(responseContent.Contains(blog1Title), "The item with this title was NOT found " + blog1Title);
Assert.IsFalse(responseContent.Contains(blog2Title), "The item with this title WAS found " + blog2Title);
}
finally
{
ServerOperations.Pages().DeleteAllPages();
ServerOperations.Blogs().DeleteAllBlogs();
}
}
private void VerifyCorrectNewsOnPageWithUseLimitsOption(MvcControllerProxy mvcProxy, string pageNamePrefix, string pageTitlePrefix, string urlNamePrefix, int index, string url, string[] selectedNewsTitles)
{
try
{
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, index);
string responseContent = PageInvoker.ExecuteWebRequest(url);
for (int i = 0; i < selectedNewsTitles.Count(); i++)
{
if (i <= 4)
{
Assert.IsTrue(responseContent.Contains(selectedNewsTitles[i]), "The news with this title was not found!");
}
else
{
Assert.IsFalse(responseContent.Contains(selectedNewsTitles[i]), "The news with this title was found!");
}
}
}
finally
{
this.pageOperations.DeletePages();
}
}
public void Logout_WithPageIdAndRedirectUrl_VerifyLogoutRedirectUrlIsCorrect()
{
string expectedLogoutUrl = "www.telerik.com";
string logoutStatusPageUrl = UrlPath.ResolveAbsoluteUrl("~/" + this.urlNamePrefix + this.pageIndex);
var basicPageOperations = new Telerik.Sitefinity.TestUtilities.CommonOperations.PagesOperations();
var pageTitle = "Page Title1";
var pageUrl = "PageTitle1";
try
{
var logoutPageId = basicPageOperations.CreatePage(pageTitle, pageUrl);
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(LoginStatusController).FullName;
var loginStatusController = new LoginStatusController();
loginStatusController.Model.LogoutPageId = logoutPageId;
loginStatusController.Model.ExternalLogoutUrl = expectedLogoutUrl;
mvcProxy.Settings = new ControllerSettings(loginStatusController);
this.pageOperations.CreatePageWithControl(mvcProxy, this.pageNamePrefix, this.pageTitlePrefix, this.urlNamePrefix, this.pageIndex);
var responseContent = PageInvoker.ExecuteWebRequest(logoutStatusPageUrl);
Assert.IsTrue(responseContent.Contains(expectedLogoutUrl), "Logout redirect url is not as expected");
}
finally
{
basicPageOperations.DeleteAllPages();
}
}
public void BlogPostsWidget_DisplaySelectedBlogPosts()
{
string blogTitle = "Blog";
string blogPost1Title = "BlogPost1";
string blogPost2Title = "BlogPost2";
string pageTitle = "PageWithBlogPostsWidget";
try
{
Guid blogId = ServerOperations.Blogs().CreateBlog(blogTitle);
Guid post1Id = ServerOperations.Blogs().CreatePublishedBlogPost(blogPost1Title, blogId);
Guid pageId = ServerOperations.Pages().CreatePage(pageTitle);
var blogPostsWidget = this.CreateBlogPostsMvcWidget(default(Guid), ParentFilterMode.All, SelectionMode.SelectedItems, post1Id);
var controls = new List <System.Web.UI.Control>();
controls.Add(blogPostsWidget);
PageContentGenerator.AddControlsToPage(pageId, controls);
string url = UrlPath.ResolveAbsoluteUrl("~/" + pageTitle);
string responseContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsTrue(responseContent.Contains(blogPost1Title), "The item with this title was NOT found " + blogPost1Title);
Assert.IsFalse(responseContent.Contains(blogPost2Title), "The item with this title WAS found " + blogPost2Title);
}
finally
{
ServerOperations.Pages().DeleteAllPages();
ServerOperations.Blogs().DeleteAllBlogs();
}
}
public void StyleSheetWidget_RendersInHead()
{
var testName = MethodInfo.GetCurrentMethod().Name;
string pageNamePrefix = testName;
string pageTitlePrefix = testName;
string urlNamePrefix = testName;
string url = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix);
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(StyleSheetController).FullName;
var controller = new StyleSheetController();
controller.Model.Mode = ResourceMode.Reference;
controller.Model.ResourceUrl = "http://my-styles.com/styles.css";
controller.Model.MediaType = "screen";
mvcProxy.Settings = new ControllerSettings(controller);
using (var generator = new PageContentGenerator())
{
var pageId = generator.CreatePage(pageNamePrefix, pageTitlePrefix, urlNamePrefix);
PageContentGenerator.AddControlToPage(pageId, mvcProxy, "CSS widget");
string responseContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsTrue(this.IsInHead(responseContent, @"<link href=""http://my-styles.com/styles.css"" media=""screen"" rel=""stylesheet"" type=""text/css"" />"), "The stylesheet reference was not found in the head.");
}
}
public void PostForm_Login_PostsItselfOnly()
{
this.pageOperations = new PagesOperations();
var pageManager = PageManager.GetManager();
Guid pageId = Guid.Empty;
string loginFormPageUrl = UrlPath.ResolveAbsoluteUrl("~/" + this.urlNamePrefix);
try
{
var template = pageManager.GetTemplates().Where(t => t.Name == this.templateName).FirstOrDefault();
Assert.IsNotNull(template, "Template was not found");
pageId = Telerik.Sitefinity.Frontend.TestUtilities.CommonOperations.FeatherServerOperations.Pages().CreatePageWithTemplate(template, this.pageNamePrefix, this.urlNamePrefix);
this.pageOperations.AddLoginFormWidgetToPage(pageId, "Contentplaceholder1");
SecurityManager.Logout();
var responseContent = PageInvoker.ExecuteWebRequest(loginFormPageUrl);
var expectedActionUrl = "?sf_cntrl_id=";
Assert.IsTrue(responseContent.Contains(string.Format("action=\"{0}", expectedActionUrl)), "The action URL doesn't contain controller ID.");
}
finally
{
SitefinityTestUtilities.ServerOperations.Users().AuthenticateAdminUser();
var pageNode = pageManager.GetPageNodes().Where(p => p.Id == pageId).SingleOrDefault();
if (pageNode != null)
{
pageManager.Delete(pageNode);
pageManager.SaveChanges();
}
}
}
public void SpacedTitleFlatTaxonomy_DynamicContentWidget()
{
var pageId = Guid.Empty;
try
{
string dynamicTitle = "dynamic type title";
string dynamicUrl = "dynamic-type-url";
var flatTaxonomyName = Regex.Replace(FlatTaxonomyTitle, " ", string.Empty);
var dynamicModulePressArticle = ServerOperationsFeather.DynamicModulePressArticle();
dynamicModulePressArticle.CreatePressArticleWithCustomTaxonomy(dynamicTitle, dynamicUrl, flatTaxonomyName, this.flatTaxaNames);
var index = 1;
var mvcWidget = this.CreateDynamicMvcWidget();
pageId = this.pagesOperations.CreatePageWithControl(mvcWidget, PageName, PageName, PageUrl, index);
string url = UrlPath.ResolveAbsoluteUrl("~/" + PageUrl + index);
var article = dynamicModulePressArticle.RetrieveCollectionOfPressArticles().FirstOrDefault(content => content.UrlName == dynamicUrl);
Assert.IsNotNull(article);
string detailsUrl = url + article.ItemDefaultUrl;
string responseContent = PageInvoker.ExecuteWebRequest(detailsUrl);
Assert.IsNotNull(responseContent);
Assert.IsTrue(responseContent.Contains(this.flatTaxaNames[0]), "The taxon with specified spaced taxonomy title was not found!");
Assert.IsTrue(responseContent.Contains(this.flatTaxaNames[1]), "The taxon with specified spaced taxonomy title was not found!");
}
finally
{
if (pageId != Guid.Empty)
{
CommonOperationsContext.ServerOperations.Pages().DeletePage(pageId);
}
}
}
public void EventWidget_SocialShareButtonsFunctionality()
{
string socialShare = "list-inline sf-social-share";
string testName = System.Reflection.MethodInfo.GetCurrentMethod().Name;
string pageNamePrefix = testName + "EventsPage";
string pageTitlePrefix = testName + "Events Page";
string urlNamePrefix = testName + "events-page";
int pageIndex = 1;
var eventsManager = EventsManager.GetManager();
string url = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + pageIndex);
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(EventController).FullName;
var eventController = new EventController();
eventController.Model.EnableSocialSharing = true;
mvcProxy.Settings = new ControllerSettings(eventController);
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, pageIndex);
var eventItem = eventsManager.GetEvents().Where <Event>(ni => ni.Status == ContentLifecycleStatus.Master && ni.Title == BaseEventTitle + 1).FirstOrDefault();
string detailEventUrl = url + eventItem.ItemDefaultUrl;
string responseContent = PageInvoker.ExecuteWebRequest(detailEventUrl);
Assert.IsTrue(responseContent.Contains(socialShare), "Social share button was not found!");
Assert.IsTrue(responseContent.Contains(BaseEventTitle + 1), "The event with this title was not found!");
}
public void EventWidget_CssClassesDetailsTemplate()
{
var methodName = MethodInfo.GetCurrentMethod().Name;
string pageNamePrefix = methodName + "EventsPage";
string pageTitlePrefix = methodName + "Events Page";
string urlNamePrefix = methodName + "events-page";
int pageIndex = 1;
var url = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + pageIndex);
var cssClass = methodName + "_css-class";
var eventController = new EventController();
eventController.Model.DetailCssClass = cssClass;
var mvcProxy = new MvcControllerProxy()
{
Settings = new ControllerSettings(eventController), ControllerName = typeof(EventController).FullName
};
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, pageIndex);
var eventItem = EventsManager.GetManager().GetEvents().Where <Event>(ni => ni.Status == ContentLifecycleStatus.Master && ni.Title == BaseEventTitle + 1).FirstOrDefault();
var detailEventUrl = url + eventItem.ItemDefaultUrl;
var responseContent = PageInvoker.ExecuteWebRequest(detailEventUrl);
Assert.Contains(responseContent, cssClass, System.StringComparison.Ordinal);
}
public void Login_WithPageId_VerifyLoginRedirectUrlIsCorrect()
{
var pageOperations = new PagesOperations();
try
{
string loginStatusPageUrl = UrlPath.ResolveAbsoluteUrl("~/" + this.urlNamePrefix + this.pageIndex);
var basicPageOperations = new Telerik.Sitefinity.TestUtilities.CommonOperations.PagesOperations();
var pageTitle = "Page Title1";
var pageUrl = "PageTitle1";
var absoluteUrl = UrlPath.GetDomainUrl() + "/" + pageUrl;
try
{
var loginPageId = basicPageOperations.CreatePage(pageTitle, pageUrl);
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(LoginStatusController).FullName;
var loginStatusController = new LoginStatusController();
loginStatusController.Model.LoginPageId = loginPageId;
mvcProxy.Settings = new ControllerSettings(loginStatusController);
pageOperations.CreatePageWithControl(mvcProxy, this.pageNamePrefix, this.pageTitlePrefix, this.urlNamePrefix, this.pageIndex);
var responseContent = PageInvoker.ExecuteWebRequest(loginStatusPageUrl);
Assert.IsTrue(responseContent.Contains(this.GetExpectedUrlWithParams(absoluteUrl)), "Login redirect url is not as expected");
}
finally
{
basicPageOperations.DeleteAllPages();
}
}
finally
{
pageOperations.DeletePages();
}
}
public void FlatTaxonomy_DoNotShowCount()
{
this.CreateTestData();
var mvcProxy = new MvcWidgetProxy();
mvcProxy.ControllerName = typeof(FlatTaxonomyController).FullName;
var flatTaxonomyController = new FlatTaxonomyController();
flatTaxonomyController.Model.ShowItemCount = false;
mvcProxy.Settings = new ControllerSettings(flatTaxonomyController);
var index = 1;
this.pagesOperations.CreatePageWithControl(mvcProxy, PageName, PageName, PageUrl, index);
string url = UrlPath.ResolveAbsoluteUrl("~/" + PageUrl + index);
string responseContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsNotNull(responseContent);
var urlPrefix = PageUrl + index + "/-in-tags/tags/";
var expectedTags = new List <Tag>()
{
new Tag(this.taxaNames[0], urlPrefix + this.taxaNames[0], 2),
new Tag(this.taxaNames[1], urlPrefix + this.taxaNames[1], 1),
};
var notExpectedTags = new List <Tag>()
{
new Tag(this.taxaNames[2], urlPrefix + this.taxaNames[2], 0),
};
this.AssertTagsLinks(responseContent, expectedTags, notExpectedTags, flatTaxonomyController.Model.ShowItemCount);
}
public void DynamicWidgetsDesignerSingleItemSettingsTests_SetDetailTemplate()
{
string detailTemplate = "PressArticleNew";
string paragraphText = "Detail template";
this.pageOperations = new PagesOperations();
string testName = System.Reflection.MethodInfo.GetCurrentMethod().Name;
string pageNamePrefix = testName + "DynamicPage";
string pageTitlePrefix = testName + "Dynamic Page";
string urlNamePrefix = testName + "dynamic-page";
int index = 1;
string url = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + index);
string fileDeatil = null;
string fileList = null;
var dynamicCollection = ServerOperationsFeather.DynamicModulePressArticle().RetrieveCollectionOfPressArticles();
try
{
fileDeatil = this.CopyFile(DynamicFileName, DynamicFileFileResource);
fileList = this.CopyFile(DynamicFileListName, DynamicFileListFileResource);
for (int i = 0; i < this.dynamicTitles.Length; i++)
{
ServerOperationsFeather.DynamicModulePressArticle().CreatePressArticleItem(this.dynamicTitles[i], this.dynamicUrls[i]);
}
dynamicCollection = ServerOperationsFeather.DynamicModulePressArticle().RetrieveCollectionOfPressArticles();
var mvcProxy = new MvcWidgetProxy();
mvcProxy.ControllerName = typeof(DynamicContentController).FullName;
var dynamicController = new DynamicContentController();
dynamicController.Model.ContentType = TypeResolutionService.ResolveType(ResolveType);
dynamicController.Model.ProviderName = ((Telerik.Sitefinity.Data.DataProviderBase)dynamicCollection.First().Provider).Name;
dynamicController.ListTemplateName = detailTemplate;
dynamicController.DetailTemplateName = detailTemplate;
mvcProxy.Settings = new ControllerSettings(dynamicController);
mvcProxy.WidgetName = WidgetName;
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, index);
string detailNewsUrl = url + dynamicCollection[0].ItemDefaultUrl;
string responseContent = PageInvoker.ExecuteWebRequest(detailNewsUrl);
Assert.IsTrue(responseContent.Contains(paragraphText), "The paragraph text was not found!");
Assert.IsTrue(responseContent.Contains(this.dynamicTitles[0]), "The dynamic item with this title was not found!");
Assert.IsFalse(responseContent.Contains(this.dynamicTitles[1]), "The dynamic item with this title was found!");
Assert.IsFalse(responseContent.Contains(this.dynamicTitles[2]), "The dynamic item with this title was found!");
}
finally
{
File.Delete(fileDeatil);
File.Delete(fileList);
Directory.Delete(this.folderPath);
this.pageOperations.DeletePages();
ServerOperationsFeather.DynamicModulePressArticle().DeleteDynamicItems(dynamicCollection);
}
}
public void DeactivatingFeather_WidgetOnPurePage_VerifyFrontendAndBackend()
{
var moduleOperations = new Telerik.Sitefinity.Frontend.TestUtilities.CommonOperations.FeatherModuleOperations();
Guid pageId = Guid.Empty;
moduleOperations.EnsureFeatherEnabled();
try
{
string pageUrl;
pageId = this.CreatePageWithControl(PageTemplateFramework.Mvc, out pageUrl);
var pageContentBeforeDeactivate = PageInvoker.ExecuteWebRequest(pageUrl + this.AppendUncacheUrl());
Assert.IsTrue(pageContentBeforeDeactivate.Contains(ModuleUnloadTests.PageControlContent), "Content was not found!");
var pageContentBeforeDeactivateInEdit = PageInvoker.ExecuteWebRequest(pageUrl + this.AppendEditUrl());
Assert.IsTrue(pageContentBeforeDeactivateInEdit.Contains(ModuleUnloadTests.PageControlContent), "Content was not found!");
Assert.IsFalse(pageContentBeforeDeactivateInEdit.Contains(ModuleUnloadTests.WidgetUnavailableMessage), "Error message is displayed in zone editor!");
this.UnlockPage(pageId);
moduleOperations.DeactivateFeather();
var pageContentAfterDeactivate = PageInvoker.ExecuteWebRequest(pageUrl + this.AppendUncacheUrl());
Assert.IsFalse(pageContentAfterDeactivate.Contains(ModuleUnloadTests.PageControlContent), "Content was found after deactivate!");
var pageContentAfterDeactivateInEdit = PageInvoker.ExecuteWebRequest(pageUrl + this.AppendEditUrl());
Assert.IsFalse(pageContentAfterDeactivateInEdit.Contains(ModuleUnloadTests.PageControlContent), "Content was found after deactivate!");
Assert.IsTrue(pageContentAfterDeactivateInEdit.Contains(ModuleUnloadTests.WidgetUnavailableMessage), "Error message is not displayed in zone editor!");
}
finally
{
moduleOperations.ActivateFeather();
Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.Pages().DeletePage(pageId);
}
}
public void LanguageSelectorWidgetAndProductList_CurrentLanguageIncluded()
{
var languageSelectorControl = this.CreateLanguageSelectorControl();
var languageSelectorModel = languageSelectorControl.Settings.Controller.Model;
languageSelectorControl.Settings.Controller.TemplateName = "DropDownMenu";
languageSelectorModel.IncludeCurrentLanguage = true;
this.productOperations.CreatePublishedProduct(ProductTypeName, true, ProductName, ProductPrice);
var controls = new List <System.Web.UI.Control>();
controls.Add(languageSelectorControl);
var pageLanguages = new[]
{
this.sitefinityLanguages["English"]
};
var createdPages = this.CreateLocalizedPage(PageName, pageLanguages);
// Add language selector widget to the en-US page
var currentPage = createdPages.First();
PageContentGenerator.AddControlsToPage(currentPage.Key, controls);
ServerOperations.Widgets().AddProductListViewWithTemplate(currentPage.Key, EcommerceGlobals.placeholderId, EcommerceGlobals.captionProducts, ControlTypes.ProductDetailLayoutTemplateName, showWishlist: true);
string url = UrlPath.ResolveAbsoluteUrl("~/" + PageName + currentPage.Value.Name);
var pageContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsNotNull(pageContent);
}
public void UninstallFeather_WidgetsInToolboxPurePageTemplate_VerifyBackend()
{
var moduleOperations = Telerik.Sitefinity.Frontend.TestUtilities.CommonOperations.FeatherServerOperations.FeatherModule();
var templatesOperations = Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.Templates();
Guid templateId = Guid.Empty;
moduleOperations.EnsureFeatherEnabled();
try
{
templateId = templatesOperations.CreatePureMVCPageTemplate(ModuleUnloadTests.PageTemplateTitle + Guid.NewGuid().ToString("N"));
string templateUrl = UrlPath.ResolveAbsoluteUrl(ModuleUnloadTests.SitefinityTemplateRoutePrefix + templateId.ToString());
var templateContentBeforeDeactivate = PageInvoker.ExecuteWebRequest(templateUrl + this.AppendUncacheUrl());
Assert.IsTrue(templateContentBeforeDeactivate.Contains(ModuleUnloadTests.FeatherWidgetToolboxItemMarkup));
moduleOperations.DeactivateFeather();
moduleOperations.UninstallFeather();
var templateContentAfterDeactivate = PageInvoker.ExecuteWebRequest(templateUrl + this.AppendUncacheUrl());
Assert.IsFalse(templateContentAfterDeactivate.Contains(ModuleUnloadTests.FeatherWidgetToolboxItemMarkup));
}
finally
{
moduleOperations.InstallFeather();
templatesOperations.DeletePageTemplate(templateId);
}
}
public void UninstallFeather_WidgetsInToolboxPurePage_VerifyBackend()
{
var moduleOperations = Telerik.Sitefinity.Frontend.TestUtilities.CommonOperations.FeatherServerOperations.FeatherModule();
Guid pageId = Guid.Empty;
moduleOperations.EnsureFeatherEnabled();
try
{
string pageUrl;
pageId = this.CreatePage(PageTemplateFramework.Mvc, out pageUrl);
var pageContentBeforeDeactivate = PageInvoker.ExecuteWebRequest(pageUrl + this.AppendEditUrl());
Assert.IsTrue(pageContentBeforeDeactivate.Contains(ModuleUnloadTests.FeatherWidgetToolboxItemMarkup));
moduleOperations.DeactivateFeather();
moduleOperations.UninstallFeather();
var pageContentAfterDeactivate = PageInvoker.ExecuteWebRequest(pageUrl + this.AppendEditUrl());
Assert.IsFalse(pageContentAfterDeactivate.Contains(ModuleUnloadTests.FeatherWidgetToolboxItemMarkup));
}
finally
{
moduleOperations.InstallFeather();
Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.Pages().DeletePage(pageId);
}
}
public void BlogsWidget_UseLimit_OneItem()
{
string blog1Title = "Blog1";
string blog2Title = "Blog2";
string pageTitle = "PageWithBlogsWidget";
try
{
ServerOperations.Blogs().CreateBlog(blog1Title);
ServerOperations.Blogs().CreateBlog(blog2Title);
Guid pageId = ServerOperations.Pages().CreatePage(pageTitle);
var blogsWidget = this.CreateBlogsMvcWidget(ListDisplayMode.Limit, itemsPerPage: 1);
var controls = new List <System.Web.UI.Control>();
controls.Add(blogsWidget);
PageContentGenerator.AddControlsToPage(pageId, controls);
string url = UrlPath.ResolveAbsoluteUrl("~/" + pageTitle);
string responseContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsTrue(responseContent.Contains(blog2Title), "The item with this title was NOT found " + blog2Title);
Assert.IsFalse(responseContent.Contains(blog1Title), "The item with this title WAS found " + blog1Title);
}
finally
{
ServerOperations.Pages().DeleteAllPages();
ServerOperations.Blogs().DeleteAllBlogs();
}
}
public void PostForm_RedirectUrlIsPreserved()
{
string loginFormPageUrl = UrlPath.ResolveAbsoluteUrl("~/" + this.urlNamePrefix + this.pageIndex);
var redirectQuery = "?RedirectUrl=myRedirectUrl";
this.pageOperations = new PagesOperations();
try
{
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(LoginFormController).FullName;
var loginFormController = new LoginFormController();
mvcProxy.Settings = new ControllerSettings(loginFormController);
this.pageOperations.CreatePageWithControl(mvcProxy, this.pageNamePrefix, this.pageTitlePrefix, this.urlNamePrefix, this.pageIndex);
SecurityManager.Logout();
var responseContent = PageInvoker.ExecuteWebRequest(loginFormPageUrl + redirectQuery);
var expectedActionUrl = this.urlNamePrefix + this.pageIndex + redirectQuery;
Assert.IsTrue(responseContent.Contains(string.Format("action=\"{0}\"", expectedActionUrl)), "The action URL no longer contains redirect URL");
}
finally
{
SecurityManager.Logout();
SitefinityTestUtilities.ServerOperations.Users().AuthenticateAdminUser();
this.pageOperations.DeletePages();
}
}
public void DynamicWidgets_ParentRelationType_DisplayRelatedItemsOnFrontend()
{
string url;
string responseContent;
string expectedContent;
string pageName = "FeatherPage";
string pageUrl = "featherpage";
string item1 = "item1";
string item2 = "item2";
foreach (var color in this.colors)
{
ServerOperationsFeather.DynamicModule1Operations().CreateColor(color);
}
try
{
string[] item1RelatedColors = new string[] { this.colors[0], this.colors[1] };
ServerOperationsFeather.DynamicModule2Operations().CreateItem(item1, item1RelatedColors);
string[] item2RelatedColors = new string[] { this.colors[2], this.colors[3] };
ServerOperationsFeather.DynamicModule2Operations().CreateItem(item2, item2RelatedColors);
this.pageId = ServerOperations.Pages().CreatePage(pageName);
var itemsWidget = this.CreateMvcWidget(ResolveTypeItem, WidgetNameItem, RelatedFieldName, ResolveTypeColor, RelationDirection.Parent);
var colorsWidget = this.CreateMvcWidget(ResolveTypeColor, WidgetNameColor);
var controls = new List <System.Web.UI.Control>();
controls.Add(itemsWidget);
controls.Add(colorsWidget);
PageContentGenerator.AddControlsToPage(this.pageId, controls);
url = UrlPath.ResolveAbsoluteUrl("~/" + pageUrl + "/" + this.colors[0]);
responseContent = PageInvoker.ExecuteWebRequest(url);
expectedContent = UrlPath.ResolveAbsoluteUrl("~/" + pageUrl + "/" + item1);
Assert.IsTrue(this.ContainsElement(responseContent, expectedContent), "Link to " + item1 + " was not found on the frontend");
expectedContent = UrlPath.ResolveAbsoluteUrl("~/" + pageUrl + "/" + item2);
Assert.IsFalse(this.ContainsElement(responseContent, expectedContent), "Link to " + item2 + " was found on the frontend, but it shouldn't");
url = UrlPath.ResolveAbsoluteUrl("~/" + pageUrl + "/" + this.colors[3]);
responseContent = PageInvoker.ExecuteWebRequest(url);
expectedContent = UrlPath.ResolveAbsoluteUrl("~/" + pageUrl + "/" + item2);
Assert.IsTrue(this.ContainsElement(responseContent, expectedContent), "Link to " + item2 + " was not found on the frontend");
expectedContent = UrlPath.ResolveAbsoluteUrl("~/" + pageUrl + "/" + item1);
Assert.IsFalse(this.ContainsElement(responseContent, expectedContent), "Link to " + item1 + " was found on the frontend, but it shouldn't");
}
finally
{
ServerOperations.Pages().DeleteAllPages();
}
}
public void Status_TestRouting_Available()
{
string statusUrl = UrlPath.ResolveAbsoluteUrl("~/rest-api/login-status");
var responseContent = PageInvoker.ExecuteWebRequest(statusUrl);
var statusResponse = Json.Decode(responseContent, typeof(StatusViewModel));
Assert.IsTrue(statusResponse.IsLoggedIn);
}
public void Status_TestRouting_Available()
{
HttpContext.Current.Request.Headers["Authorization"] = string.Empty;
string statusUrl = UrlPath.ResolveAbsoluteUrl("~/rest-api/login-status");
var responseContent = PageInvoker.ExecuteWebRequest(statusUrl);
var statusResponse = Json.Decode(responseContent, typeof(StatusViewModel));
Assert.IsFalse(statusResponse.IsLoggedIn);
}
