Esempio n. 1
0
        public void CanDeploy_SecurityRoleLink_ByName()
        {
            var securityGroup = ModelGeneratorService.GetRandomDefinition <SecurityGroupDefinition>();
            var securityRole  = ModelGeneratorService.GetRandomDefinition <SecurityRoleDefinition>();

            var siteModel = SPMeta2Model
                            .NewSiteModel(site =>
            {
                site
                .AddSecurityGroup(securityGroup)
                .AddSecurityRole(securityRole);
            });

            var webModel = SPMeta2Model
                           .NewWebModel(web =>
            {
                web.AddRandomWeb(rndWeb =>
                {
                    rndWeb.AddRandomList(rndList =>
                    {
                        // rndList.AddRandomListItem(rndListItem =>
                        // {
                        rndList.AddBreakRoleInheritance(new BreakRoleInheritanceDefinition(),
                                                        secureListItem =>
                        {
                            secureListItem.AddSecurityGroupLink(securityGroup, group =>
                            {
                                group.AddSecurityRoleLink(new SecurityRoleLinkDefinition
                                {
                                    SecurityRoleName = securityRole.Name
                                });
                            });
                        });


                        // });
                    });
                });
            });


            TestModels(new[] { siteModel, webModel });
        }
Esempio n. 2
0
        public void CanDeploy_Default_PublishingPage()
        {
            var siteFeature = BuiltInSiteFeatures.SharePointServerPublishingInfrastructure.Inherit(f => f.Enable());
            var webFeature  = BuiltInWebFeatures.SharePointServerPublishing.Inherit(f => f.Enable());

            var page = ModelGeneratorService.GetRandomDefinition <PublishingPageDefinition>();

            var siteModel = SPMeta2Model.NewSiteModel(site => site.AddSiteFeature(siteFeature));
            var webModel  = SPMeta2Model.NewWebModel(web =>
            {
                web.AddWebFeature(webFeature);
                web.AddHostList(BuiltInListDefinitions.Pages, list =>
                {
                    list.AddPublishingPage(page);
                });
            });

            TestModels(new ModelNode[] { siteModel, webModel });
        }
        public void CanDeploy_CoreProperty_As_URL()
        {
            WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
            {
                var propDef = ModelGeneratorService.GetRandomDefinition <CorePropertyDefinition>(def =>
                {
                    def.Type   = BuiltInPropertyDataType.URL;
                    def.Length = 1 + Rnd.Int(10);
                });

                var model = SPMeta2Model.NewSiteModel(site =>
                {
                    site.AddCoreProperty(propDef);
                });


                TestModel(model);
            });
        }
Esempio n. 4
0
        public void CanDeploy_XsltListViewWebPart_WithXslLink()
        {
            var xslFileName = string.Format("m2.{0}.xsl", Rnd.String());

            var xsltListViewWebpart = ModelGeneratorService.GetRandomDefinition <XsltListViewWebPartDefinition>(def =>
            {
                def.ListId    = Guid.Empty;
                def.ListTitle = BuiltInListDefinitions.SitePages.Title;
                def.ListUrl   = string.Empty;

                def.ViewName = string.Empty;
                def.ViewId   = null;

                // this needs to be set to get XslLink working
                // either SP1 issue or http context = null
                def.BaseXsltHashKey = Guid.NewGuid().ToString();
                def.XslLink         = "/Style Library/" + xslFileName;
            });

            var model = SPMeta2Model
                        .NewWebModel(web =>
            {
                web
                .AddHostList(BuiltInListDefinitions.StyleLibrary, list =>
                {
                    list.AddModuleFile(new ModuleFileDefinition
                    {
                        Content  = Encoding.UTF8.GetBytes(XsltStrings.XsltListViewWebPart_TestXsl),
                        FileName = xslFileName
                    });
                })
                .AddHostList(BuiltInListDefinitions.SitePages, list =>
                {
                    list
                    .AddRandomWebPartPage(page =>
                    {
                        page.AddXsltListViewWebPart(xsltListViewWebpart);
                    });
                });
            });

            TestModel(model);
        }
