public override void DeployWebModel(ModelNode model)
{
if (!WebUrls.Any())
{
throw new SPMeta2Exception("WebUrls is empty");
}
foreach (var webUrl in WebUrls)
{
//var webUrl = GetTargetSiteCollectionUrl();
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
for (var provisionGeneration = 0; provisionGeneration < ProvisionGenerationCount; provisionGeneration++)
{
WithSSOMSiteAndWebContext(webUrl, (site, web) =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(WebModelHost.FromWeb(web), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromWeb(web), model);
}
});
}
}
}
/// <summary>
/// Deploys and validates target web model.
/// </summary>
/// <param name="model"></param>
public override void DeployWebModel(ModelNode model)
{
if (!WebUrls.Any())
{
throw new SPMeta2Exception("WebUrls is empty");
}
foreach (var webUrl in WebUrls)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
WithO365Context(webUrl, context =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(WebModelHost.FromClientContext(context), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromClientContext(context), model);
}
});
}
}
}
/// <summary>
/// Deploys and validates target site model.
/// </summary>
/// <param name="model"></param>
public override void DeploySiteModel(ModelNode model)
{
foreach (var siteUrl in SiteUrls)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on site: [{0}]", siteUrl));
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
WithO365Context(siteUrl, context =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(SiteModelHost.FromClientContext(context), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(SiteModelHost.FromClientContext(context), model);
}
});
}
}
}
/// <summary>
/// Deploys and validates target web model.
/// </summary>
/// <param name="model"></param>
public override void DeployWebModel(ModelNode model)
{
if (RandomBalancedUrls.Count > 0)
{
var url = RandomBalancedUrls[rnd.Next(0, RandomBalancedUrls.Count)];
WebOnUrl(model, url);
}
else
{
foreach (var webUrl in WebUrls)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
WithO365Context(webUrl, context =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(WebModelHost.FromClientContext(context), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromClientContext(context), model);
}
});
}
}
}
}
protected virtual void InitRunnerTypes()
{
var runnerLibraries = RunnerEnvironmentUtils.GetEnvironmentVariable(EnvironmentConsts.RunnerLibraries);
ContainerTraceUtils.WriteLine(string.Format("Testing with runner libraries: [{0}]", runnerLibraries));
if (!string.IsNullOrEmpty(runnerLibraries))
{
var libs = runnerLibraries.Split(',');
foreach (var lib in libs)
{
ProvisionRunnerAssemblies.Add(lib);
}
}
if (ProvisionRunnerAssemblies.Count == 0)
{
throw new ArgumentException("Cannot find any test runners. Please configure test runners via SPMeta2.Regression.Environment.ps1 script.");
}
// Test runners should be managed via SPMeta2.Regression.Environment.ps1
// Manual adding is for internal use only.
// ProvisionRunnerAssemblies.Add("SPMeta2.Regression.Runners.O365.dll");
// ProvisionRunnerAssemblies.Add("SPMeta2.Regression.Runners.CSOM.dll");
//ProvisionRunnerAssemblies.Clear();
//ProvisionRunnerAssemblies.Add("SPMeta2.Containers.SSOM.dll");
}
protected void WithProvisionRunnerContext(Action <ProvisionRunnerContext> action)
{
foreach (var provisionRunner in ProvisionRunners)
{
var type = provisionRunner.GetType().FullName;
provisionRunner.ProvisionGenerationCount = ProvisionGenerationCount;
provisionRunner.EnableDefinitionProvision = EnableDefinitionProvision;
provisionRunner.EnableDefinitionValidation = EnableDefinitionValidation;
CurrentProvisionRunner = provisionRunner;
ContainerTraceUtils.WriteLine(string.Format("[INF] Testing with runner impl: [{0}]", type));
ContainerTraceUtils.WriteLine(string.Format("[INF] Testing with Is64BitProcess flag: [{0}]", Environment.Is64BitProcess));
ContainerTraceUtils.WriteLine(string.Format(@"[INF] Testing as user: [{0}\{1}]", Environment.UserDomainName, Environment.UserName));
ContainerTraceUtils.WriteLine(string.Empty);
ContainerTraceUtils.WriteLine(string.Format("[INF] - Current VM: [{0}]", Environment.MachineName));
ContainerTraceUtils.WriteLine(string.Format("[INF] - Current VM CPU: [{0}]", Environment.ProcessorCount));
ContainerTraceUtils.WriteLine(string.Empty);
ContainerTraceUtils.WriteLine(string.Format("[INF] - ProvisionGenerationCount: [{0}]", ProvisionGenerationCount));
ContainerTraceUtils.WriteLine(string.Format("[INF] - EnableDefinitionValidation: [{0}]", EnableDefinitionValidation));
action(new ProvisionRunnerContext
{
Runner = provisionRunner
});
}
}
private void WebOnUrl(ModelNode model, string webUrl)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
WithO365Context(webUrl, context =>
{
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
if (EnableDefinitionProvision)
{
if (OnBeforeDeployModel != null)
{
OnBeforeDeployModel(_provisionService, model);
}
_provisionService.DeployModel(WebModelHost.FromClientContext(context), model);
if (OnAfterDeployModel != null)
{
OnAfterDeployModel(_provisionService, model);
}
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromClientContext(context), model);
}
}
});
}
private void InitServices()
{
_provisionService = new StandardSSOMProvisionService();
_validationService = new SSOMValidationService();
// TODO, setup a high level validation registration
_provisionService.PreDeploymentServices.Add(new DefaultRequiredPropertiesValidationService());
var ssomStandartAsm = typeof(ContactFieldControlModelHandler).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(ssomStandartAsm))
{
_provisionService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
var ssomStandartValidationAsm = typeof(ImageRenditionDefinitionValidator).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(ssomStandartValidationAsm))
{
_validationService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
_provisionService.OnModelNodeProcessing += (sender, args) =>
{
ContainerTraceUtils.WriteLine(
string.Format("Processing: [{0}/{1}] - [{2:0} %] - [{3}] [{4}]",
new object[] {
args.ProcessedModelNodeCount,
args.TotalModelNodeCount,
100d * (double)args.ProcessedModelNodeCount / (double)args.TotalModelNodeCount,
args.CurrentNode.Value.GetType().Name,
args.CurrentNode.Value
}));
};
_provisionService.OnModelNodeProcessed += (sender, args) =>
{
ContainerTraceUtils.WriteLine(
string.Format("Processed: [{0}/{1}] - [{2:0} %] - [{3}] [{4}]",
new object[] {
args.ProcessedModelNodeCount,
args.TotalModelNodeCount,
100d * (double)args.ProcessedModelNodeCount / (double)args.TotalModelNodeCount,
args.CurrentNode.Value.GetType().Name,
args.CurrentNode.Value
}));
};
foreach (var modelHandler in _provisionService.ModelHandlers.Values)
{
var isQA = modelHandler.GetType()
.GetProperty("IsQARun", BindingFlags.NonPublic | BindingFlags.Instance);
if (isQA != null)
{
isQA.SetValue(modelHandler, true);;
}
}
}
public override void DeployListModel(ModelNode model)
{
foreach (var webUrl in WebUrls)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
WithCSOMContext(webUrl, context =>
{
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
List list = null;
try
{
list = context.Web.QueryAndGetListByTitle("Site Pages");
}
catch (Exception ex) { }
if (list == null)
{
try
{
list = context.Web.QueryAndGetListByTitle("Pages");
}
catch (Exception ex) { }
}
if (list == null)
{
throw new SPMeta2Exception("Cannot find host list");
}
if (EnableDefinitionProvision)
{
_provisionService.DeployListModel(context, list, model);
}
if (EnableDefinitionValidation)
{
var listHost = ModelHostBase.Inherit <ListModelHost>(WebModelHost.FromClientContext(context), h =>
{
h.HostList = list;
});
_validationService.DeployModel(listHost, model);
}
}
});
}
}
private void InitServices()
{
//_provisionService = new CSOMProvisionService();
_provisionService = new StandardCSOMProvisionService();
_validationService = new CSOMValidationService();
// TODO, setup a high level validation registration
_provisionService.PreDeploymentServices.Add(new DefaultRequiredPropertiesValidationService());
var csomStandartAsm = typeof(TaxonomyFieldModelHandler).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(csomStandartAsm))
{
_provisionService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
var csomtandartValidationAsm = typeof(ClientTaxonomyFieldDefinitionValidator).Assembly;
foreach (var handlerType in ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(csomtandartValidationAsm))
{
_validationService.RegisterModelHandler(Activator.CreateInstance(handlerType) as ModelHandlerBase);
}
_provisionService.OnModelNodeProcessing += (sender, args) =>
{
ContainerTraceUtils.WriteLine(
string.Format("Processing: [{0}/{1}] - [{2:0} %] - [{3}] [{4}]",
new object[] {
args.ProcessedModelNodeCount,
args.TotalModelNodeCount,
100d * (double)args.ProcessedModelNodeCount / (double)args.TotalModelNodeCount,
args.CurrentNode.Value.GetType().Name,
args.CurrentNode.Value
}));
};
_provisionService.OnModelNodeProcessed += (sender, args) =>
{
ContainerTraceUtils.WriteLine(
string.Format("Processed: [{0}/{1}] - [{2:0} %] - [{3}] [{4}]",
new object[] {
args.ProcessedModelNodeCount,
args.TotalModelNodeCount,
100d * (double)args.ProcessedModelNodeCount / (double)args.TotalModelNodeCount,
args.CurrentNode.Value.GetType().Name,
args.CurrentNode.Value
}));
};
}
public override void DeployListModel(ModelNode model)
{
foreach (var webUrl in WebUrls)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
for (var provisionGeneration = 0; provisionGeneration < ProvisionGenerationCount; provisionGeneration++)
{
WithSSOMSiteAndWebContext(webUrl, (site, web) =>
{
var list = web.Lists.TryGetList("Site Pages");
if (list == null)
{
list = web.Lists.TryGetList("Pages");
}
if (list == null)
{
throw new SPMeta2Exception("Cannot find host list");
}
if (EnableDefinitionProvision)
{
_provisionService.DeployListModel(list, model);
}
if (EnableDefinitionValidation)
{
var listHost = ModelHostBase.Inherit <ListModelHost>(WebModelHost.FromWeb(list.ParentWeb), h =>
{
h.HostList = list;
});
_validationService.DeployModel(listHost, model);
}
});
}
}
}
private void ListOnUrl(ModelNode model, string webUrl)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
WithO365Context(webUrl, context =>
{
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
if (EnableDefinitionProvision)
{
if (OnBeforeDeployModel != null)
{
OnBeforeDeployModel(_provisionService, model);
}
var web = context.Web;
var list = web.QueryAndGetListByTitle("Site Pages");
if (list == null)
{
list = web.QueryAndGetListByTitle("Pages");
}
if (list == null)
{
throw new SPMeta2Exception("Cannot find host list");
}
var listHost = ModelHostBase.Inherit <ListModelHost>(WebModelHost.FromClientContext(context), h =>
{
h.HostList = list;
});
_provisionService.DeployModel(listHost, model);
if (OnAfterDeployModel != null)
{
OnAfterDeployModel(_provisionService, model);
}
}
if (EnableDefinitionValidation)
{
var web = context.Web;
var list = web.QueryAndGetListByTitle("Site Pages");
if (list == null)
{
list = web.QueryAndGetListByTitle("Pages");
}
if (list == null)
{
throw new SPMeta2Exception("Cannot find host list");
}
var listHost = ModelHostBase.Inherit <ListModelHost>(WebModelHost.FromClientContext(context), h =>
{
h.HostList = list;
});
_validationService.DeployModel(listHost, model);
}
}
});
}
private bool ResolveModelValidation(ModelNode modelNode, string start, List <EventHooks> hooks)
{
// should be re-written with ModelTreeTraverseService
ContainerTraceUtils.WriteLine(string.Format(""));
var hasMissedOrInvalidProps = false;
var model = modelNode.Value;
ContainerTraceUtils.WriteLine(string.Format("[INF]{2}MODEL CHECK [{0}] - ( {1} )", model.GetType(), model.ToString(), start));
//if (model.RequireSelfProcessing || modelNode.Options.RequireSelfProcessing)
if (modelNode.Options.RequireSelfProcessing)
{
var shouldProcessFlag = !modelNode.RegIsExcludedFromValidation();
if (RegExcludedDefinitionTypes.Contains(modelNode.Value.GetType()))
{
shouldProcessFlag = false;
}
if (shouldProcessFlag)
{
var modelValidationResult = ModelValidations.FirstOrDefault(r => r.Model == model);
var shouldBeValidatedProperties = model.GetType()
.GetProperties()
.Where(
p =>
p.GetCustomAttributes <SPMeta2.Attributes.Regression.ExpectValidationAttribute>().Count() >
0)
.ToList();
if (modelValidationResult == null)
{
ContainerTraceUtils.WriteLine(string.Format("[ERR]{2} Missing validation for model [{0}] - ( {1} )",
model.GetType(), model.ToString(), start));
hasMissedOrInvalidProps = true;
return(hasMissedOrInvalidProps);
}
foreach (
var property in
modelValidationResult.Properties.OrderBy(p => p.Src != null ? p.Src.Name : p.ToString()))
{
if ((!property.IsValid) ||
(property.IsValid && !ShowOnlyFalseResults))
{
ContainerTraceUtils.WriteLine(
string.Format(
"[INF]{6} [{4}] - Src prop: [{0}] Src value: [{1}] Dst prop: [{2}] Dst value: [{3}] Message:[{5}]",
new object[]
{
property.Src != null ? property.Src.Name : string.Empty,
property.Src != null ? property.Src.Value : string.Empty,
property.Dst != null ? property.Dst.Name : string.Empty,
property.Dst != null ? property.Dst.Value : string.Empty,
property.IsValid,
property.Message,
start
}));
}
if (!property.IsValid)
{
hasMissedOrInvalidProps = true;
}
}
ContainerTraceUtils.WriteLine(string.Format("[INF]{0}PROPERTY CHECK", start));
if (EnablePropertyValidation)
{
ContainerTraceUtils.WriteLine(string.Format("[INF]{0}EnablePropertyValidation == true. Checking...", start));
foreach (var shouldBeValidatedProp in shouldBeValidatedProperties.OrderBy(p => p.Name))
{
var hasValidation = false;
var validationResult =
modelValidationResult.Properties.FirstOrDefault(
r => r.Src != null && r.Src.Name == shouldBeValidatedProp.Name);
// convert stuff
if (validationResult == null)
{
validationResult = modelValidationResult.Properties.FirstOrDefault(
r => r.Src != null && r.Src.Name.Contains("." + shouldBeValidatedProp.Name + ")"));
}
// nullables
if (validationResult == null)
{
validationResult = modelValidationResult.Properties.FirstOrDefault(
r => r.Src != null &&
(r.Src.Name.Contains("System.Nullable`1") &&
r.Src.Name.Contains(shouldBeValidatedProp.Name)));
}
if (validationResult != null)
{
hasValidation = true;
}
else
{
hasMissedOrInvalidProps = true;
hasValidation = false;
}
if (hasValidation)
{
if (!ShowOnlyFalseResults)
{
ContainerTraceUtils.WriteLine(string.Format("[INF]{2} [{0}] - [{1}]",
"VALIDATED",
shouldBeValidatedProp.Name,
start));
}
}
else
{
ContainerTraceUtils.WriteLine(string.Format("[ERR]{2} [{0}] - [{1}]",
"MISSED",
shouldBeValidatedProp.Name,
start));
}
}
}
else
{
ContainerTraceUtils.WriteLine(string.Format("[INF]{0}EnablePropertyValidation == false. Skipping...", start));
}
ContainerTraceUtils.WriteLine(string.Format("[INF]{0}EVENT CHECK", start));
if (EnableEventValidation && !modelNode.RegIsExcludeFromEventsValidation())
{
ContainerTraceUtils.WriteLine(string.Format("[INF]{0}EnableEventValidation == true. Checking...", start));
var hook = hooks.FirstOrDefault(h => h.ModelNode == modelNode);
if (hook != null)
{
ResolveHook(hook, start);
}
else
{
ContainerTraceUtils.WriteLine(string.Format("[ERR]{2} Missing hook validation for model [{0}] - ( {1} )",
model.GetType(), model.ToString(), start));
}
}
else
{
ContainerTraceUtils.WriteLine(string.Format("[INF]{0}EnableEventValidation == false. Skipping...", start));
}
}
else
{
ContainerTraceUtils.WriteLine(string.Format("[INF]{0} Skipping due .RegIsExcludedFromValidation == TRUE", start));
}
}
else
{
ContainerTraceUtils.WriteLine(string.Format("[INF]{0} Skipping due RequireSelfProcessing == FALSE", start));
}
foreach (var childModel in modelNode.ChildModels)
{
var tmp = ResolveModelValidation(childModel, start + start, hooks);
if (tmp == true)
{
hasMissedOrInvalidProps = true;
}
}
return(hasMissedOrInvalidProps);
}
public void TestModels(IEnumerable <ModelNode> models, bool deployOnce)
{
// force XML serialiation
GetSerializedAndRestoredModels(models);
_hookMap.Clear();
foreach (var model in models)
{
ContainerTraceUtils.WriteLine(string.Format(".ToPrettyPrint() result:"));
ContainerTraceUtils.WriteLine(model.ToPrettyPrint());
ContainerTraceUtils.WriteLine(string.Format(".ToDotGraph result:"));
ContainerTraceUtils.WriteLine(model.ToDotGraph());
if (EnableDefinitionImmutabilityValidation)
{
PersistDefinitionHashes(new[] { model });
}
var allHooks = new List <EventHooks>();
WithProvisionRunnerContext(runnerContext =>
{
var runner = runnerContext.Runner;
if (BeforeProvisionRunnerExcecution != null)
{
BeforeProvisionRunnerExcecution(runner);
}
var omModelType = GetRunnerType(runner);
var hooks = new List <EventHooks>();
if (!deployOnce)
{
if (this.EnableDefinitionValidation)
{
hooks = GetHooks(model);
foreach (var hook in hooks)
{
hook.Tag = runner.Name;
}
allHooks.AddRange(hooks);
}
}
if (model.Value.GetType() == typeof(FarmDefinition))
{
runner.DeployFarmModel(model);
}
else if (model.Value.GetType() == typeof(WebApplicationDefinition))
{
runner.DeployWebApplicationModel(model);
}
else if (model.Value.GetType() == typeof(SiteDefinition))
{
runner.DeploySiteModel(model);
}
else if (model.Value.GetType() == typeof(WebDefinition))
{
runner.DeployWebModel(model);
}
else if (model.Value.GetType() == typeof(ListDefinition))
{
runner.DeployListModel(model);
}
else
{
throw new SPMeta2NotImplementedException(
string.Format("Runner does not support model of type: [{0}]", model.Value.GetType()));
}
if (!deployOnce)
{
if (this.EnableDefinitionValidation)
{
var hasMissedOrInvalidProps = ResolveModelValidation(model, hooks);
AssertService.IsFalse(hasMissedOrInvalidProps);
}
}
if (AfterProvisionRunnerExcecution != null)
{
AfterProvisionRunnerExcecution(runner);
}
});
if (!deployOnce)
{
if (EnableDefinitionImmutabilityValidation)
{
PleaseMakeSureDefinitionsWereNotChangedByModelHandlers(new[] { model });
}
}
}
}