public void Should_By_Xml_And_Binary_Serializable()
        {
            var pageContent = TestDataProvider.CreateNewPageContent();
            pageContent.Content = TestDataProvider.CreateNewHtmlContent();
            pageContent.Options = new[]
                                                 {
                                                     TestDataProvider.CreateNewPageContentOption(pageContent),
                                                     TestDataProvider.CreateNewPageContentOption(pageContent),
                                                     TestDataProvider.CreateNewPageContentOption(pageContent)
                                                 };

            var cmsConfiguration = new Mock<ICmsConfiguration>();
            var optionService = new DefaultOptionService(null, new HttpRuntimeCacheService(), cmsConfiguration.Object);
            var optionValues = optionService.GetMergedOptionValues(pageContent.Options, null);

            PageContentProjection original = new PageContentProjection(
                pageContent, pageContent.Content, new HtmlContentAccessor((HtmlContent)pageContent.Content, optionValues));

            RunSerializationAndDeserialization(original,
                projection =>
                    {
                        Assert.AreEqual(original.ContentId, projection.ContentId);
                        Assert.AreEqual(original.Order, projection.Order);
                        Assert.AreEqual(original.RegionId, projection.RegionId);
                    });
        }       
        public void Should_Return_MergedOptionsAndValuesSuccessfully()
        {
            var option1 = TestDataProvider.CreateNewLayoutOption();
            var option2 = TestDataProvider.CreateNewLayoutOption();
            var option3 = TestDataProvider.CreateNewLayoutOption();
            var option4 = TestDataProvider.CreateNewLayoutOption();
            var option5 = TestDataProvider.CreateNewLayoutOption();

            var optionValue1 = TestDataProvider.CreateNewPageOption();
            var optionValue2 = TestDataProvider.CreateNewPageOption();
            var optionValue3 = TestDataProvider.CreateNewPageOption();
            var optionValue4 = TestDataProvider.CreateNewPageOption();
            var optionValue5 = TestDataProvider.CreateNewPageOption();

            optionValue1.Key = option1.Key;
            optionValue2.Key = option2.Key;
            option1.Type = option2.Type = option3.Type = option4.Type = option5.Type = OptionType.Text;
            optionValue1.Type = optionValue2.Type = optionValue3.Type = optionValue4.Type = optionValue5.Type = OptionType.Text;

            option3.DefaultValue = null;
            optionValue4.Value = null;

            var service = new DefaultOptionService(null);
            var optionValues = new List<IOption> { optionValue1, optionValue2, optionValue3, optionValue4, optionValue5 };
            var options = new List<IOption> { option1, option2, option3, option4, option5 };

            var result = service.GetMergedOptionValues(options, optionValues);
            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 8);
            Assert.AreEqual(6, result.Count(o => o.Value != null));
        }
        public void Should_ThrowValidationException_AboutNonDeletableOption()
        {
            RunActionInTransaction(session =>
            {
                var unitOfWork = new DefaultUnitOfWork(session);
                var repository = new DefaultRepository(unitOfWork);

                var optionService = new DefaultOptionService(repository);

                // Create layout with options
                var layout = TestDataProvider.CreateNewLayout();
                layout.LayoutOptions = new List<LayoutOption>();

                var option1 = TestDataProvider.CreateNewLayoutOption(layout);
                option1.Type = OptionType.Text;
                option1.IsDeletable = false;
                layout.LayoutOptions.Add(option1);

                session.SaveOrUpdate(layout);
                session.Flush();
                session.Clear();

                optionService.SetOptions<LayoutOption, Layout>(layout, new List<IOption>());
                unitOfWork.Commit();
            });
        }
        public void Should_Save_Options_Successfully()
        {
            RunActionInTransaction(session =>
            {
                var unitOfWork = new DefaultUnitOfWork(session);
                var repository = new DefaultRepository(unitOfWork);

                var cmsConfiguration = new Mock <ICmsConfiguration>();
                var optionService    = new DefaultOptionService(repository, new HttpRuntimeCacheService(), cmsConfiguration.Object);

                // Create layout with options
                var layout           = TestDataProvider.CreateNewLayout();
                layout.LayoutOptions = new List <LayoutOption>();

                var option1  = TestDataProvider.CreateNewLayoutOption(layout);
                option1.Type = OptionType.Text;
                layout.LayoutOptions.Add(option1);

                var option2  = TestDataProvider.CreateNewLayoutOption(layout);
                option2.Type = OptionType.Text;
                layout.LayoutOptions.Add(option2);

                var option3  = TestDataProvider.CreateNewLayoutOption(layout);
                option3.Type = OptionType.Text;
                layout.LayoutOptions.Add(option3);

                session.SaveOrUpdate(layout);
                session.Flush();
                session.Clear();

                // Create fake options:
                // 1 should be kept
                // 2 should be updated
                // 3 should be inserted
                // option2 should be deleted
                var newOption1 = new LayoutOption {
                    Key = option1.Key, Type = option1.Type, DefaultValue = option1.DefaultValue
                };
                var newOption2 = new LayoutOption {
                    Key = option2.Key, Type = option2.Type, DefaultValue = TestDataProvider.ProvideRandomString(100)
                };
                var newOption3 = new LayoutOption {
                    Key = TestDataProvider.ProvideRandomString(100), Type = OptionType.Text, DefaultValue = TestDataProvider.ProvideRandomString(100)
                };
                var newOptions = new List <IOptionEntity> {
                    newOption1, newOption2, newOption3
                };

                optionService.SetOptions <LayoutOption, Layout>(layout, newOptions);
                unitOfWork.Commit();

                // Load all options
                var options = repository.AsQueryable <LayoutOption>(lo => lo.Layout == layout).ToList();

                Assert.AreEqual(options.Count, 3);
                Assert.IsTrue(options.Any(o => o.Key == option1.Key && o.DefaultValue == option1.DefaultValue && o.Type == option1.Type));
                Assert.IsTrue(options.Any(o => o.Key == option2.Key && o.DefaultValue == newOption2.DefaultValue && o.Type == option2.Type));
                Assert.IsTrue(options.Any(o => o.Key == newOption3.Key && o.DefaultValue == newOption3.DefaultValue && o.Type == newOption3.Type));
            });
        }