Esempio n. 5
0
        public void CanDeploy_LookupField_AsSingleSelectAndBindToListUrl_OnSubWeb()
        {
            var subWeb = ModelGeneratorService.GetRandomDefinition <WebDefinition>(def =>
            {
            });

            var lookupEnvironment = GetLookupFieldEnvironment(env =>
            {
                env.LookupField.LookupListUrl = env.ChildList.GetListUrl();
                env.LookupField.LookupWebUrl  = UrlUtility.CombineUrl("~sitecollection", subWeb.Url);
            }, subWeb);

            TestModels(new ModelNode[]
            {
                lookupEnvironment.ChildListModel,
                lookupEnvironment.SiteModel,
                lookupEnvironment.MasterListModel
            });
        }
        public void CanDeploy_TaxonomyFieldBindedToTermById()
        {
            var termSet = new TaxonomyTermSetDefinition
            {
                Name        = Rnd.String(),
                Description = Rnd.String(),
            };

            var term = new TaxonomyTermDefinition
            {
                Name        = Rnd.String(),
                Description = Rnd.String(),
                Id          = Guid.NewGuid()
            };

            var taxField = ModelGeneratorService.GetRandomDefinition <TaxonomyFieldDefinition>(def =>
            {
                def.TermSetName = termSet.Name;
                def.TermId      = term.Id.Value;
            });

            var taxonomyModel = SPMeta2Model.NewSiteModel(site =>
            {
                site.AddRandomTermStore(termStore =>
                {
                    termStore.AddRandomTermGroup(group =>
                    {
                        group.AddTaxonomyTermSet(termSet, t =>
                        {
                            t.AddTaxonomyTerm(term);
                        });
                    });
                });
            });

            var fieldModel = SPMeta2Model
                             .NewSiteModel(site =>
            {
                site.AddTaxonomyField(taxField);
            });

            TestModels(new[] { taxonomyModel, fieldModel });
        }
        public void CanDeploy_TaxonomyFieldAsEmptyMiltiSelect()
        {
            var taxField = ModelGeneratorService.GetRandomDefinition <TaxonomyFieldDefinition>(def =>
            {
                def.IsMulti = true;

                def.UseDefaultSiteCollectionTermStore = false;
                def.SspId   = null;
                def.SspName = string.Empty;
            });

            var model = SPMeta2Model
                        .NewSiteModel(site =>
            {
                site.AddTaxonomyField(taxField);
            });

            TestModel(model);
        }
Esempio n. 8
0
        public void CanDeploy_XsltListViewWebPart_ByListId()
        {
            WithDisabledDefinitionImmutabilityValidation(() =>
            {
                var sourceList          = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def => { });
                var xsltListViewWebpart =
                    ModelGeneratorService.GetRandomDefinition <XsltListViewWebPartDefinition>(def =>
                {
                    // list id will be updated later in OnProvisioned
                    // we need to set something here
                    // to pass property validation which requires one of the properties set
                    def.ListId    = Guid.NewGuid();
                    def.ListTitle = string.Empty;
                    def.ListUrl   = string.Empty;

                    def.ViewName = string.Empty;
                    def.ViewId   = null;
                });

                var model = SPMeta2Model
                            .NewWebModel(web =>
                {
                    web
                    .AddList(sourceList, list =>
                    {
                        list.OnProvisioned <object>(context =>
                        {
                            xsltListViewWebpart.ListId = ExtractListId(context);
                        });
                    })
                    .AddHostList(BuiltInListDefinitions.SitePages, list =>
                    {
                        list
                        .AddRandomWebPartPage(page =>
                        {
                            page.AddXsltListViewWebPart(xsltListViewWebpart);
                        });
                    });
                });

                TestModel(model);
            });
        }
        public void CanDeploy_ListItem_ToList()
        {
            var list = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
            {
                def.EnableMinorVersions = false;
                def.TemplateType        = BuiltInListTemplateTypeId.GenericList;
            });

            var model = SPMeta2Model
                        .NewWebModel(web =>
            {
                web.AddList(list, rndList =>
                {
                    rndList.AddRandomListItem();
                });
            });

            TestModel(model);
        }
