protected virtual void PushPackageToCIRepository(
SolutionPackageBase solutionPackage,
List <SolutionPackageBase> solutionDependencies,
NuGetSolutionPackageService packagingService)
{
PushPackageToCIRepository(solutionPackage, solutionDependencies, packagingService, UseLocaNuGet);
}
private void Can_Unpack_Internal(
NuGetSolutionPackageService packagingService,
Action <SolutionPackageBase> basePackageAction,
Action <SolutionPackageBase, SolutionPackageBase> action)
{
var solutionPackage = CreateNewSolutionPackage(packagingService);
if (basePackageAction != null)
{
basePackageAction(solutionPackage);
}
var nuGetPackage = packagingService.Pack(solutionPackage);
Assert.IsNotNull(nuGetPackage);
Assert.IsTrue(nuGetPackage.Length > 0);
var filePath = GetTempNuGetFilePath();
packagingService.PackToFile(solutionPackage, filePath);
// unpacking and checking props
using (var streamReader = File.OpenRead(filePath))
{
var unpackedSolutionPackage = packagingService.Unpack(streamReader) as SolutionPackageBase;
action(solutionPackage, unpackedSolutionPackage);
}
}
protected virtual void PushPackageToCIRepository(
SolutionPackageBase solutionPackage,
NuGetSolutionPackageService packagingService
)
{
PushPackageToCIRepository(solutionPackage, null, packagingService);
}
private void Can_Pack_Internal(NuGetSolutionPackageService packagingService)
{
var solutionPackage = CreateNewSolutionPackage(packagingService);
var nuGetPackage = packagingService.Pack(solutionPackage);
// mem stream
Assert.IsNotNull(nuGetPackage);
Assert.IsTrue(nuGetPackage.Length > 0);
var filePath = GetTempNuGetFilePath();
packagingService.PackToFile(solutionPackage, filePath);
Assert.IsTrue(File.Exists(filePath));
}
private void Can_Push_Internal(NuGetSolutionPackageService packagingService)
{
WithCINuGetContext((apiUrl, apiKey, repoUrl) =>
{
var solutionPackage = CreateNewSolutionPackage(packagingService);
UpdatePackageVersion(solutionPackage);
packagingService.Push(solutionPackage, apiUrl, apiKey);
var ciRepo = PackageRepositoryFactory.Default.CreateRepository(repoUrl);
var ciPackage = ciRepo.FindPackageSafe(solutionPackage.Id);
Assert.IsNotNull(ciPackage);
Trace.WriteLine(string.Format("Found package:[{0}]", ciPackage));
});
}
protected virtual void PushPackageToCIRepository(
SolutionPackageBase solutionPackage,
List <SolutionPackageBase> solutionDependencies,
NuGetSolutionPackageService packagingService,
bool useLocal
)
{
IPackageRepository repo = null;
if (solutionDependencies != null)
{
foreach (var soutionDependency in solutionDependencies)
{
if (useLocal)
{
var filePath = Path.Combine(LocalNuGetRepositoryFolderPath,
String.Format("{0}.{1}.nupkg", soutionDependency.Id, soutionDependency.Version));
packagingService.PackToFile(soutionDependency, filePath);
}
else
{
WithCINuGetContext((apiUrl, apiKey, repoUrl) =>
{
packagingService.Push(soutionDependency, apiUrl, apiKey);
});
}
}
}
if (useLocal)
{
var filePath = Path.Combine(LocalNuGetRepositoryFolderPath,
String.Format("{0}.{1}.nupkg", solutionPackage.Id, solutionPackage.Version));
packagingService.PackToFile(solutionPackage, filePath);
}
else
{
WithCINuGetContext((apiUrl, apiKey, repoUrl) =>
{
packagingService.Push(solutionPackage, apiUrl, apiKey);
});
}
}
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);
}
protected virtual SolutionPackageBase CreateNewSolutionPackage(NuGetSolutionPackageService service,
RegressinModelLevel modelLevel)
{
return(CreateNewSolutionPackage(service, null, modelLevel));
}
private void Can_Unpack_Internal(
NuGetSolutionPackageService packagingService,
Action <SolutionPackageBase, SolutionPackageBase> action)
{
Can_Unpack_Internal(packagingService, null, action);
}
private void Can_Unpack_Internal_2(NuGetSolutionPackageService service)
{
Can_Unpack_Internal(service,
(rawPackage, unpackedPackage) =>
{
var solutionPackage = rawPackage as SolutionPackageBase;
var unpackedSolutionPackage = unpackedPackage as SolutionPackageBase;
Assert.IsNotNull(solutionPackage);
Assert.IsNotNull(unpackedSolutionPackage);
Assert.AreEqual(solutionPackage.Name, unpackedSolutionPackage.Name);
Assert.AreEqual(solutionPackage.Title, unpackedSolutionPackage.Title);
Assert.AreEqual(solutionPackage.Description, unpackedSolutionPackage.Description);
Assert.AreEqual(solutionPackage.Id, unpackedSolutionPackage.Id);
Assert.AreEqual(solutionPackage.Authors, unpackedSolutionPackage.Authors);
Assert.AreEqual(solutionPackage.Company, unpackedSolutionPackage.Company);
Assert.AreEqual(solutionPackage.Version, unpackedSolutionPackage.Version);
Assert.AreEqual(solutionPackage.Owners, unpackedSolutionPackage.Owners);
Assert.AreEqual(solutionPackage.ReleaseNotes, unpackedSolutionPackage.ReleaseNotes);
Assert.AreEqual(solutionPackage.Summary, unpackedSolutionPackage.Summary);
Assert.AreEqual(solutionPackage.ProjectUrl, unpackedSolutionPackage.ProjectUrl);
Assert.AreEqual(solutionPackage.IconUrl, unpackedSolutionPackage.IconUrl);
Assert.AreEqual(solutionPackage.LicenseUrl, unpackedSolutionPackage.LicenseUrl);
Assert.AreEqual(solutionPackage.Copyright, unpackedSolutionPackage.Copyright);
Assert.AreEqual(solutionPackage.Tags, unpackedSolutionPackage.Tags);
Assert.AreEqual(solutionPackage.Dependencies.Count, unpackedSolutionPackage.Dependencies.Count);
foreach (var dependency in solutionPackage.Dependencies)
{
var unpackedDependency =
unpackedSolutionPackage.Dependencies.FirstOrDefault(d => d.Id == dependency.Id);
Assert.AreEqual(dependency.Id, unpackedDependency.Id);
Assert.AreEqual(dependency.Version, unpackedDependency.Version);
}
if (service is SPMeta2SolutionPackageService)
{
var m2package = solutionPackage as SolutionPackageBase;
var m2unpackedPackage = unpackedSolutionPackage as SolutionPackageBase;
Assert.IsNotNull(m2package);
Assert.IsNotNull(m2unpackedPackage);
Assert.AreEqual(m2package.GetModels().Count(), m2unpackedPackage.GetModels().Count());
foreach (var modelContainer in m2unpackedPackage.GetModels())
{
Assert.IsNotNull(modelContainer.Model);
Assert.IsNotNull(modelContainer.AdditionalOptions);
// we should be able o unpack it
var modelXml = Encoding.UTF8.GetString(modelContainer.Model);
Assert.IsTrue(!string.IsNullOrEmpty(modelXml));
var m2model = SPMeta2Model.FromXML(modelXml);
Assert.IsNotNull(m2model);
}
}
if (service is SharePointPnPSolutionPackageService)
{
var pnpPackage = solutionPackage as SolutionPackageBase;
var pnpUnpackedPackage = unpackedSolutionPackage as SolutionPackageBase;
Assert.IsNotNull(pnpPackage);
Assert.IsNotNull(pnpPackage);
Assert.IsNotNull(pnpUnpackedPackage);
Assert.AreEqual(pnpPackage.GetModels().Count(), pnpUnpackedPackage.GetModels().Count());
foreach (var modelContainer in pnpUnpackedPackage.GetModels())
{
Assert.IsNotNull(modelContainer.Model);
Assert.IsNotNull(modelContainer.AdditionalOptions);
}
}
});
}
private void Can_Unpack_SolutionPackage_WithOrderedModel_Internal(NuGetSolutionPackageService s)
{
Can_Unpack_Internal(s,
prePackagedSolution =>
{
// clean models
var models = prePackagedSolution.GetModels().ToArray();
foreach (var model in models)
{
prePackagedSolution.RemoveModel(model);
}
var firstModel = new ModelContainerBase();
firstModel.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Order.Id,
Value = "100"
});
var secondModel = new ModelContainerBase();
secondModel.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Order.Id,
Value = "200"
});
var thirdModel = new ModelContainerBase();
thirdModel.AdditionalOptions.Add(new OptionValue
{
Name = DefaultOptions.Model.Order.Id,
Value = "300"
});
prePackagedSolution.AddModel(secondModel);
prePackagedSolution.AddModel(firstModel);
prePackagedSolution.AddModel(thirdModel);
},
(rawPackage, unpackedPackage) =>
{
var solutionPackage = rawPackage as SolutionPackageBase;
var unpackedSolutionPackage = unpackedPackage as SolutionPackageBase;
Assert.IsNotNull(solutionPackage);
// these should be ordred by Order flag
var models = unpackedPackage.GetModels();
var orderValues = models.Select(m =>
{
var orderValue = m.AdditionalOptions
.FirstOrDefault(o => o.Name == DefaultOptions.Model.Order.Id);
return(int.Parse(orderValue.Value));
}).ToArray();
for (var index = 0; index < orderValues.Count() - 1; index++)
{
var firstOrder = orderValues[index];
var secondOrder = orderValues[index + 1];
Assert.IsTrue(firstOrder <= secondOrder);
}
// must be array of int-s
});
}