Beispiel #5
0
        public void Should_ThrowValidationException_AboutNonDeletableOption()
        {
            RunActionInTransaction(session =>
            {
                var unitOfWork = new DefaultUnitOfWork(session);
                var repository = new DefaultRepository(unitOfWork);

                var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService());

                // Create layout with options
                var layout           = TestDataProvider.CreateNewLayout();
                layout.LayoutOptions = new List <LayoutOption>();

                var option1         = TestDataProvider.CreateNewLayoutOption(layout);
                option1.Type        = OptionType.Text;
                option1.IsDeletable = false;
                layout.LayoutOptions.Add(option1);

                session.SaveOrUpdate(layout);
                session.Flush();
                session.Clear();

                optionService.SetOptions <LayoutOption, Layout>(layout, new List <IOption>());
                unitOfWork.Commit();
            });
        }
        public void Should_By_Xml_And_Binary_Serializable()
        {
            var pageContent = TestDataProvider.CreateNewPageContent();

            pageContent.Content = TestDataProvider.CreateNewHtmlContent();
            pageContent.Options = new[]
            {
                TestDataProvider.CreateNewPageContentOption(pageContent),
                TestDataProvider.CreateNewPageContentOption(pageContent),
                TestDataProvider.CreateNewPageContentOption(pageContent)
            };

            var cmsConfiguration = new Mock <ICmsConfiguration>();
            var optionService    = new DefaultOptionService(null, new HttpRuntimeCacheService(), cmsConfiguration.Object);
            var optionValues     = optionService.GetMergedOptionValues(pageContent.Options, null);

            var original = new PageContentProjection(
                pageContent, pageContent.Content, new HtmlContentAccessor((HtmlContent)pageContent.Content, optionValues));

            RunSerializationAndDeserialization(original,
                                               projection =>
            {
                Assert.AreEqual(original.ContentId, projection.ContentId);
                Assert.AreEqual(original.Order, projection.Order);
                Assert.AreEqual(original.RegionId, projection.RegionId);
            });
        }
        public void Should_Return_MergedEmptyOptionsSuccessfully()
        {
            var service = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List<IOption>();
            var options = new List<IOption>();

            var result = service.GetMergedOptionValues(options, optionValues);
            Assert.NotNull(result);
            Assert.IsEmpty(result);
        }
        public void Should_Return_MergedEmptyOptions_ForEdit_Successfully()
        {
            var service = new DefaultOptionService(null);
            var optionValues = new List<IOption>();
            var options = new List<IOption>();

            var result = service.GetMergedOptionValuesForEdit(options, optionValues);
            Assert.NotNull(result);
            Assert.IsEmpty(result);
        }