Esempio n. 10
0
        public void CanDeploy_ModuleFile_MoreThan_511_Times_WithModeration()
        {
            if (!TestOptions.EnableModuleFile511Tests)
            {
                return;
            }

            var list = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
            {
                def.EnableVersioning    = true;
                def.EnableMinorVersions = true;

                def.EnableModeration = true;

                def.TemplateType = BuiltInListTemplateTypeId.DocumentLibrary;
            });

            CanDeploy_ModuleFile_MoreThan_511_Times(list);
        }
Esempio n. 11
0
        protected void AddWebWorkflow(ModelNode web)
        {
            var workflow = ModelGeneratorService.GetRandomDefinition <SP2013WorkflowDefinition>();

            var historyList = GetHistoryList();
            var taskList    = GetTaskList();

            web
            .AddSP2013Workflow(workflow)
            .AddList(historyList)
            .AddList(taskList)
            .AddSP2013WorkflowSubscription(new SP2013WorkflowSubscriptionDefinition
            {
                Name = Rnd.String(),
                WorkflowDisplayName = workflow.DisplayName,
                HistoryListUrl      = historyList.GetListUrl(),
                TaskListUrl         = taskList.GetListUrl()
            });
        }
Esempio n. 12
0
        public void CanDeploy_ReusableItemsToFolder()
        {
            var reusableHtml = ModelGeneratorService.GetRandomDefinition <ReusableHTMLItemDefinition>();
            var reusableText = ModelGeneratorService.GetRandomDefinition <ReusableTextItemDefinition>();

            var model = SPMeta2Model.NewWebModel(web =>
            {
                web.AddHostList(BuiltInListDefinitions.ReusableContent, list =>
                {
                    list.AddRandomFolder(folder =>
                    {
                        folder.AddReusableHTMLItem(reusableHtml);
                        folder.AddReusableTextItem(reusableText);
                    });
                });
            });

            TestModel(model);
        }
        public void CanDeploy_TaxonomyTermGroupByNameAndId()
        {
            var termGroup = ModelGeneratorService.GetRandomDefinition <TaxonomyTermGroupDefinition>(def =>
            {
                def.Id = Guid.NewGuid();
            });

            var model = SPMeta2Model
                        .NewSiteModel(site =>
            {
                site
                .AddRandomTermStore(store =>
                {
                    store.AddTaxonomyTermGroup(termGroup);
                });
            });

            TestModel(model);
        }
