private static string PublishPackage(VettingContext context) { var packagePath = context.ProjectPackageInfo.path; if (!context.ProjectPackageInfo.PackageType.NeedsLocalPublishing()) { return(packagePath); } Profiler.BeginSample("PublishPackage"); var tempPath = System.IO.Path.GetTempPath(); string packageName = context.ProjectPackageInfo.Id.Replace("@", "-") + ".tgz"; //Use upm-template-tools package-ci var packagesGenerated = PackageCIUtils.Pack(packagePath, tempPath); var publishPackagePath = Path.Combine(tempPath, "publish-" + context.ProjectPackageInfo.Id); var deleteOutput = true; foreach (var packageTgzName in packagesGenerated) { Utilities.ExtractPackage(packageTgzName, tempPath, publishPackagePath, context.ProjectPackageInfo.name, deleteOutput); deleteOutput = false; } Profiler.EndSample(); return(publishPackagePath); }
internal static bool RunAssetStoreValidationSuite(string packageName, string packageVersion, string packagePath, string previousPackagePath = null) { if (string.IsNullOrEmpty(packageName)) { throw new ArgumentNullException(packageName); } if (string.IsNullOrEmpty(packageVersion)) { throw new ArgumentNullException(packageVersion); } if (string.IsNullOrEmpty(packagePath)) { throw new ArgumentNullException(packageName); } var report = new ValidationSuiteReport(packageName + "@" + packageVersion, packageName, packageVersion, packagePath); try { var context = VettingContext.CreateAssetStoreContext(packageName, packageVersion, packagePath, previousPackagePath); var testSuite = new ValidationSuite(SingleTestCompletedDelegate, AllTestsCompletedDelegate, context, report); testSuite.RunSync(); return(testSuite.testSuiteState == TestState.Succeeded); } catch (Exception e) { report.OutputErrorReport(string.Format("\r\nTest Setup Error: \"{0}\"\r\n", e)); return(false); } }
internal void Initialize(VettingContext context) { var packageInfo = context.ProjectPackageInfo; Write( string.Format("Validation Suite Results for package \"{0}\"\n", packageInfo.name) + string.Format(" - Path: {0}\n", packageInfo.path) + string.Format(" - Version: {0}\n", packageInfo.version) + string.Format(" - Type: {0}\n", context.PackageType) + string.Format(" - Context: {0}\n", context.ValidationType) + string.Format(" - Lifecycle: {0}\n", packageInfo.lifecycle) + string.Format(" - Test Time: {0}\n", DateTime.Now) + string.Format(" - Tested with {0} version: {1}\n", context.VSuiteInfo.name, context.VSuiteInfo.version) ); if (context.ProjectPackageInfo.dependencies.Any()) { Append("\nPACKAGE DEPENDENCIES:\n"); Append("--------------------\n"); foreach (var dependencies in context.ProjectPackageInfo.dependencies) { Append(string.Format(" - {0}@{1}\n", dependencies.Key, dependencies.Value)); } } Append(exceptionSectionPlaceholder); Append("\nVALIDATION RESULTS:\n"); Append("------------------\n"); }
public static bool ValidatePackage(string packageName, string packageVersion, string[] packageIdsForPromotion) { if (string.IsNullOrEmpty(packageName)) { throw new ArgumentNullException(packageName); } if (string.IsNullOrEmpty(packageVersion)) { throw new ArgumentNullException(packageVersion); } var packageId = Utilities.CreatePackageId(packageName, packageVersion); var packagePath = FindPackagePath(packageName); var report = new ValidationSuiteReport(packageId, packageName, packageVersion, packagePath); if (string.IsNullOrEmpty(packagePath)) { report.OutputErrorReport(string.Format("Unable to find package \"{0}\" on disk.", packageName)); return(false); } // publish locally for embedded and local packages var context = VettingContext.CreatePackmanContext(packageId, ValidationType.Promotion); context.packageIdsForPromotion = packageIdsForPromotion; return(ValidatePackage(context, out report)); }
internal ValidationSuite(SingleTestCompletedDelegate singleTestCompletionDelegate, AllTestsCompletedDelegate allTestsCompletedDelegate, VettingContext context, ValidationSuiteReport report) { this.singleTestCompletionDelegate += singleTestCompletionDelegate; this.allTestsCompletedDelegate += allTestsCompletedDelegate; this.context = context; this.report = report; testSuiteState = TestState.NotRun; BuildTestSuite(); }
void PrintExceptions(VettingContext context) { string str = ""; if (context.ValidationExceptionManager.HasExceptions) { str = "\n\n***************************************\n"; str += "PACKAGE CONTAINS VALIDATION EXCEPTIONS!\n"; var issuesList = context.ValidationExceptionManager.CheckValidationExceptions(context.PublishPackageInfo.version); foreach (var issue in issuesList) { str += "\n- Issue: " + issue + "\n"; } str += "***************************************\n"; } Replace(exceptionSectionPlaceholder, str); }
/// <summary> /// Contains project information that is relevant for Template testing. During testing, the used manifest path /// and package manager settings path will be defined by the existence of those files within the package's /// ProjectData~ folder /// </summary> /// <param name="context"></param> public ProjectInfo(VettingContext context) { string packedManifestPath = Path.Combine(context.PublishPackageInfo.path, "ProjectData~", "Packages", "manifest.json"); string packmanSettingsPath = Path.Combine(context.PublishPackageInfo.path, "ProjectData~", "ProjectSettings", "PackageManagerSettings.asset"); ManifestPath = File.Exists(packedManifestPath) ? packedManifestPath : Path.GetFullPath("Packages/manifest.json"); PackageManagerSettingsPath = File.Exists(packmanSettingsPath) ? packmanSettingsPath : Path.GetFullPath("ProjectSettings/PackageManagerSettings.asset"); SetProjectManifestKeys(); SetPackageManagerSettings(); }
public static VettingContext CreateAssetStoreContext(string packageName, string packageVersion, string packagePath, string previousPackagePath) { VettingContext context = new VettingContext(); context.ProjectPackageInfo = new ManifestData() { path = packagePath, name = packageName, version = packageVersion }; context.PublishPackageInfo = new ManifestData() { path = packagePath, name = packageName, version = packageVersion }; context.PreviousPackageInfo = string.IsNullOrEmpty(previousPackagePath) ? null : new ManifestData() { path = previousPackagePath, name = packageName, version = "Previous" }; context.ValidationType = ValidationType.AssetStore; return(context); }
internal static void ValidateEmbeddedPackages(ValidationType validationType) { var packageIdList = new List <string>(); var directories = Directory.GetDirectories("Packages/", "*", SearchOption.TopDirectoryOnly); foreach (var directory in directories) { ActivityLogger.Log("Starting package validation for " + directory); packageIdList.Add(VettingContext.GetManifest(directory).Id); } if (packageIdList.Any()) { var success = ValidatePackages(packageIdList, validationType); ActivityLogger.Log("Package validation done and batchmode is set. Shutting down Editor"); EditorApplication.Exit(success ? 0 : 1); } else { EditorApplication.Exit(1); } }
public static bool ValidatePackage(VettingContext context, out ValidationSuiteReport report) { Profiler.BeginSample("ValidatePackage"); report = new ValidationSuiteReport(context.ProjectPackageInfo.Id, context.ProjectPackageInfo.name, context.ProjectPackageInfo.version, context.ProjectPackageInfo.path); try { // publish locally for embedded and local packages var testSuite = new ValidationSuite(SingleTestCompletedDelegate, AllTestsCompletedDelegate, context, report); report.Initialize(testSuite.context); testSuite.RunSync(); Profiler.EndSample(); return(testSuite.testSuiteState == TestState.Succeeded); } catch (Exception e) { report.OutputErrorReport(string.Format("Test Setup Error: \"{0}\"\r\n", e)); Profiler.EndSample(); return(false); } }
public static VettingContext CreatePackmanContext(string packageId, ValidationType validationType) { Profiler.BeginSample("CreatePackmanContext"); ActivityLogger.Log("Starting Packman Context Creation"); VettingContext context = new VettingContext(); var packageParts = packageId.Split('@'); var packageList = Utilities.UpmListOffline(); ActivityLogger.Log("Looking for package {0} in project", packageParts[0]); var packageInfo = packageList.SingleOrDefault(p => p.name == packageParts[0] && p.version == packageParts[1]); if (packageInfo == null) { throw new ArgumentException("Package Id " + packageId + " is not part of this project."); } #if UNITY_2019_1_OR_NEWER context.IsCore = packageInfo.source == PackageSource.BuiltIn && packageInfo.type != "module"; #else context.IsCore = false; // there are no core packages before 2019.1 #endif context.ValidationType = validationType; context.ProjectPackageInfo = GetManifest(packageInfo.resolvedPath); context.PackageType = context.ProjectPackageInfo.PackageType; if (context.ValidationType != ValidationType.VerifiedSet) { ActivityLogger.Log($"Checking if package {packageInfo.name} has been promoted to production"); context.PackageExistsOnProduction = Utilities.PackageExistsOnProduction(packageInfo.name); ActivityLogger.Log($"Package {packageInfo.name} {(context.PackageExistsOnProduction ? "is" : "is not")} in production"); ActivityLogger.Log($"Checking if package {packageInfo.packageId} has been promoted to production"); context.PackageVersionExistsOnProduction = Utilities.PackageExistsOnProduction(packageInfo.packageId); ActivityLogger.Log($"Package {packageInfo.packageId} {(context.PackageExistsOnProduction ? "is" : "is not")} in production"); } if (context.ValidationType == ValidationType.LocalDevelopment || context.ValidationType == ValidationType.LocalDevelopmentInternal) { var publishPackagePath = PublishPackage(context); context.PublishPackageInfo = GetManifest(publishPackagePath); } else { context.PublishPackageInfo = GetManifest(packageInfo.resolvedPath); } context.ProjectInfo = new ProjectInfo(context); Profiler.BeginSample("RelatedPackages"); foreach (var relatedPackage in context.PublishPackageInfo.relatedPackages) { // Check to see if the package is available locally // We are only focusing on local packages to avoid validation suite failures in CI // when the situation arises where network connection is impaired ActivityLogger.Log("Looking for related package {0} in the project", relatedPackage.Key); var foundRelatedPackage = Utilities.UpmListOffline().Where(p => p.name.Equals(relatedPackage.Key)); var relatedPackageInfo = foundRelatedPackage.ToList(); if (!relatedPackageInfo.Any()) { ActivityLogger.Log(String.Format("Cannot find the relatedPackage {0} ", relatedPackage.Key)); continue; } context.relatedPackages.Add(new RelatedPackage(relatedPackage.Key, relatedPackage.Value, relatedPackageInfo.First().resolvedPath)); } Profiler.EndSample(); // No need to compare against the previous version of the package if we're testing out the verified set. if (context.ValidationType != ValidationType.VerifiedSet) { ActivityLogger.Log("Looking for previous package version"); // List out available versions for a package var foundPackages = Utilities.UpmSearch(context.ProjectPackageInfo.name); // If it exists, get the last one from that list. if (foundPackages != null && foundPackages.Length > 0) { // Get the last released version of the package var previousPackagePath = GetPreviousReleasedPackage(context.ProjectPackageInfo, foundPackages[0]); if (!string.IsNullOrEmpty(previousPackagePath)) { context.PreviousPackageInfo = GetManifest(previousPackagePath); context.DownloadAssembliesForPreviousVersion(); } // Fill the versions for later use context.AllVersions = foundPackages[0].versions.all; } } else { context.PreviousPackageInfo = null; } context.VSuiteInfo = GetPackageValidationSuiteInfo(packageList); // Get exception Data, if any was added to the package. context.ValidationExceptionManager = new ValidationExceptionManager(context.PublishPackageInfo.path); Profiler.EndSample(); return(context); }
internal void Initialize(VettingContext context) { TextReport?.Initialize(context); }
public static bool ValidatePackage(VettingContext context, ValidationType validationType, out ValidationSuiteReport report) => ValidatePackage(context, out report);