Beispiel #9
0
        public void Should_Return_MergedEmptyOptions_ForEdit_Successfully()
        {
            var service      = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List <IOption>();
            var options      = new List <IOption>();

            var result = service.GetMergedOptionValuesForEdit(options, optionValues);

            Assert.NotNull(result);
            Assert.IsEmpty(result);
        }
Beispiel #10
0
        public void Should_Return_MergedEmptyOptionsSuccessfully()
        {
            var service      = new DefaultOptionService(null);
            var optionValues = new List <IOption>();
            var options      = new List <IOption>();

            var result = service.GetMergedOptionValues(options, optionValues);

            Assert.NotNull(result);
            Assert.IsEmpty(result);
        }
        public void Should_Save_Options_Successfully()
        {
            RunActionInTransaction(session =>
            {
                var unitOfWork = new DefaultUnitOfWork(session);
                var repository = new DefaultRepository(unitOfWork);

                var cmsConfiguration = new Mock<ICmsConfiguration>();
                var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService(), cmsConfiguration.Object);

                // Create layout with options
                var layout = TestDataProvider.CreateNewLayout();
                layout.LayoutOptions = new List<LayoutOption>();

                var option1 = TestDataProvider.CreateNewLayoutOption(layout);
                option1.Type = OptionType.Text;
                layout.LayoutOptions.Add(option1);

                var option2 = TestDataProvider.CreateNewLayoutOption(layout);
                option2.Type = OptionType.Text;
                layout.LayoutOptions.Add(option2);

                var option3 = TestDataProvider.CreateNewLayoutOption(layout);
                option3.Type = OptionType.Text;
                layout.LayoutOptions.Add(option3);
                
                session.SaveOrUpdate(layout);
                session.Flush();
                session.Clear();
                
                // Create fake options:
                // 1 should be kept
                // 2 should be updated
                // 3 should be inserted
                // option2 should be deleted
                var newOption1 = new LayoutOption { Key = option1.Key, Type = option1.Type, DefaultValue = option1.DefaultValue };
                var newOption2 = new LayoutOption { Key = option2.Key, Type = option2.Type, DefaultValue = TestDataProvider.ProvideRandomString(100) };
                var newOption3 = new LayoutOption { Key = TestDataProvider.ProvideRandomString(100), Type = OptionType.Text, DefaultValue = TestDataProvider.ProvideRandomString(100) };
                var newOptions = new List<IOptionEntity> { newOption1, newOption2, newOption3 };

                optionService.SetOptions<LayoutOption, Layout>(layout, newOptions);
                unitOfWork.Commit();

                // Load all options
                var options = repository.AsQueryable<LayoutOption>(lo => lo.Layout == layout).ToList();

                Assert.AreEqual(options.Count, 3);
                Assert.IsTrue(options.Any(o => o.Key == option1.Key && o.DefaultValue == option1.DefaultValue && o.Type == option1.Type));
                Assert.IsTrue(options.Any(o => o.Key == option2.Key && o.DefaultValue == newOption2.DefaultValue && o.Type == option2.Type));
                Assert.IsTrue(options.Any(o => o.Key == newOption3.Key && o.DefaultValue == newOption3.DefaultValue && o.Type == newOption3.Type));
            });
        }