Esempio n. 14
0
        public void CanDeploy_MetadataNavigationSettings_With_Hierarchies_And_KeyFilters()
        {
            WithExcpectedException(typeof(SPMeta2NotImplementedException),
                                   () =>
            {
                var managedNavSettings = ModelGeneratorService.GetRandomDefinition <MetadataNavigationSettingsDefinition>(
                    def =>
                {
                    def.Hierarchies.Clear();
                    def.KeyFilters.Clear();

                    def.Hierarchies.Add(new MetadataNavigationHierarchy
                    {
                        FieldId = BuiltInFieldId.ContentTypeId
                    });

                    def.KeyFilters.Add(new MetadataNavigationKeyFilter
                    {
                        FieldId = BuiltInFieldId.Created
                    });

                    def.KeyFilters.Add(new MetadataNavigationKeyFilter
                    {
                        FieldId = BuiltInFieldId.Modified
                    });
                });

                var model = SPMeta2Model.NewWebModel(web =>
                {
                    web.AddWebFeature(BuiltInWebFeatures.MetadataNavigationAndFiltering.Inherit(f =>
                    {
                        f.Enable = true;
                    }));

                    web.AddRandomDocumentLibrary(list =>
                    {
                        list.AddMetadataNavigationSettings(managedNavSettings);
                    });
                });

                TestModel(model);
            });
        }
        public void CanDeploy_SecurityGroupLink_OnPublishingPage()
        {
            var securityGroup = ModelGeneratorService.GetRandomDefinition <SecurityGroupDefinition>();

            var siteModel = SPMeta2Model
                            .NewSiteModel(site =>
            {
                site.AddSecurityGroup(securityGroup);
                site.AddSiteFeature(BuiltInSiteFeatures.SharePointServerPublishingInfrastructure.Inherit(f =>
                {
                    f.Enable = true;
                }));
            });

            var webModel = SPMeta2Model
                           .NewWebModel(web =>
            {
                web.AddRandomWeb(rndWeb =>
                {
                    rndWeb.AddWebFeature(BuiltInWebFeatures.SharePointServerPublishing.Inherit(f =>
                    {
                        f.Enable = true;
                    }));

                    rndWeb.AddHostList(BuiltInListDefinitions.Pages, sitePages =>
                    {
                        sitePages.AddRandomPublishingPage(page =>
                        {
                            page.OnProvisioning <object>(context =>
                            {
                                TurnOffValidation(page);
                            });

                            AddSecurityGroupLinkWithRoleLinks(page, securityGroup);
                        });
                    });
                });
            });


            TestModels(new ModelNode[] { siteModel, webModel });
        }
Esempio n. 16
0
        public void CanDeploy_Default_WebPartPage_With_ContentType_ByName()
        {
            var webFeature = BuiltInWebFeatures.WikiPageHomePage.Inherit(f => f.Enable());

            var contentTypeDef = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>(def =>
            {
                def.ParentContentTypeId = BuiltInContentTypeId.WebPartPage;
            });

            var itemDef = ModelGeneratorService.GetRandomDefinition <WebPartPageDefinition>(def =>
            {
                def.ContentTypeName = contentTypeDef.Name;
            });

            var siteModel = SPMeta2Model.NewSiteModel(site =>
            {
                site.AddContentType(contentTypeDef);
            });

            var listDef = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
            {
                def.ContentTypesEnabled = true;
                def.TemplateType        = BuiltInListTemplateTypeId.DocumentLibrary;
            });

            var webModel = SPMeta2Model.NewWebModel(web =>
            {
                web.AddFeature(webFeature);

                //web.AddHostList(BuiltInListDefinitions.SitePages.Inherit(d =>
                web.AddList(listDef.Inherit(d =>
                {
                    d.ContentTypesEnabled = true;
                }), list =>
                {
                    list.AddContentTypeLink(contentTypeDef);
                    list.AddWebPartPage(itemDef);
                });
            });

            TestModel(siteModel, webModel);
        }
Esempio n. 17
0
        public void CanDeploy_Simple_Site_WithNullableSecondaryContactLogin()
        {
            WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
            {
                var site = ModelGeneratorService.GetRandomDefinition <SiteDefinition>();

                //site.PrefixName = string.Empty;

                site.SecondaryContactEmail = null;
                site.SecondaryContactLogin = null;
                site.SecondaryContactName  = null;

                var model = SPMeta2Model.NewWebApplicationModel(webApplication =>
                {
                    webApplication.AddSite(site);
                });

                TestModel(model);
            });
        }
Esempio n. 18
0
        public void CanDeploy_LookupField_With_CountRelated()
        {
            var field1 = ModelGeneratorService.GetRandomDefinition <LookupFieldDefinition>(def =>
            {
                def.CountRelated = Rnd.Bool();
            });

            var field2 = ModelGeneratorService.GetRandomDefinition <LookupFieldDefinition>(def =>
            {
                def.CountRelated = !field1.CountRelated;
            });

            var siteModel = SPMeta2Model.NewSiteModel(site =>
            {
                site.AddField(field1);
                site.AddField(field2);
            });

            TestModel(siteModel);
        }
