protected bool ShouldPass(string message, object context, string token, string expectedUrl)
{
var result = true;
RegressionUtils.WriteLine(message);
var valueResult = Service.ReplaceTokens(new TokenReplacementContext
{
Value = token,
Context = context
});
result = expectedUrl.ToUpper() == valueResult.Value.ToUpper();
RegressionUtils.WriteLine(string.Format("[{0}] - [{1}] - token:[{2}] expected value:[{3}] replaced value:[{4}]",
new object[]
{
message,
result,
token,
expectedUrl,
valueResult.Value
}));
return(result);
}
public void FieldDefinitions_ShouldHave_Correct_ValidationMessageAndFormula_Property()
{
var fieldDefinitionTypes = new List <Type>();
fieldDefinitionTypes.AddRange(ReflectionUtils.GetTypesFromAssembly <FieldDefinition>(typeof(FieldDefinition).Assembly));
fieldDefinitionTypes.AddRange(ReflectionUtils.GetTypesFromAssembly <FieldDefinition>(typeof(TaxonomyFieldDefinition).Assembly));
foreach (var fieldDefintion in fieldDefinitionTypes)
{
RegressionUtils.WriteLine(string.Format("Checking Indexed propr for Indexed def:[{0}]", fieldDefintion.GetType().Name));
var siteModel = SPMeta2Model.NewSiteModel(m => { });
var siteField = ModelGeneratorService.GetRandomDefinition(fieldDefintion) as FieldDefinition;
siteModel.AddField(siteField);
// dep lookiup
if (siteField is DependentLookupFieldDefinition)
{
var primaryLookupField = new LookupFieldDefinitionGenerator().GenerateRandomDefinition() as FieldDefinition;
(siteField as DependentLookupFieldDefinition).PrimaryLookupFieldId = primaryLookupField.Id;
siteModel.AddField(primaryLookupField);
}
siteField.ValidationMessage = string.Format("validatin_msg_{0}", RegressionService.RndService.String());
siteField.ValidationFormula = string.Format("=[ID] * {0}", RegressionService.RndService.Int(100));
TestModel(siteModel);
}
}
public void RandomDefinitionTest_ShouldHave_Tests_ForAllDefinitions()
{
var methods = typeof(RandomDefinitionTest).GetMethods();
var spMetaAssembly = typeof(FieldDefinition).Assembly;
var spMetaStandardAssembly = typeof(TaxonomyFieldDefinition).Assembly;
var allDefinitions = ReflectionUtils.GetTypesFromAssemblies <DefinitionBase>(new[]
{
spMetaAssembly,
spMetaStandardAssembly
});
foreach (var def in allDefinitions)
{
RegressionUtils.WriteLine(def.Name);
}
var isValid = true;
foreach (var definition in allDefinitions)
{
var hasTestMethod = HasTestMethod("CanDeployRandom_", definition, methods);
if (!hasTestMethod)
{
RegressionUtils.WriteLine(string.Format("[ERR]:{0}", definition.Name));
isValid = false;
}
}
Assert.IsTrue(isValid);
}
public void All_Services_Should_Have_Metadata()
{
var isValid = true;
var validationServiceTypes =
ReflectionUtils.GetTypesFromAssembly <PreDeploymentValidationServiceBase>(
typeof(FieldDefinition).Assembly);
foreach (var validationServiceType in validationServiceTypes)
{
var service = Activator.CreateInstance(validationServiceType) as PreDeploymentValidationServiceBase;
RegressionUtils.WriteLine(service.Title);
RegressionUtils.WriteLine(service.Description);
Assert.IsNotNull(service);
if (string.IsNullOrEmpty(service.Title))
{
isValid = false;
break;
}
if (string.IsNullOrEmpty(service.Description))
{
isValid = false;
break;
}
}
Assert.IsTrue(isValid);
}
private bool HasTestMethod(string methodPrefix, Type definition, MethodInfo[] methods)
{
var methodName = string.Format("{0}{1}", methodPrefix, definition.Name);
RegressionUtils.WriteLine(string.Format("Asserting method:[{0}]", methodName));
var targetMethod = methods.FirstOrDefault(m => m.Name == methodName);
return(targetMethod != null);
}
public void Incremental_Update_NonSingleton_ModelNodes_PlusRandomModelNodes()
{
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddRandomField();
site.AddRandomField();
site.AddRandomField();
});
var prevModel = model;
var currentModel = model;
var firstProvisionService = new FakeIncrementalModelTreeTraverseService();
firstProvisionService.PreviousModelHash = new ModelHash();
firstProvisionService.Traverse(null, currentModel);
RegressionUtils.WriteLine("Original model:");
RegressionUtils.WriteLine(ModelPrintService.PrintModel(currentModel));
var trace = ServiceContainer.Instance.GetService <TraceServiceBase>();
ModelNode newField1 = null;
ModelNode newField2 = null;
// newnodes to add
model.AddRandomField(f => { newField1 = f; });
model.AddRandomField(f => { newField2 = f; });
// check one more with second provision
var secondProvisionService = new FakeIncrementalModelTreeTraverseService();
secondProvisionService.PreviousModelHash = firstProvisionService.CurrentModelHash;
secondProvisionService.Traverse(null, currentModel);
RegressionUtils.WriteLine(string.Empty);
RegressionUtils.WriteLine("Provisioned model:");
RegressionUtils.WriteLine(ModelPrintService.PrintModel(currentModel));
// asserts
// should be 2 of the nodes to update on the same model
Assert.AreEqual(2, secondProvisionService.ModelNodesToUpdate.Count);
Assert.AreEqual(GetTotalModelNodeCount(model),
secondProvisionService.ModelNodesToSkip.Count + secondProvisionService.ModelNodesToUpdate.Count);
// new field must be marked as to be updated
Assert.IsTrue(newField1.Options.RequireSelfProcessing);
Assert.IsTrue(newField2.Options.RequireSelfProcessing);
RegressionUtils.WriteLine("Current model hash:");
RegressionUtils.WriteLine(Environment.NewLine + secondProvisionService.CurrentModelHash);
}
public void Create_BuildBaseline()
{
var assemblies = new List <Assembly>();
// SPMeta2
// SPMeta2.Standard
assemblies.Add(typeof(FieldDefinition).Assembly);
assemblies.Add(typeof(TaxonomyFieldDefinition).Assembly);
// SPMeta2.CSOM
// SPMeta2.CSOM.Standard
assemblies.Add(typeof(SPMeta2.CSOM.ModelHandlers.FieldModelHandler).Assembly);
assemblies.Add(typeof(SPMeta2.CSOM.Standard.ModelHandlers.Fields.TaxonomyFieldModelHandler).Assembly);
// SPMeta2.SSOM
// SPMeta2.SSOM.Standard
assemblies.Add(typeof(SPMeta2.SSOM.ModelHandlers.FieldModelHandler).Assembly);
assemblies.Add(typeof(SPMeta2.SSOM.Standard.ModelHandlers.Fields.TaxonomyFieldModelHandler).Assembly);
var result = new List <BuildBaseline>();
foreach (var assembly in assemblies)
{
result.Add(BuildBaselineFromAssembly(assembly));
}
var fileName = "m2.buildbaseline.xml";
var xmlService = new DefaultXMLSerializationService();
xmlService.RegisterKnownType(typeof(BuildBaseline));
var content = xmlService.Serialize(result);
RegressionUtils.WriteLine(content);
var paths = new[]
{
System.IO.Path.GetFullPath(fileName),
System.IO.Path.GetFullPath("../../../SPMeta2.Build/" + fileName)
};
foreach (var path in paths)
{
var dirPath = Path.GetDirectoryName(path);
Directory.CreateDirectory(dirPath);
System.IO.File.WriteAllText(path, content);
}
}
public void SelfDiagnostic_AllFields_Should_Have_Value_Tests()
{
var isValid = true;
var methods = typeof(ListItemScenariousTest).GetMethods();
var targetTypes = new List <Type>();
var assemblies = new[]
{
typeof(FieldDefinition).Assembly,
typeof(TaxonomyFieldDefinition).Assembly
};
targetTypes.AddRange(ReflectionUtils.GetTypesFromAssemblies <FieldDefinition>(assemblies));
RegressionUtils.WriteLine(string.Format("Found [{0}] fied types.", targetTypes.Count));
foreach (var fieldType in targetTypes.OrderBy(m => m.Name))
{
var fullDefName = fieldType.Name;
var shortDefName = fieldType.Name.Replace("Definition", string.Empty);
var testName1 = string.Format("CanDeploy_{0}_Value", shortDefName);
var testName2 = string.Format("CanDeploy_{0}_Values", shortDefName);
var testExists1 = methods.Any(m => m.Name == testName1);
var testExists2 = methods.Any(m => m.Name == testName2);
if (!testExists1)
{
isValid = false;
}
if (!testExists2)
{
isValid = false;
}
RegressionUtils.WriteLine(string.Format("[{0}] def: {1} one value test method: {2}",
testExists1, fullDefName, testName1));
RegressionUtils.WriteLine(string.Format("[{0}] def: {1} multiple values test method: {2}",
testExists2, fullDefName, testName2));
RegressionUtils.WriteLine(string.Empty);
}
Assert.IsTrue(isValid);
}
private void AddAndCheckRandomAppWithVersion(WebModelNode web, Version version)
{
var def = new AppDefinition();
def.ProductId = DefaultContainers.Apps.ProductId;
def.Version = version.ToString();
def.Content = File.ReadAllBytes(string.Format(DefaultContainers.Apps.GenericVersionableAppFilePath, version));
web.AddApp(def, app =>
{
app.OnProvisioned <object, AppDefinition>(context =>
{
RegressionUtils.WriteLine(context.ObjectDefinition.ToString());
RegressionUtils.WriteLine(context.Object.ToString());
var expectedAppVersion = new Version(context.ObjectDefinition.Version);
var obj = context.Object;
var objType = context.Object.GetType();
if (objType.ToString().Contains("Microsoft.SharePoint.Client.AppInstance"))
{
// with CSOM there is no API to know current app installed version
// checking if app is Installed after every single update
var appStatus = obj.GetPropertyValue("Status").ToString();
Assert.IsTrue(appStatus == "Installed",
string.Format("App should be installed after every update"));
}
else if (objType.ToString().Contains("Microsoft.SharePoint.Administration.SPAppInstance"))
{
var appObjet = obj.GetPropertyValue("App");
var versionString = appObjet.GetPropertyValue("VersionString") as string;
var spAppVersion = new Version(versionString);
// either equal (update) or SharePoint version greater than local (second update)
// the test is run several times, so only once we have =, and then we have <
Assert.IsTrue(expectedAppVersion <= spAppVersion,
string.Format("Expecting app version:[{0}] SharePoint app version:[{1}]", expectedAppVersion, spAppVersion));
}
else
{
throw new SPMeta2NotImplementedException(string.Format("ID property extraction is not implemented for type: [{0}]", objType));
}
});
});
}
public void FieldDefinitions_ShouldHave_Correct_Indexed_Property()
{
var fieldDefinitionTypes = new List <Type>();
fieldDefinitionTypes.AddRange(ReflectionUtils.GetTypesFromAssembly <FieldDefinition>(typeof(FieldDefinition).Assembly));
fieldDefinitionTypes.AddRange(ReflectionUtils.GetTypesFromAssembly <FieldDefinition>(typeof(TaxonomyFieldDefinition).Assembly));
foreach (var fieldDefintion in fieldDefinitionTypes)
{
RegressionUtils.WriteLine(string.Format("Checking Indexed prop for Indexed def:[{0}]", fieldDefintion.GetType().Name));
var indexedSiteModel = SPMeta2Model.NewSiteModel(m => { });
var indexedSiteField = ModelGeneratorService.GetRandomDefinition(fieldDefintion) as FieldDefinition;
indexedSiteModel.AddField(indexedSiteField);
indexedSiteField.Indexed = true;
// dep lookiup
if (indexedSiteField is DependentLookupFieldDefinition)
{
var primaryLookupField = new LookupFieldDefinitionGenerator().GenerateRandomDefinition() as FieldDefinition;
(indexedSiteField as DependentLookupFieldDefinition).PrimaryLookupFieldId = primaryLookupField.Id;
indexedSiteModel.AddField(primaryLookupField);
}
TestModel(indexedSiteModel);
RegressionUtils.WriteLine(string.Format("Checking Indexed prop for non-Indexed def:[{0}]", fieldDefintion.GetType().Name));
var nonIdexedSiteModel = SPMeta2Model.NewSiteModel(m => { });
var nonIndexedSiteField = ModelGeneratorService.GetRandomDefinition(fieldDefintion) as FieldDefinition;
nonIdexedSiteModel.AddField(nonIndexedSiteField);
nonIndexedSiteField.Indexed = false;
// dep lookiup
if (indexedSiteField is DependentLookupFieldDefinition)
{
var primaryLookupField = new LookupFieldDefinitionGenerator().GenerateRandomDefinition() as FieldDefinition;
(nonIndexedSiteField as DependentLookupFieldDefinition).PrimaryLookupFieldId = primaryLookupField.Id;
nonIdexedSiteModel.AddField(primaryLookupField);
}
TestModel(nonIdexedSiteModel);
}
}
public SPMeta2RegresionScenarioTestBase()
{
RegressionService.ProvisionGenerationCount = 2;
RegressionService.ShowOnlyFalseResults = true;
var isIncrementalProvisionEnabled = IsIncrementalProvisionMode;
if (isIncrementalProvisionEnabled)
{
RegressionService.BeforeProvisionRunnerExcecution += (runner) =>
{
var config = new IncrementalProvisionConfig();
runner.ProvisionService.SetIncrementalProvisionMode(config);
runner.OnBeforeDeployModel += (provisionService, model) =>
{
if (PreviousModelHash != null)
{
provisionService.SetIncrementalProvisionModelHash(PreviousModelHash);
}
};
runner.OnAfterDeployModel += (provisionService, model) =>
{
var tracer = new DefaultIncrementalModelPrettyPrintService();
RegressionUtils.WriteLine(string.Format("Deployed model with incremental updates:"));
RegressionUtils.WriteLine(Environment.NewLine + tracer.PrintModel(model));
PreviousModelHash = provisionService.GetIncrementalProvisionModelHash();
};
};
RegressionService.AfterProvisionRunnerExcecution += (runner) =>
{
};
RegressionService.EnableEventValidation = false;
RegressionService.EnableDefinitionValidation = false;
RegressionService.EnablePropertyValidation = false;
EnablePropertyUpdateValidation = true;
}
}
public void SelfDiagnostic_AllFields_Should_Have_DefaultValue_Tests()
{
// check if FieldScenariosTest class has all testsfor field default values
// should not inherit SPMeta2RegresionScenarioTestBase as it will force to use (init) provisioners under CI
// that's why it is separated
var isValid = true;
var methods = typeof(FieldScenariosTest).GetMethods();
var targetTypes = new List <Type>();
var assemblies = new[]
{
typeof(FieldDefinition).Assembly,
typeof(TaxonomyFieldDefinition).Assembly
};
targetTypes.AddRange(ReflectionUtils.GetTypesFromAssemblies <FieldDefinition>(assemblies));
RegressionUtils.WriteLine(string.Format("Found [{0}] fied types.", targetTypes.Count));
foreach (var fieldType in targetTypes.OrderBy(m => m.Name))
{
var fullDefName = fieldType.Name;
var shortDefName = fieldType.Name.Replace("Definition", string.Empty);
var testName = string.Format("CanDeploy_{0}_DefaultValue", shortDefName);
var testExists = methods.Any(m => m.Name == testName);
if (!testExists)
{
isValid = false;
}
RegressionUtils.WriteLine(string.Format("[{0}] def: {1} test method: {2}",
testExists, fullDefName, testName));
}
Assert.IsTrue(isValid);
}
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>();
RegressionUtils.WriteLine("Checking hashes for definitions...");
foreach (var defType in allDefinitions)
{
var defInstance = ModelGeneratorService.GetRandomDefinition(defType);
RegressionUtils.WriteLine(string.Format("Definition:[{0}] - [{1}]", defType, defInstance));
IndentableTrace.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);
});
}
}
public void Internal_Incremental_Update_NonSingleton_ModelNodes_SameModels(ModelNode model)
{
var prevModel = model;
var currentModel = model;
var firstProvisionService = new FakeIncrementalModelTreeTraverseService();
firstProvisionService.PreviousModelHash = new ModelHash();
firstProvisionService.Traverse(null, currentModel);
var trace = ServiceContainer.Instance.GetService <TraceServiceBase>();
// check one more with second provision
var secondProvisionService = new FakeIncrementalModelTreeTraverseService();
RegressionUtils.WriteLine("Original model:");
RegressionUtils.WriteLine(ModelPrintService.PrintModel(currentModel));
secondProvisionService.PreviousModelHash = firstProvisionService.CurrentModelHash;
secondProvisionService.Traverse(null, currentModel);
RegressionUtils.WriteLine(string.Empty);
RegressionUtils.WriteLine("Provisioned model:");
RegressionUtils.WriteLine(ModelPrintService.PrintModel(currentModel));
// asserts
// should be NONE of the nodes to update on the same model
Assert.AreEqual(0, secondProvisionService.ModelNodesToUpdate.Count);
Assert.AreEqual(GetTotalModelNodeCount(model), secondProvisionService.ModelNodesToSkip.Count);
RegressionUtils.WriteLine("Current model hash:");
RegressionUtils.WriteLine(Environment.NewLine + secondProvisionService.CurrentModelHash);
foreach (var modelNodeHash in secondProvisionService.CurrentModelHash.ModelNodes)
{
RegressionUtils.WriteLine(string.Format("- {0}", modelNodeHash.ToString()));
}
}
private BuildBaseline BuildBaselineFromAssembly(Assembly assembly)
{
var result = new BuildBaseline();
result.AssemblyFullName = assembly.FullName;
result.AssemblyFileName = assembly.ManifestModule.Name;
result.DefinitionTypeFullNames = ReflectionUtils.GetTypesFromAssembly <DefinitionBase>(assembly)
.Where(t => !t.IsAbstract)
.Select(t => t.AssemblyQualifiedName)
.ToList();
result.ModelHandlerTypeFullNames = ReflectionUtils.GetTypesFromAssembly <ModelHandlerBase>(assembly)
.Where(t => !t.IsAbstract)
.Select(t => t.AssemblyQualifiedName)
.ToList();
RegressionUtils.WriteLine(string.Format("AssemblyFullName:[{0}]", result.AssemblyFullName));
RegressionUtils.WriteLine(string.Format("DefinitionTypeFullNames:[{0}]", result.DefinitionTypeFullNames.Count));
RegressionUtils.WriteLine(string.Format("ModelHandlerTypeFullNames:[{0}]", result.ModelHandlerTypeFullNames.Count));
RegressionUtils.WriteLine("Definitions:");
foreach (var name in result.DefinitionTypeFullNames)
{
RegressionUtils.WriteLine(" " + name);
}
RegressionUtils.WriteLine("Model handlers:");
foreach (var name in result.ModelHandlerTypeFullNames)
{
RegressionUtils.WriteLine(" " + name);
}
RegressionUtils.WriteLine(string.Empty);
RegressionUtils.WriteLine(string.Empty);
return(result);
}
public void ShouldFail_On_Invalid_Field_Twice()
{
var isValid = false;
var innerExceptionCount = 0;
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddRandomField(field =>
{
(field.Value as FieldDefinition).InternalName = string.Empty;
(field.Value as FieldDefinition).Id = default(Guid);
});
});
try
{
Service.DeployModel(null, model);
}
catch (Exception e)
{
isValid = e is SPMeta2ModelDeploymentException &&
e.InnerException is SPMeta2AggregateException &&
(e.InnerException as AggregateException)
.InnerExceptions.All(ie => ie is SPMeta2ModelValidationException);
innerExceptionCount = (e.InnerException as AggregateException)
.InnerExceptions.Count;
foreach (var ex in (e.InnerException as AggregateException).InnerExceptions
.OfType <SPMeta2ModelValidationException>())
{
RegressionUtils.WriteLine("Ex: " + ex.Message + " N:" + ex.Definition);
}
}
Assert.IsTrue(isValid);
Assert.AreEqual(2, innerExceptionCount);
}
protected bool HasAllTestsForTokens(string methodPrefix, IEnumerable <TokenInfo> tokens,
IEnumerable <MethodInfo> methods)
{
var isValid = true;
foreach (var token in tokens)
{
var tokenName = token.Name.Replace("~", string.Empty);
var methodName = string.Format("{1}TokenReplacementService_Can_Replace_{0}_Token", tokenName,
methodPrefix);
var method = methods.FirstOrDefault(m => m.Name.ToUpper() == methodName.ToUpper());
RegressionUtils.WriteLine(methodName + " : " + (method != null));
if (method == null)
{
isValid = false;
}
}
return(isValid);
}
public void Incremental_Update_AllDefinitions_As_RandomModels_Internal(
Action <DefaultIncrementalModelTreeTraverseService> configureService,
bool silentMode,
int iterationCount)
{
var m2logService = ServiceContainer.Instance.GetService <TraceServiceBase>();
var spMetaAssembly = typeof(FieldDefinition).Assembly;
var spMetaStandardAssembly = typeof(TaxonomyFieldDefinition).Assembly;
var allDefinitionTypes = ReflectionUtils.GetTypesFromAssemblies <DefinitionBase>(new[]
{
spMetaAssembly,
spMetaStandardAssembly
}).OrderBy(t => t.Name);
var allDefinitionTypesCount = allDefinitionTypes.Count();
var currentDefinitionTypeIndex = 0;
for (int it = 0; it < iterationCount; it++)
{
foreach (var definitionType in allDefinitionTypes)
{
currentDefinitionTypeIndex++;
if (!silentMode)
{
RegressionUtils.WriteLine(string.Format("[{0}/{1}] Testing definition:[{2}]",
new object[] {
currentDefinitionTypeIndex,
allDefinitionTypesCount,
definitionType.FullName
}));
}
var model = GetVeryRandomModel(definitionType, SPObjectModelType.CSOM);
var prevModel = model;
var currentModel = model;
var firstProvisionService = new FakeIncrementalModelTreeTraverseService();
if (configureService != null)
{
configureService(firstProvisionService);
}
firstProvisionService.PreviousModelHash = new ModelHash();
firstProvisionService.Traverse(null, currentModel);
var trace = ServiceContainer.Instance.GetService <TraceServiceBase>();
// check one more with second provision
var secondProvisionService = new FakeIncrementalModelTreeTraverseService();
if (configureService != null)
{
configureService(secondProvisionService);
}
if (!silentMode)
{
RegressionUtils.WriteLine("Original model:");
RegressionUtils.WriteLine(ModelPrintService.PrintModel(currentModel));
}
secondProvisionService.PreviousModelHash = firstProvisionService.CurrentModelHash;
secondProvisionService.Traverse(null, currentModel);
// trace size of the model hash + amount if the aritfacts
var modelNodesCount = 0;
model.WithNodesOfType <DefinitionBase>(n => { modelNodesCount++; });
var serializer = ServiceContainer.Instance.GetService <DefaultXMLSerializationService>();
serializer.RegisterKnownTypes(new[]
{
typeof(ModelHash),
typeof(ModelNodeHash)
});
var data = Encoding.UTF8.GetBytes(serializer.Serialize(firstProvisionService.CurrentModelHash));
var persistanceFileService = new DefaultFileSystemPersistenceStorage();
persistanceFileService.SaveObject(
string.Format("incremental_state_m2.regression-artifact-{1}-{0}", definitionType.Name, modelNodesCount),
data);
if (!silentMode)
{
RegressionUtils.WriteLine(string.Empty);
RegressionUtils.WriteLine("Provisioned model:");
RegressionUtils.WriteLine(ModelPrintService.PrintModel(currentModel));
}
// asserts
var expectedProvisionNodesCount = 0;
expectedProvisionNodesCount += secondProvisionService.GetTotalSingleIdentityNodeCount();
expectedProvisionNodesCount += secondProvisionService.GetTotalIgnoredNodeCount();
Assert.AreEqual(expectedProvisionNodesCount, secondProvisionService.ModelNodesToUpdate.Count);
Assert.AreEqual(GetTotalModelNodeCount(model) - expectedProvisionNodesCount, secondProvisionService.ModelNodesToSkip.Count);
}
}
}
public void CreateDefinitionCoverageReport()
{
var result = new StringBuilder();
foreach (var definitionType in AllDefinitionTypes.OrderBy(d => d.Name))
{
var allProps = definitionType.GetProperties().OrderBy(p => p.Name);
var validatedProps = allProps.Where(p => p.GetCustomAttributes(typeof(ExpectValidationAttribute)).Any());
var updatableProps = allProps.Where(p => p.GetCustomAttributes(true).Any(a => (a as ExpectUpdate) != null));
RegressionUtils.WriteLine(definitionType.Name);
result.Append("<table class='table table-bordered table-striped'>");
result.Append("<thead>");
result.Append("<tr>");
result.AppendFormat("<th style='width: 150px;'>{0}</th>", definitionType.Name);
result.Append("<th>Property</th>");
result.Append("<th>Validated</th>");
result.Append("<th>Updated</th>");
result.Append("</tr>");
result.Append("</thead>");
result.Append("<tr>");
bool isFirst = true;
foreach (var prop in allProps)
{
if (!isFirst)
{
result.Append("<tr>");
}
var isValidated = validatedProps.Any(p => p.Name == prop.Name);
var isUpdated = updatableProps.Any(p => p.Name == prop.Name);
result.AppendFormat("<td></td>");
result.AppendFormat("<td>{0}</td>", prop.Name);
result.AppendFormat("<td>{0}</td>", isValidated);
result.AppendFormat("<td>{0}</td>", isUpdated);
RegressionUtils.WriteLine(string.Format("{0}{1} - validated:{2} updated:{3}", '\t', prop.Name, isValidated, isUpdated));
isFirst = false;
if (!isFirst)
{
result.Append("</tr>");
}
}
result.Append("</table>");
result.Append("<br/>");
result.Append("<br/>");
}
var reportHtml = result.ToString();
RegressionUtils.WriteLine(reportHtml);
}
static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
var m2runner = Environment.GetEnvironmentVariable("SPMeta2_RunnerLibraries", EnvironmentVariableTarget.Machine);
var baseDir = AppDomain.CurrentDomain.BaseDirectory;
RegressionUtils.WriteLine(string.Format("Resolving custom assembly binding for m2 runner:[{0}]", m2runner));
RegressionUtils.WriteLine(string.Format(" RequestingAssembly:[{0}]", args.RequestingAssembly));
RegressionUtils.WriteLine(string.Format(" What requested:[{0}]", args.Name));
if (args.Name.Contains(".resources,"))
{
RegressionUtils.WriteLine("resources assembly. returning null");
return(null);
}
var assemblyName = args.Name.Split(',')[0] + ".dll";
var assemblyVersion = args.Name.Split(',')[1].Split('=')[1];
var assemblyDirs = new List <string>();
if (assemblyName.Contains("Microsoft.SharePoint.Client."))
{
switch (assemblyVersion)
{
case "16.1.0.0":
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\csom-v365"));
break;
case "15.0.0.0":
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\csom-v2013"));
break;
}
}
if (m2runner == "SPMeta2.Containers.O365v16.dll")
{
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-365"));
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-regression-365"));
}
if (m2runner == "SPMeta2.Containers.O365.dll")
{
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-2013"));
}
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-regression-2013"));
if (m2runner == "SPMeta2.Containers.CSOM.dll")
{
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-2013"));
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-regression-2013"));
}
foreach (var dir in assemblyDirs)
{
var filePath = Path.Combine(dir, assemblyName);
if (File.Exists(filePath))
{
RegressionUtils.WriteLine(string.Format("Loading assemblly:[{0}]", filePath));
return(Assembly.LoadFile(filePath));
}
}
throw new Exception(string.Format("Cannot load custom assembly:[{0}] for assembly:[{1}]",
args.Name,
args.RequestingAssembly
));
}
static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
var m2runner = RegressionTestService.CurrentProvisionRunnerAsssmbly;
var baseDir = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory);
RegressionUtils.WriteLine(string.Format("Resolving custom assembly binding for m2 runner:[{0}]", m2runner));
RegressionUtils.WriteLine(string.Format(" RequestingAssembly:[{0}]", args.RequestingAssembly));
RegressionUtils.WriteLine(string.Format(" What requested:[{0}]", args.Name));
if (args.Name.Contains(".resources,"))
{
RegressionUtils.WriteLine("resources assembly. returning null");
return(null);
}
var assemblyName = args.Name.Split(',')[0] + ".dll";
var assemblyVersion = args.Name.Split(',')[1].Split('=')[1];
var assemblyDirs = new List <string>();
if (assemblyName.Contains("Microsoft.SharePoint.Client."))
{
switch (assemblyVersion)
{
case "16.1.0.0":
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\csom-v365"));
break;
case "15.0.0.0":
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\csom-v2013"));
break;
}
}
if (m2runner == "SPMeta2.Containers.O365v16.dll")
{
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-365"));
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-regression-365"));
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-regression-365"));
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-regression-365"));
// VS sometimes does not coipy these accorss
// referencing straight to the solution
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.CSOM.Standard\bin\Debug45-365\")));
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.CSOM\bin\Debug45-365\")));
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.Regression.CSOM\bin\Debug45-365\")));
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.Regression.CSOM.Standard\bin\Debug45-365\")));
}
if (m2runner == "SPMeta2.Containers.O365.dll")
{
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-2013"));
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-regression-2013"));
// VS sometimes does not coipy these accorss
// referencing straight to the solution
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.CSOM.Standard\bin\Debug45\")));
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.CSOM\bin\Debug45\")));
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.Regression.CSOM\bin\Debug45\")));
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.Regression.CSOM.Standard\bin\Debug45\")));
}
if (m2runner == "SPMeta2.Containers.CSOM.dll")
{
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-2013"));
assemblyDirs.Add(Path.Combine(baseDir, @"_Dependencies\spmeta2-csom-regression-2013"));
// VS sometimes does not coipy these accorss
// referencing straight to the solution
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.CSOM.Standard\bin\Debug45\")));
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.CSOM\bin\Debug45\")));
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.Regression.CSOM\bin\Debug45\")));
assemblyDirs.Add(GetFullPath(Path.Combine(baseDir, @"..\..\..\SPMeta2.Regression.CSOM.Standard\bin\Debug45\")));
}
foreach (var dir in assemblyDirs)
{
var filePath = Path.Combine(dir, assemblyName);
if (File.Exists(filePath))
{
RegressionUtils.WriteLine(string.Format("Loading assemblly:[{0}]", filePath));
return(Assembly.LoadFile(filePath));
}
}
throw new Exception(string.Format("Cannot load custom assembly:[{0}] for assembly:[{1}]. Rebuild solution via powershell .\build in 'Build' project and run regression again",
args.Name,
args.RequestingAssembly
));
}