Beispiel #12
0
        public void Should_Return_MergedOptionsAndValues_ForEdit_Successfully()
        {
            var option1 = TestDataProvider.CreateNewLayoutOption();
            var option2 = TestDataProvider.CreateNewLayoutOption();
            var option3 = TestDataProvider.CreateNewLayoutOption();
            var option4 = TestDataProvider.CreateNewLayoutOption();
            var option5 = TestDataProvider.CreateNewLayoutOption();

            var optionValue1 = TestDataProvider.CreateNewPageOption();
            var optionValue2 = TestDataProvider.CreateNewPageOption();
            var optionValue3 = TestDataProvider.CreateNewPageOption();
            var optionValue4 = TestDataProvider.CreateNewPageOption();
            var optionValue5 = TestDataProvider.CreateNewPageOption();

            optionValue1.Key  = option1.Key;
            optionValue2.Key  = option2.Key;
            option1.Type      = option2.Type = option3.Type = option4.Type = option5.Type = OptionType.Text;
            optionValue1.Type = optionValue2.Type = optionValue3.Type = optionValue4.Type = optionValue5.Type = OptionType.Text;

            option3.DefaultValue = null;
            optionValue4.Value   = null;

            var service      = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List <IOption> {
                optionValue1, optionValue2, optionValue3, optionValue4, optionValue5
            };
            var options = new List <IOption> {
                option1, option2, option3, option4, option5
            };

            var result = service.GetMergedOptionValuesForEdit(options, optionValues);

            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 8);
            // 3 of 5 values has no equivalent option, so they can be edited
            Assert.AreEqual(result.Count(o => o.CanEditOption), 3);
            // 4 of 5 options has default values
            Assert.AreEqual(result.Count(o => o.OptionDefaultValue == null), 4);
            // 4 of 5 option values has default values
            Assert.AreEqual(result.Count(o => o.OptionValue == o.OptionDefaultValue), 4);
            // 1 option and option value are equal
            Assert.AreEqual(result.Count(o => o.OptionKey == option1.Key &&
                                         o.OptionDefaultValue == option1.DefaultValue &&
                                         o.OptionValue == optionValue1.Value), 1);
            // 2 option and option value are equal
            Assert.AreEqual(result.Count(o => o.OptionKey == option2.Key &&
                                         o.OptionDefaultValue == option2.DefaultValue &&
                                         o.OptionValue == optionValue2.Value), 1);
        }
Beispiel #13
0
        public void Should_Return_Null_Values_Not_ConvertedToDateTime()
        {
            var service      = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List <IOption>();
            var options      = new List <IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();

            option.DefaultValue = "not-datetime";
            option.Type         = OptionType.DateTime;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);

            Assert.NotNull(result);
            Assert.IsNull(result[0].Value);
        }
Beispiel #14
0
        public void Should_Return_Null_Values_Not_ConvertedToInteger()
        {
            var service      = new DefaultOptionService(null);
            var optionValues = new List <IOption>();
            var options      = new List <IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();

            option.DefaultValue = "not-integer";
            option.Type         = OptionType.Integer;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);

            Assert.NotNull(result);
            Assert.IsNull(result[0].Value);
        }
        public void Should_Return_MergedOptionValuesSuccessfully()
        {
            var option1 = TestDataProvider.CreateNewLayoutOption();
            var option2 = TestDataProvider.CreateNewLayoutOption();
            var option3 = TestDataProvider.CreateNewLayoutOption();

            option1.Type = option2.Type = option3.Type = OptionType.Text;
            
            option3.DefaultValue = null;

            var service = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List<IOption>();
            var options = new List<IOption> { option1, option2, option3 };

            var result = service.GetMergedOptionValues(options, optionValues);
            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 3);
            Assert.AreEqual(2, result.Count(o => o.Value != null));
        }
Beispiel #16
0
        public void ShouldRetrieveMasterPageOptionsSuccessfully()
        {
            RunActionInTransaction(session =>
            {
                var unitOfWork = new DefaultUnitOfWork(session);
                var repository = new DefaultRepository(unitOfWork);

                var pages = CreateNestedOptions(session, 1);

                var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService());
                var optionValues  = optionService.GetMergedMasterPagesOptionValues(pages[0].Id, null, pages[0].Layout.Id);

                Assert.AreEqual(optionValues.Count, 4);
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l1" && o.OptionValue == "l1"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l2" && o.OptionValue == "l2"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l3" && o.OptionValue == "l3p1"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "p1" && o.OptionValue == "p1"));
            });
        }