Esempio n. 19
0
        public void CanDeploy_WelcomePage_ToLibraryFolder()
        {
            var listDefinition = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
            {
                def.TemplateType = BuiltInListTemplateTypeId.DocumentLibrary;
            });

            var model = SPMeta2Model.NewWebModel(web =>
            {
                web.AddList(listDefinition, list =>
                {
                    list.AddRandomFolder(folder =>
                    {
                        folder.AddRandomWelcomePage();
                    });
                });
            });

            TestModel(model);
        }
Esempio n. 20
0
        public void CanDeploy_Field_WithRawXmlAndAdditionalAttributes()
        {
            WithDisabledPropertyUpdateValidation(() =>
            {
                var internalName = Rnd.String();
                var id           = Guid.NewGuid();
                var title        = Rnd.String();
                var group        = Rnd.String();

                var xmlElement = new XElement("Field",
                                              new XAttribute(BuiltInFieldAttributes.ID, id.ToString("B")),
                                              new XAttribute(BuiltInFieldAttributes.StaticName, internalName),
                                              new XAttribute(BuiltInFieldAttributes.DisplayName, title),
                                              new XAttribute(BuiltInFieldAttributes.Title, title),
                                              new XAttribute(BuiltInFieldAttributes.Name, internalName),
                                              new XAttribute(BuiltInFieldAttributes.Type, BuiltInFieldTypes.Text),
                                              new XAttribute(BuiltInFieldAttributes.Group, group));

                var def = ModelGeneratorService.GetRandomDefinition <FieldDefinition>();

                // ID/InternalName should be defined to be able to lookup the field
                def.Id           = id;
                def.FieldType    = BuiltInFieldTypes.Text;
                def.InternalName = internalName;
                def.Title        = title;
                def.Group        = group;

                def.RawXml = xmlElement.ToString();

                def.AdditionalAttributes.Add(new FieldAttributeValue("Commas", Rnd.Bool().ToString().ToUpper()));
                def.AdditionalAttributes.Add(new FieldAttributeValue("AllowDuplicateValues",
                                                                     Rnd.Bool().ToString().ToUpper()));

                var siteModel = SPMeta2Model.NewSiteModel(site =>
                {
                    site.AddField(def);
                });

                TestModel(siteModel);
            });
        }
Esempio n. 21
0
        public void CanDeploy_ContentTypeLink_With_SiteAndWebContentTypes()
        {
            var siteContentType = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>();
            var webContentType  = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>();

            var webList = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
            {
                def.ContentTypesEnabled = true;
            });

            var siteModel = SPMeta2Model.NewSiteModel(site =>
            {
                site.AddContentType(siteContentType);
            });

            var webModel = SPMeta2Model.NewWebModel(web =>
            {
                web.AddWebFeature(BuiltInWebFeatures.WikiPageHomePage.Inherit(f =>
                {
                    f.Enable = true;
                }));

                web.AddRandomWeb(subWeb =>
                {
                    subWeb.AddWebFeature(BuiltInWebFeatures.WikiPageHomePage.Inherit(f =>
                    {
                        f.Enable = true;
                    }));

                    subWeb.AddContentType(webContentType);

                    subWeb.AddList(webList, list =>
                    {
                        list.AddContentTypeLink(siteContentType);
                        list.AddContentTypeLink(webContentType);
                    });
                });
            });

            TestModel(siteModel, webModel);
        }
