public void CanDeploy_FarmSolution_As_Default_UnderTwoWebApplication()
{
// the same wsp package is to be deployed under different web app
// checking that the same *.wsp package can be sfaely deployed under two web app
// such deployment and retraction should only be scoped to a particular web app not affecting other web app deployments
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var webApp1 = ModelGeneratorService.GetRandomDefinition <WebApplicationDefinition>(def =>
{
def.Port = 31401;
def.UseSecureSocketsLayer = false;
});
var webApp2 = ModelGeneratorService.GetRandomDefinition <WebApplicationDefinition>(def =>
{
def.Port = 31402;
def.UseSecureSocketsLayer = false;
});
var solutionDef1 = GetFarmSolutionDefinition(true, def =>
{
//def.ShouldRetract = true;
def.ShouldDeploy = true;
});
var solutionDef2 = GetFarmSolutionDefinition(true, def =>
{
// the same wsp package is to be deployed under different web app
def.FileName = solutionDef1.FileName;
//def.ShouldRetract = true;
def.ShouldDeploy = true;
});
var farmModel = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddWebApplication(webApp1, webApp =>
{
webApp.RegExcludeFromValidation();
webApp.AddFarmSolution(solutionDef1, solution =>
{
});
});
farm.AddWebApplication(webApp2, webApp =>
{
webApp.RegExcludeFromValidation();
webApp.AddFarmSolution(solutionDef2, solution =>
{
});
});
});
TestModel(farmModel);
});
}
public void CanDeploy_ManagedProperty_WithWrongCrawledProperty_OnFarm()
{
// https://github.com/SubPointSolutions/spmeta2/pull/680
// Whenever you try to assign a mapping for a crawled property
// which doesn't exist to the mappings property of a ManagedPropertyDefinition
// you'll get a null reference exception.
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var managedProperty = ModelGeneratorService.GetRandomDefinition <ManagedPropertyDefinition>(def =>
{
def.Mappings.Clear();
def.Mappings.Add(new ManagedPropertyMappping
{
CrawledPropertyName = Rnd.String()
});
});
var mdoel = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddManagedProperty(managedProperty);
});
TestModel(mdoel);
});
}
protected virtual void TestFarmSolutionModel(FarmSolutionDefinition solutionDef, bool isWebApplicationLevel)
{
var newSolutiondef = solutionDef.Inherit();
if (isWebApplicationLevel)
{
var originalModel = SPMeta2Model.NewWebApplicationModel(webApp =>
{
webApp.AddFarmSolution(solutionDef);
});
var newModel = SPMeta2Model.NewWebApplicationModel(farm =>
{
farm.AddFarmSolution(newSolutiondef);
});
TestModel(originalModel);
TestModel(newModel);
}
else
{
var originalModel = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddFarmSolution(solutionDef);
});
var newModel = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddFarmSolution(newSolutiondef);
});
TestModel(originalModel);
TestModel(newModel);
}
}
public void CanDeploy_FarmModel()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var model = SPMeta2Model.NewFarmModel(m => { });
TestModel(model);
});
}
public void Should_Pass_On_Valid_SSOM_Invalid_CSOM_2()
{
var model = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddProperty(ModelGeneratorService.GetRandomDefinition <PropertyDefinition>());
});
// - CSOM / + SSOM
Assert.IsFalse(SPMeta2Model.IsCSOMCompatible(model));
Assert.IsTrue(SPMeta2Model.IsSSOMCompatible(model));
}
public void CanDeploy_PropertyBag_OnFarm()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var model = SPMeta2Model
.NewFarmModel(farm =>
{
farm.AddRandomPropertyBag();
});
TestModel(model);
});
}
public void CanDeploy_ManagedProperty_OnFarm()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var managedProperty = ModelGeneratorService.GetRandomDefinition <ManagedPropertyDefinition>();
var mdoel = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddManagedProperty(managedProperty);
});
TestModel(mdoel);
});
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimpleFarmDefinition()
{
var farmFeature = BuiltInFarmFeatures.SiteMailboxes.Inherit(f =>
{
f.Enable = true;
});
var model = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddFarmFeature(farmFeature);
});
DeployModel(model);
}
public void CanPassTypedSyntax_FarmLevel()
{
var model = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddProperty(new PropertyDefinition());
farm.AddFeature(new FeatureDefinition());
farm.AddFarmFeature(new FeatureDefinition());
farm.AddFarmSolution(new FarmSolutionDefinition());
farm.AddManagedProperty(new ManagedPropertyDefinition());
farm.AddDiagnosticsServiceBase(new DiagnosticsServiceBaseDefinition());
});
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimpleFarmSolutionDefinition()
{
var solutionDef = new FarmSolutionDefinition
{
FileName = "your-solution-file.wsp",
SolutionId = new Guid("your-solution-id"),
Content = File.ReadAllBytes("path-to-your-solution-or-byte-array")
};
var model = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddFarmSolution(solutionDef);
});
DeployModel(model);
}
protected virtual void TestFarmSolutionModel(FarmSolutionDefinition solutionDef)
{
var newSolutiondef = solutionDef.Inherit();
var originalModel = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddFarmSolution(solutionDef);
});
var newModel = SPMeta2Model.NewFarmModel(farm =>
{
farm.AddFarmSolution(newSolutiondef);
});
TestModel(originalModel);
TestModel(newModel);
}
public void SPMeta2Model_NewFarmModel_Contract()
{
var expectedType = typeof(FarmModelNode);
var newDefinition = new FarmDefinition();
// new
Assert.IsTrue(SPMeta2Model.NewFarmModel().GetType() == expectedType);
// new with callback
Assert.IsTrue(SPMeta2Model.NewFarmModel(model => { }).GetType() == expectedType);
// new definition
Assert.IsTrue(SPMeta2Model.NewFarmModel(newDefinition).GetType() == expectedType);
// new definition with callback
Assert.IsTrue(SPMeta2Model.NewFarmModel(newDefinition, farm => { }).GetType() == expectedType);
}
public void CanDeploy_FarmFeature()
{
WithExpectedUnsupportedCSOMnO365RunnerExceptions(() =>
{
var model = SPMeta2Model
.NewFarmModel(farm =>
{
farm.AddFeature(new FeatureDefinition
{
Enable = true,
ForceActivate = true,
Id = BuiltInFarmFeatures.DataConnectionLibrary.Id,
Scope = FeatureDefinitionScope.Farm
});
});
TestModel(model);
});
}
public void Deploy_FarmModel_SSOM()
{
// create you model
var farmModel = SPMeta2Model.NewFarmModel(farm =>
{
});
var spFarm = SPFarm.Local;
// deploy site model with SharePoint Foundation SSOM API
var foundationProvisionService = new SSOMProvisionService();
foundationProvisionService.DeployFarmModel(spFarm, farmModel);
// deploy site model with SharePoint Standard SSOM API
var standardProvisionService = new StandardSSOMProvisionService();
standardProvisionService.DeployFarmModel(spFarm, farmModel);
}
public void CanPassTypedSyntax_FarmLevel()
{
var model = SPMeta2Model.NewFarmModel(farm =>
{
farm
.AddProperty(new PropertyDefinition())
.AddProperty(new PropertyDefinition());
farm.AddTrustedAccessProvider(new TrustedAccessProviderDefinition());
farm.AddFeature(new FeatureDefinition());
farm.AddFarmFeature(new FeatureDefinition());
farm.AddFarmSolution(new FarmSolutionDefinition());
farm.AddManagedProperty(new ManagedPropertyDefinition());
farm.AddDiagnosticsServiceBase(new DiagnosticsServiceBaseDefinition());
farm.AddDeveloperDashboardSettings(new DeveloperDashboardSettingsDefinition());
});
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeployPropertyBagUnderFarm()
{
var farmTag = new PropertyDefinition
{
Key = "m2_farm_tag",
Value = "m2_farm_tag_value",
};
var farmType = new PropertyDefinition
{
Key = "m2_farm_type",
Value = "m2_farm_type_value",
};
var model = SPMeta2Model.NewFarmModel(farm =>
{
farm
.AddProperty(farmTag)
.AddProperty(farmType);
});
DeploySSOMModel(model);
}
public ModelNode GenerateModelTreeForDefinition(Type definitionType, SPObjectModelType objectModelType)
{
ModelNode result = null;
var rootHostType = GetRootHostType(definitionType, objectModelType);
var parentHostType = GetParentHostType(definitionType, objectModelType);
var currentDefinition = GetRandomDefinition(definitionType);
var expectManyInstancesAttr = definitionType.GetCustomAttribute <ExpectManyInstances>(false);
var manyInstances = new List <DefinitionBase>();
if (expectManyInstancesAttr != null)
{
var maxCount = expectManyInstancesAttr.MinInstancesCount +
Rnd.Int(expectManyInstancesAttr.MaxInstancesCount -
expectManyInstancesAttr.MinInstancesCount);
for (int i = 0; i < maxCount; i++)
{
manyInstances.Add(GetRandomDefinition(definitionType));
}
}
CurrentDefinitions.Clear();
CurrentDefinitions.Add(currentDefinition);
CurrentDefinitions.AddRange(manyInstances);
//CurrentDefinition = currentDefinition;
var defs = new List <GeneratedNodes>();
LookupModelTree(rootHostType, definitionType, defs, objectModelType);
if (defs.Count > 0)
{
defs.Reverse();
var rootHost = defs[0].ModelNode;
parentHostType = rootHost.Value.GetType();
defs.RemoveAt(0);
ModelNode model = null;
if (parentHostType == typeof(FarmDefinition))
{
model = SPMeta2Model.NewFarmModel();
}
if (parentHostType == typeof(WebApplicationDefinition))
{
model = SPMeta2Model.NewWebApplicationModel();
}
if (parentHostType == typeof(SiteDefinition))
{
model = SPMeta2Model.NewSiteModel();
}
if (parentHostType == typeof(WebDefinition))
{
model = SPMeta2Model.NewWebModel();
}
var _m = model;
foreach (var def in defs)
{
_m.ChildModels.Add(def.ModelNode);
_m = def.ModelNode;
}
_m.AddDefinitionNode(currentDefinition);
foreach (var manyDef in manyInstances)
{
_m.AddDefinitionNode(manyDef);
}
result = model;
}
else
{
ModelNode resultModel = null;
if (currentDefinition.GetType() == typeof(FarmDefinition))
{
resultModel = SPMeta2Model.NewFarmModel();
}
if (currentDefinition.GetType() == typeof(WebApplicationDefinition))
{
resultModel = SPMeta2Model.NewWebApplicationModel();
}
if (currentDefinition.GetType() == typeof(SiteDefinition))
{
resultModel = SPMeta2Model.NewSiteModel();
}
if (currentDefinition.GetType() == typeof(WebDefinition))
{
resultModel = SPMeta2Model.NewWebModel();
}
if (resultModel == null)
{
throw new SPMeta2NotImplementedException(string.Format("Cannot find host model for type:[{0}]. Ensure correct RootHostAttribute/ParentHostAttribute/SPObjectTypeAttribute attributes.", definitionType.AssemblyQualifiedName));
}
resultModel.Value = currentDefinition;
result = resultModel;
}
// ProcessAdditionalArtifacts(result, defs);
return(result);
}
public void Can_Provision_Incrementally_With_AutoDetection_As_SSOM()
{
var provisionRunner = new SSOMProvisionRunner();
var provisionService = provisionRunner.ProvisionService;
var incrementalModelId = "m2.regression." + Guid.NewGuid().ToString("N");
provisionRunner.WithSSOMFarmContext(farm =>
{
for (var i = 0; i < 3; i++)
{
var incrementalProvisionConfig = new IncrementalProvisionConfig();
incrementalProvisionConfig.AutoDetectSharePointPersistenceStorage = true;
provisionService.SetIncrementalProvisionMode(incrementalProvisionConfig);
var model = SPMeta2Model.NewFarmModel(site =>
{
});
model.SetIncrementalProvisionModelId(incrementalModelId);
provisionService.DeployModel(SPMeta2.SSOM.ModelHosts.FarmModelHost.FromFarm(farm), model);
}
});
provisionRunner.WebApplicationUrls.ForEach(url =>
{
provisionRunner.WithSSOMWebApplicationContext(url, spWebApp =>
{
for (var i = 0; i < 3; i++)
{
var incrementalProvisionConfig = new IncrementalProvisionConfig();
incrementalProvisionConfig.AutoDetectSharePointPersistenceStorage = true;
provisionService.SetIncrementalProvisionMode(incrementalProvisionConfig);
var model = SPMeta2Model.NewWebApplicationModel(site =>
{
});
model.SetIncrementalProvisionModelId(incrementalModelId);
provisionService.DeployModel(SPMeta2.SSOM.ModelHosts.WebApplicationModelHost.FromWebApplication(spWebApp), model);
}
});
});
provisionRunner.SiteUrls.ForEach(siteUrl =>
{
provisionRunner.WithSSOMSiteAndWebContext((spSite, spWeb) =>
{
for (var i = 0; i < 3; i++)
{
var incrementalProvisionConfig = new IncrementalProvisionConfig();
incrementalProvisionConfig.AutoDetectSharePointPersistenceStorage = true;
provisionService.SetIncrementalProvisionMode(incrementalProvisionConfig);
var model = SPMeta2Model.NewSiteModel(site =>
{
});
model.SetIncrementalProvisionModelId(incrementalModelId);
provisionService.DeployModel(SPMeta2.SSOM.ModelHosts.WebModelHost.FromWeb(spWeb), model);
}
});
});
}
protected virtual SolutionPackageBase CreateNewSolutionPackage(
NuGetSolutionPackageService service,
Action <SolutionPackageBase> action,
RegressinModelLevel modelLevel)
{
var knownPackageType = false;
SolutionPackageBase solutionPackage = null;
if (service is SPMeta2SolutionPackageService)
{
var m2package = new SolutionPackageBase();
m2package.Name = "SPMeta2 CI Package Name";
m2package.Title = "SPMeta2 CI Package Title";
m2package.Description = "SPMeta2 CI Package description";
m2package.Id = "MetaPack.SPMeta2.CI";
m2package.Authors = "SubPoint Solutions Authors";
m2package.Company = "SubPoint Solutions Company";
m2package.Version = "1.0.0.0";
m2package.Owners = "SubPoint Solutions Owners";
m2package.ReleaseNotes = "ReleaseNotes";
m2package.Summary = "Summary";
m2package.ProjectUrl = "https://github.com/SubPointSolutions/metapack";
m2package.IconUrl = "https://github.com/SubPointSolutions/metapack/metapack.png";
m2package.LicenseUrl = "https://opensource.org/licenses/MIT";
m2package.Copyright = "Some copyright here";
m2package.Tags = "CI SPMeta2 MetaPack Tags";
var models = new List <ModelNode>();
switch (modelLevel)
{
case RegressinModelLevel.Farm:
models.Add(SPMeta2Model.NewFarmModel(farm => { }));
break;
case RegressinModelLevel.WebApplication:
models.Add(SPMeta2Model.NewWebApplicationModel(webApp => { }));
break;
case RegressinModelLevel.Site:
models.Add(SPMeta2Model.NewSiteModel(site => { }));
models.Add(SPMeta2Model.NewWebModel(web => { }));
break;
case RegressinModelLevel.Web:
models.Add(SPMeta2Model.NewWebModel(web => { }));
break;
case RegressinModelLevel.Subweb:
models.Add(SPMeta2Model.NewWebModel(web => { }));
break;
default:
throw new NotImplementedException(string.Format(
"Unsupported model level:[{0}] for model genaration",
modelLevel));
}
var index = 0;
foreach (var model in models)
{
index++;
var xmlContext = SPMeta2Model.ToXML(model);
var modelContainer = new ModelContainerBase
{
Model = Encoding.UTF8.GetBytes(xmlContext),
};
modelContainer.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Order.Id,
Value = index.ToString()
});
m2package.AddModel(modelContainer);
}
m2package.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.SolutionToolPackage.PackageId.Id,
Value = "MetaPack.SPMeta2"
});
solutionPackage = m2package;
}
if (service is SharePointPnPSolutionPackageService)
{
var pnpPackage = new SolutionPackageBase();
pnpPackage.Name = "SharePointPnP CI Package Name";
pnpPackage.Title = "SharePointPnP Package Title";
pnpPackage.Description = "SPMeta2 CI Package description";
pnpPackage.Id = "MetaPack.SharePointPnP.CI";
pnpPackage.Authors = "SubPoint Solutions Authors";
pnpPackage.Company = "SubPoint Solutions Company";
pnpPackage.Version = "1.0.0.0";
pnpPackage.Owners = "SubPoint Solutions Owners";
pnpPackage.ReleaseNotes = "ReleaseNotes";
pnpPackage.Summary = "Summary";
pnpPackage.ProjectUrl = "https://github.com/SubPointSolutions/metapack";
pnpPackage.IconUrl = "https://github.com/SubPointSolutions/metapack/metapack.png";
pnpPackage.LicenseUrl = "https://opensource.org/licenses/MIT";
pnpPackage.Copyright = "Some copyright here";
pnpPackage.Tags = "CI SPMeta2 MetaPack Tags";
// TODO
// Zip up and set the model type
var asmFolder = Path.GetDirectoryName(GetType().Assembly.Location);
var foldersPath = Path.Combine(asmFolder, @"Data/PnPTemplates/Folders");
var openXmlFolderPath = Path.Combine(asmFolder, @"Data/PnPTemplates/OpenXML");
foreach (var templateFolder in Directory.GetDirectories(foldersPath))
{
// package up into zip
var templateFolderZipFile = GetTempZipFilePath();
ZipFile.CreateFromDirectory(templateFolder, templateFolderZipFile);
var modelContainer = new ModelContainerBase
{
Model = System.IO.File.ReadAllBytes(templateFolderZipFile),
};
modelContainer.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Type.Id,
Value = "SharePointPnP.FolderZip"
});
pnpPackage.AddModel(modelContainer);
}
var openXmlPackages = Directory.GetFiles(openXmlFolderPath, "*.pnp");
foreach (var file in openXmlPackages)
{
var modelContainer = new ModelContainerBase
{
Model = System.IO.File.ReadAllBytes(file),
};
modelContainer.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Type.Id,
Value = "SharePointPnP.OpenXml"
});
pnpPackage.AddModel(modelContainer);
}
pnpPackage.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.SolutionToolPackage.PackageId.Id,
Value = "MetaPack.SharePointPnP"
});
solutionPackage = pnpPackage;
}
if (solutionPackage == null)
{
throw new NotImplementedException(string.Format(
"Unknown service type:[{0}]", service.GetType()));
}
if (action != null)
{
action(solutionPackage);
}
return(solutionPackage);
}
public ModelNode GenerateModelTreeForDefinition <TDefinition>(SPObjectModelType objectModelType)
where TDefinition : DefinitionBase, new()
{
ModelNode result = null;
var rootHostType = GetRootHostType <TDefinition>(objectModelType);
var parentHostType = GetParentHostType <TDefinition>(objectModelType);
var currentDefinition = GetRandomDefinition <TDefinition>();
CurrentDefinition = currentDefinition;
var defs = new List <GeneratedArtifact>();
LookupModelTree <TDefinition>(rootHostType, defs, objectModelType);
if (defs.Count > 0)
{
defs.Reverse();
var rootHost = defs[0].Definition;
parentHostType = rootHost.GetType();
defs.RemoveAt(0);
ModelNode model = null;
if (parentHostType == typeof(FarmDefinition))
{
model = SPMeta2Model.NewFarmModel();
}
if (parentHostType == typeof(WebApplicationDefinition))
{
model = SPMeta2Model.NewWebApplicationModel();
}
if (parentHostType == typeof(SiteDefinition))
{
model = SPMeta2Model.NewSiteModel();
}
if (parentHostType == typeof(WebDefinition))
{
model = SPMeta2Model.NewWebModel();
}
var _m = model;
foreach (var def in defs)
{
_m
.AddDefinitionNode(def.Definition, currentDef =>
{
currentDef.Options.RequireSelfProcessing = def.Definition.RequireSelfProcessing;
_m = currentDef;
});
}
_m.AddDefinitionNode(currentDefinition);
result = model;
}
else
{
ModelNode resultModel = null;
if (currentDefinition.GetType() == typeof(FarmDefinition))
{
resultModel = SPMeta2Model.NewFarmModel();
}
if (currentDefinition.GetType() == typeof(WebApplicationDefinition))
{
resultModel = SPMeta2Model.NewWebApplicationModel();
}
if (currentDefinition.GetType() == typeof(SiteDefinition))
{
resultModel = SPMeta2Model.NewSiteModel();
}
if (currentDefinition.GetType() == typeof(WebDefinition))
{
resultModel = SPMeta2Model.NewWebModel();
}
if (resultModel == null)
{
throw new SPMeta2NotImplementedException(string.Format("Cannot find host model for type:[{0}]. Ensure correct RootHostAttribute/ParentHostAttribute/SPObjectTypeAttribute attributes.", typeof(TDefinition).AssemblyQualifiedName));
}
resultModel.Value = currentDefinition;
result = resultModel;
}
// ProcessAdditionalArtifacts(result, defs);
return(result);
}