Beispiel #17
0
        public void Should_Return_ValuesConvertedToBoolean()
        {
            var service      = new DefaultOptionService(null);
            var optionValues = new List <IOption>();
            var options      = new List <IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();

            option.DefaultValue = "true";
            option.Type         = OptionType.Boolean;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);

            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 1);
            Assert.AreEqual(result[0].Value is bool, true);
            Assert.AreEqual(result[0].Value, true);
        }
Beispiel #18
0
        public void Should_Return_ValuesConvertedToFloat()
        {
            var service      = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List <IOption>();
            var options      = new List <IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();

            option.DefaultValue = "10.5";
            option.Type         = OptionType.Float;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);

            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 1);
            Assert.AreEqual(result[0].Value is decimal, true);
            Assert.AreEqual(result[0].Value, 10.5M);
        }
Beispiel #19
0
        public void Should_Return_ValuesConvertedToLongInteger()
        {
            var service      = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List <IOption>();
            var options      = new List <IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();

            option.DefaultValue = "4294967296";
            option.Type         = OptionType.Integer;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);

            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 1);
            Assert.AreEqual(result[0].Value is long, true);
            Assert.AreEqual(result[0].Value, 4294967296);
        }
Beispiel #20
0
        public void Should_Return_MergedOptions_ForEdit_Successfully()
        {
            var optionValue1 = TestDataProvider.CreateNewPageOption();
            var optionValue2 = TestDataProvider.CreateNewPageOption();
            var optionValue3 = TestDataProvider.CreateNewPageOption();

            optionValue1.Type  = optionValue2.Type = optionValue3.Type = OptionType.Text;
            optionValue3.Value = null;

            var service      = new DefaultOptionService(null);
            var optionValues = new List <IOption> {
                optionValue1, optionValue2, optionValue3
            };
            var options = new List <IOption>();

            var result = service.GetMergedOptionValuesForEdit(options, optionValues);

            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 3);
        }
Beispiel #21
0
        public void Should_Return_MergedOptionValues_ForEdit_Successfully()
        {
            var option1 = TestDataProvider.CreateNewLayoutOption();
            var option2 = TestDataProvider.CreateNewLayoutOption();
            var option3 = TestDataProvider.CreateNewLayoutOption();

            option1.Type         = option2.Type = option3.Type = OptionType.Text;
            option3.DefaultValue = null;

            var service      = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List <IOption>();
            var options      = new List <IOption> {
                option1, option2, option3
            };

            var result = service.GetMergedOptionValuesForEdit(options, optionValues);

            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 3);
        }
        public void ShouldRetrieveFirstChildPageOptionsSuccessfully()
        {
            RunActionInTransaction(session =>
            {
                var unitOfWork = new DefaultUnitOfWork(session);
                var repository = new DefaultRepository(unitOfWork);

                var pages            = CreateNestedOptions(session, 2);
                var cmsConfiguration = new Mock <ICmsConfiguration>();
                var optionService    = new DefaultOptionService(repository, new HttpRuntimeCacheService(), cmsConfiguration.Object);
                var optionValues     = optionService.GetMergedMasterPagesOptionValues(pages[1].Id, pages[1].MasterPage.Id, null);

                Assert.AreEqual(optionValues.Count, 5);
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l1" && o.OptionValue == "l1"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l2" && o.OptionValue == "l2p2"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l3" && o.OptionValue == "l3p2"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "p1" && o.OptionValue == "p1"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "p2" && o.OptionValue == "p2"));
            });
        }
        public void ShouldRetrieveFirstChildPageOptionsSuccessfully()
        {
            RunActionInTransaction(session =>
            {
                var unitOfWork = new DefaultUnitOfWork(session);
                var repository = new DefaultRepository(unitOfWork);

                var pages = CreateNestedOptions(session, 2);
                var cmsConfiguration = new Mock<ICmsConfiguration>();
                var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService(), cmsConfiguration.Object);
                var optionValues = optionService.GetMergedMasterPagesOptionValues(pages[1].Id, pages[1].MasterPage.Id, null);

                Assert.AreEqual(optionValues.Count, 5);
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l1" && o.OptionValue == "l1"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l2" && o.OptionValue == "l2p2"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l3" && o.OptionValue == "l3p2"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "p1" && o.OptionValue == "p1"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "p2" && o.OptionValue == "p2"));
            });
        }