Esempio n. 22
0
        public void CanDeploy_DocumentLibrary_With_WebCollectionToken_DocumentTemplateUrl()
        {
            var templateFileName = Rnd.TxtFileName();

            var webModel = SPMeta2Model
                           .NewWebModel(web =>
            {
                var randomList = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
                {
                    //def.EnableVersioning = true;
                    //def.EnableMinorVersions = true;

                    //def.EnableModeration = true;

                    def.TemplateType = BuiltInListTemplateTypeId.DocumentLibrary;
                });

                // add first to provision, add a module
                web.AddList(randomList, list =>
                {
                    list.AddHostFolder(BuiltInFolderDefinitions.Forms, folder =>
                    {
                        folder.AddModuleFile(new ModuleFileDefinition
                        {
                            FileName = templateFileName,
                            Content  = Encoding.UTF8.GetBytes(Rnd.String())
                        });
                    });
                });

                // add a clone second time with the template
                var listWithDocumentTemplate = randomList.Inherit();
#pragma warning disable 618
                listWithDocumentTemplate.DocumentTemplateUrl = string.Format("~site/" + randomList.GetListUrl() + "/Forms/" + templateFileName);
#pragma warning restore 618

                web.AddList(listWithDocumentTemplate);
            });

            TestModel(webModel);
        }
Esempio n. 23
0
        public void CanGetHashForAllDefinitions()
        {
            var service = new MD5HashCodeServiceBase();


            var spMetaAssembly         = typeof(FieldDefinition).Assembly;
            var spMetaStandardAssembly = typeof(TaxonomyFieldDefinition).Assembly;

            var allDefinitions = ReflectionUtils.GetTypesFromAssemblies <DefinitionBase>(new[]
            {
                spMetaAssembly,
                spMetaStandardAssembly
            });

            var hashes = new Dictionary <string, string>();

            Trace.WriteLine("Checking hashes for definitions...");

            foreach (var defType in allDefinitions)
            {
                var defInstance = ModelGeneratorService.GetRandomDefinition(defType);
                Trace.WriteLine(string.Format("Definition:[{0}] - [{1}]", defType, defInstance));

                TraceUtils.WithScope(trace =>
                {
                    var hash1 = service.GetHashCode(defInstance);
                    var hash2 = service.GetHashCode(defInstance);

                    trace.WriteLine(string.Format("HASH1:[{0}]", hash1));
                    trace.WriteLine(string.Format("HASH1:[{0}]", hash2));

                    // just curious, would it ever blow up on duplicate?
                    hashes.Add(hash1, hash1);

                    Assert.IsNotNull(hash1);
                    Assert.IsNotNull(hash2);

                    Assert.IsTrue(hash1 == hash2);
                });
            }
        }
        protected CalculatedFieldDefinition GetCalculatedFieldDefinition(Action <CalculatedFieldDefinition> action)
        {
            var result = ModelGeneratorService.GetRandomDefinition <CalculatedFieldDefinition>(def =>
            {
                def.ShowInNewForm     = true;
                def.ShowInEditForm    = true;
                def.ShowInDisplayForm = true;

                def.ShowInListSettings = true;

                def.Hidden   = false;
                def.Required = false;
            });

            if (action != null)
            {
                action(result);
            }

            return(result);
        }