Beispiel #24
0
        public void Should_Return_MergedOptionsAndValuesSuccessfully()
        {
            var option1 = TestDataProvider.CreateNewLayoutOption();
            var option2 = TestDataProvider.CreateNewLayoutOption();
            var option3 = TestDataProvider.CreateNewLayoutOption();
            var option4 = TestDataProvider.CreateNewLayoutOption();
            var option5 = TestDataProvider.CreateNewLayoutOption();

            var optionValue1 = TestDataProvider.CreateNewPageOption();
            var optionValue2 = TestDataProvider.CreateNewPageOption();
            var optionValue3 = TestDataProvider.CreateNewPageOption();
            var optionValue4 = TestDataProvider.CreateNewPageOption();
            var optionValue5 = TestDataProvider.CreateNewPageOption();

            optionValue1.Key  = option1.Key;
            optionValue2.Key  = option2.Key;
            option1.Type      = option2.Type = option3.Type = option4.Type = option5.Type = OptionType.Text;
            optionValue1.Type = optionValue2.Type = optionValue3.Type = optionValue4.Type = optionValue5.Type = OptionType.Text;

            option3.DefaultValue = null;
            optionValue4.Value   = null;

            var service      = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List <IOption> {
                optionValue1, optionValue2, optionValue3, optionValue4, optionValue5
            };
            var options = new List <IOption> {
                option1, option2, option3, option4, option5
            };

            var result = service.GetMergedOptionValues(options, optionValues);

            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 8);
            Assert.AreEqual(6, result.Count(o => o.Value != null));
        }
        public void ShouldRetrieveMasterPageOptionsSuccessfully()
        {
            RunActionInTransaction(session =>
            {
                var unitOfWork = new DefaultUnitOfWork(session);
                var repository = new DefaultRepository(unitOfWork);

                var pages = CreateNestedOptions(session, 1);

                var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService());
                var optionValues = optionService.GetMergedMasterPagesOptionValues(pages[0].Id, null, pages[0].Layout.Id);

                Assert.AreEqual(optionValues.Count, 4);
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l1" && o.OptionValue == "l1"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l2" && o.OptionValue == "l2"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l3" && o.OptionValue == "l3p1"));
                Assert.IsTrue(optionValues.Any(o => o.OptionKey == "p1" && o.OptionValue == "p1"));
            });
        }
        public void Should_Return_ValuesConvertedToBoolean()
        {
            var service = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List<IOption>();
            var options = new List<IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();
            option.DefaultValue = "true";
            option.Type = OptionType.Boolean;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);
            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 1);
            Assert.AreEqual(result[0].Value is bool, true);
            Assert.AreEqual(result[0].Value, true);
        }
        public void Should_Return_Null_Values_Not_ConvertedToFloat()
        {
            var service = new DefaultOptionService(null, new HttpRuntimeCacheService());
            var optionValues = new List<IOption>();
            var options = new List<IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();
            option.DefaultValue = "not-float";
            option.Type = OptionType.Float;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);
            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 1);
            Assert.IsNull(result[0].Value);
        }
        public void Should_Return_MergedOptions_ForEdit_Successfully()
        {
            var optionValue1 = TestDataProvider.CreateNewPageOption();
            var optionValue2 = TestDataProvider.CreateNewPageOption();
            var optionValue3 = TestDataProvider.CreateNewPageOption();

            optionValue1.Type = optionValue2.Type = optionValue3.Type = OptionType.Text;
            optionValue3.Value = null;

            var service = new DefaultOptionService(null);
            var optionValues = new List<IOption> { optionValue1, optionValue2, optionValue3 };
            var options = new List<IOption>();

            var result = service.GetMergedOptionValuesForEdit(options, optionValues);
            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 3);
        }
        public void Should_Return_MergedOptionsAndValues_ForEdit_Successfully()
        {
            var option1 = TestDataProvider.CreateNewLayoutOption();
            var option2 = TestDataProvider.CreateNewLayoutOption();
            var option3 = TestDataProvider.CreateNewLayoutOption();
            var option4 = TestDataProvider.CreateNewLayoutOption();
            var option5 = TestDataProvider.CreateNewLayoutOption();

            var optionValue1 = TestDataProvider.CreateNewPageOption();
            var optionValue2 = TestDataProvider.CreateNewPageOption();
            var optionValue3 = TestDataProvider.CreateNewPageOption();
            var optionValue4 = TestDataProvider.CreateNewPageOption();
            var optionValue5 = TestDataProvider.CreateNewPageOption();

            optionValue1.Key = option1.Key;
            optionValue2.Key = option2.Key;
            option1.Type = option2.Type = option3.Type = option4.Type = option5.Type = OptionType.Text;
            optionValue1.Type = optionValue2.Type = optionValue3.Type = optionValue4.Type = optionValue5.Type = OptionType.Text;

            option3.DefaultValue = null;
            optionValue4.Value = null;

            var service = new DefaultOptionService(null);
            var optionValues = new List<IOption> { optionValue1, optionValue2, optionValue3, optionValue4, optionValue5 };
            var options = new List<IOption> { option1, option2, option3, option4, option5 };

            var result = service.GetMergedOptionValuesForEdit(options, optionValues);
            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 8);
            // 3 of 5 values has no equivalent option, so they can be edited
            Assert.AreEqual(result.Count(o => o.CanEditOption), 3);
            // 4 of 5 options has default values
            Assert.AreEqual(result.Count(o => o.OptionDefaultValue == null), 4);
            // 4 of 5 option values has default values
            Assert.AreEqual(result.Count(o => o.OptionValue == o.OptionDefaultValue), 4);
            // 1 option and option value are equal
            Assert.AreEqual(result.Count(o => o.OptionKey == option1.Key
                && o.OptionDefaultValue == option1.DefaultValue
                && o.OptionValue == optionValue1.Value), 1);
            // 2 option and option value are equal
            Assert.AreEqual(result.Count(o => o.OptionKey == option2.Key
                && o.OptionDefaultValue == option2.DefaultValue
                && o.OptionValue == optionValue2.Value), 1);
        }
        public void Should_Return_Null_Values_Not_ConvertedToInteger()
        {
            var service = new DefaultOptionService(null);
            var optionValues = new List<IOption>();
            var options = new List<IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();
            option.DefaultValue = "not-integer";
            option.Type = OptionType.Integer;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);
            Assert.NotNull(result);
            Assert.IsNull(result[0].Value);
        }
        public void Should_Return_ValuesConvertedToInteger()
        {
            var service = new DefaultOptionService(null);
            var optionValues = new List<IOption>();
            var options = new List<IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();
            option.DefaultValue = "580";
            option.Type = OptionType.Integer;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);
            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 1);
            Assert.AreEqual(result[0].Value is long, true);
            Assert.AreEqual(result[0].Value, 580);
        }
        public void Should_Return_ValuesConvertedToDateTime()
        {
            var service = new DefaultOptionService(null);
            var optionValues = new List<IOption>();
            var options = new List<IOption>();

            var option = TestDataProvider.CreateNewLayoutOption();
            option.DefaultValue = "10/10/2010";
            option.Type = OptionType.DateTime;
            options.Add(option);

            var result = service.GetMergedOptionValues(options, optionValues);
            Assert.NotNull(result);
            Assert.AreEqual(result.Count, 1);
            Assert.AreEqual(result[0].Value is DateTime, true);
            Assert.AreEqual(result[0].Value, new DateTime(2010, 10, 10));
        }