Esempio n. 25
0
        public void CanDeploy_SecurityRoleLink_Under_SecurityGroup()
        {
            // Incorrect provision order for SecurityGroup / SecurityRole #1017
            // https://github.com/SubPointSolutions/spmeta2/issues/1017

            var securityGroupDef = ModelGeneratorService.GetRandomDefinition <SecurityGroupDefinition>();
            var securityRoleDef  = ModelGeneratorService.GetRandomDefinition <SecurityRoleDefinition>();

            var siteModel = SPMeta2Model.NewSiteModel(site =>
            {
                site
                .AddSecurityRole(securityRoleDef)
                .AddSecurityGroup(securityGroupDef, securityGroup =>
                {
                    securityGroup.AddSecurityRoleLink(securityRoleDef.Name);
                });
            });


            TestModel(siteModel);
        }
        public void CanDeploy_TaxonomyTermSetByName()
        {
            var termSet = ModelGeneratorService.GetRandomDefinition <TaxonomyTermSetDefinition>(def =>
            {
            });

            var model = SPMeta2Model
                        .NewSiteModel(site =>
            {
                site
                .AddRandomTermStore(store =>
                {
                    store.AddRandomTermGroup(group =>
                    {
                        group.AddTaxonomyTermSet(termSet);
                    });
                });
            });

            TestModel(model);
        }
        public void CanDeploy_LookupField_AsSingleSelectAndBindToListByTitle_OnSubWeb()
        {
            WithDisabledPropertyUpdateValidation(() =>
            {
                var subWeb = ModelGeneratorService.GetRandomDefinition <WebDefinition>(def =>
                {
                });

                var lookupEnvironment = GetLookupFieldEnvironment(env =>
                {
                    env.LookupField.LookupListTitle = env.ChildList.Title;
                    env.LookupField.LookupWebUrl    = UrlUtility.CombineUrl("~sitecollection", subWeb.Url);
                }, subWeb);

                TestModels(new ModelNode[] {
                    lookupEnvironment.ChildListModel,
                    lookupEnvironment.SiteModel,
                    lookupEnvironment.MasterListModel
                });
            });
        }
        public void CanDeploy_ContentTypeFieldLink_OnSiteContentType()
        {
            var siteFieldOne = ModelGeneratorService.GetRandomDefinition <FieldDefinition>();
            var siteFieldTwo = ModelGeneratorService.GetRandomDefinition <FieldDefinition>();

            var siteContentType = ModelGeneratorService.GetRandomDefinition <ContentTypeDefinition>();

            var siteModel = SPMeta2Model.NewSiteModel(site =>
            {
                site.AddField(siteFieldOne);
                site.AddField(siteFieldTwo);

                site.AddContentType(siteContentType, c =>
                {
                    c.AddContentTypeFieldLink(siteFieldOne);
                    c.AddContentTypeFieldLink(siteFieldTwo);
                });
            });

            TestModels(new[] { siteModel });
        }
Esempio n. 29
0
        public void CanDeploy_ModuleFile_ToLibrary_FormsFolder()
        {
            var list = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
            {
                def.TemplateType = BuiltInListTemplateTypeId.DocumentLibrary;
            });

            var model = SPMeta2Model
                        .NewWebModel(web =>
            {
                web.AddList(list, rndList =>
                {
                    rndList.AddHostFolder(BuiltInFolderDefinitions.Forms, folder =>
                    {
                        folder.AddRandomModuleFile();
                    });
                });
            });

            TestModel(model);
        }
Esempio n. 30
0
        public void CanDeploy_ListItemEventReceiver()
        {
            var eventReceiver = ModelGeneratorService.GetRandomDefinition <EventReceiverDefinition>();

            eventReceiver.Assembly = "Microsoft.SharePoint, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c";
            eventReceiver.Class    = "Microsoft.SharePoint.Help.HelpLibraryEventReceiver";

            eventReceiver.Synchronization = BuiltInEventReceiverSynchronization.Synchronous;
            eventReceiver.Type            = BuiltInEventReceiverType.ItemAdded;

            var model = SPMeta2Model
                        .NewWebModel(web =>
            {
                web.AddRandomList(list =>
                {
                    list.AddEventReceiver(eventReceiver);
                });
            });

            TestModel(model);
        }
Esempio n. 31
0
        public static TextFieldDefinition GetRandomTextField(ModelGeneratorService service)
        {
            return service.GetRandomDefinition<TextFieldDefinition>(def =>
            {
                def.ShowInDisplayForm = true;
                def.ShowInEditForm = true;
                def.ShowInListSettings = true;
                def.ShowInNewForm = true;
                def.ShowInVersionHistory = true;
                def.ShowInViewForms = true;

                def.ValidationFormula = null;
                def.ValidationMessage = null;

                def.Indexed = false;
                def.Hidden = false;

                def.DefaultValue = string.Empty;
                def.Required = true;

            });
        }