public async Task Restore_PackageSourceMapping_Succeed()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
// Set up solution, project, and packages
var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot);
var net461 = NuGetFramework.Parse("net461");
var projectA = SimpleTestProjectContext.CreateLegacyPackageReference(
"a",
pathContext.SolutionRoot,
net461);
var projectAPackages = Path.Combine(pathContext.SolutionRoot, "packages");
var externalRepositoryPath = Path.Combine(pathContext.SolutionRoot, "ExternalRepository");
Directory.CreateDirectory(externalRepositoryPath);
var contosoRepositoryPath = Path.Combine(pathContext.SolutionRoot, "ContosoRepository");
Directory.CreateDirectory(contosoRepositoryPath);
var configPath = Path.Combine(pathContext.WorkingDirectory, "nuget.config");
SettingsTestUtils.CreateConfigurationFile(configPath, $@"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<packageSources>
<!--To inherit the global NuGet package sources remove the <clear/> line below -->
<clear />
<add key=""ExternalRepository"" value=""{externalRepositoryPath}"" />
<add key=""ContosoRepository"" value=""{contosoRepositoryPath}"" />
</packageSources>
<packageSourceMapping>
<packageSource key=""externalRepository"">
<package pattern=""External.*"" />
<package pattern=""Others.*"" />
</packageSource>
<packageSource key=""contosoRepository"">
<package pattern=""Contoso.*"" />
<package pattern=""Test.*"" />
</packageSource>
</packageSourceMapping>
</configuration>");
var ContosoReal = new SimpleTestPackageContext()
{
Id = "Contoso.A",
Version = "1.0.0"
};
ContosoReal.AddFile("lib/net461/contosoA.dll");
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
contosoRepositoryPath,
PackageSaveMode.Defaultv3,
ContosoReal);
var ExternalA = new SimpleTestPackageContext()
{
Id = "Contoso.A", // Initial version had package id conflict with Contoso repository
Version = "1.0.0"
};
ExternalA.AddFile("lib/net461/externalA.dll");
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
externalRepositoryPath,
PackageSaveMode.Defaultv3,
ExternalA);
var ExternalB = new SimpleTestPackageContext()
{
Id = "External.B", // name conflict resolved.
Version = "2.0.0"
};
ExternalB.AddFile("lib/net461/externalB.dll");
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
externalRepositoryPath,
PackageSaveMode.Defaultv3,
ExternalB);
Util.CreateFile(Path.GetDirectoryName(projectA.ProjectPath), "packages.config",
@"<packages>
<package id=""Contoso.A"" version=""1.0.0"" targetFramework=""net461"" />
<package id=""External.B"" version=""2.0.0"" targetFramework=""net461"" />
</packages>");
solution.Projects.Add(projectA);
solution.Create(pathContext.SolutionRoot);
// Act
var result = RunRestore(pathContext, _successExitCode);
// Assert
var contosoRestorePath = Path.Combine(projectAPackages, ContosoReal.ToString(), ContosoReal.ToString() + ".nupkg");
using (var nupkgReader = new PackageArchiveReader(contosoRestorePath))
{
var allFiles = nupkgReader.GetFiles().ToList();
// Assert correct Contoso package from Contoso repository was restored.
Assert.Contains("lib/net461/contosoA.dll", allFiles);
}
var externalRestorePath = Path.Combine(projectAPackages, ExternalB.ToString(), ExternalB.ToString() + ".nupkg");
Assert.True(File.Exists(externalRestorePath));
}
}
public void DependencyGraphSpec_RoundTripMSBuildMetadata_ProjectReferenceFlags()
{
// Arrange
var frameworks = new List <TargetFrameworkInformation>();
frameworks.Add(new TargetFrameworkInformation()
{
FrameworkName = NuGetFramework.Parse("net45")
});
var spec = new PackageSpec(frameworks);
var msbuildMetadata = new ProjectRestoreMetadata();
spec.RestoreMetadata = msbuildMetadata;
msbuildMetadata.ProjectUniqueName = "A55205E7-4D08-4672-8011-0925467CC45F";
msbuildMetadata.ProjectPath = "c:\\x\\x.csproj";
msbuildMetadata.ProjectName = PackageSpecName;
msbuildMetadata.ProjectStyle = ProjectStyle.PackageReference;
var tfmGroup = new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("net45"));
var tfmGroup2 = new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("netstandard1.3"));
msbuildMetadata.TargetFrameworks.Add(tfmGroup);
msbuildMetadata.TargetFrameworks.Add(tfmGroup2);
var ref1 = new ProjectRestoreReference()
{
ProjectUniqueName = "44B29B8D-8413-42D2-8DF4-72225659619B",
ProjectPath = "c:\\a\\a.csproj",
IncludeAssets = LibraryIncludeFlags.Build,
ExcludeAssets = LibraryIncludeFlags.Compile,
PrivateAssets = LibraryIncludeFlags.Runtime
};
var ref2 = new ProjectRestoreReference()
{
ProjectUniqueName = "78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F",
ProjectPath = "c:\\b\\b.csproj"
};
tfmGroup.ProjectReferences.Add(ref1);
tfmGroup.ProjectReferences.Add(ref2);
tfmGroup2.ProjectReferences.Add(ref1);
tfmGroup2.ProjectReferences.Add(ref2);
// Act
PackageSpec readSpec = PackageSpecTestUtility.RoundTrip(spec, PackageSpecName, PackageSpecPath);
// Assert
Assert.Equal(2, readSpec.RestoreMetadata.TargetFrameworks.Count);
foreach (var framework in readSpec.RestoreMetadata.TargetFrameworks)
{
var references = framework.ProjectReferences.OrderBy(e => e.ProjectUniqueName).ToArray();
Assert.Equal("44B29B8D-8413-42D2-8DF4-72225659619B", references[0].ProjectUniqueName);
Assert.Equal(LibraryIncludeFlags.Build, references[0].IncludeAssets);
Assert.Equal(LibraryIncludeFlags.Compile, references[0].ExcludeAssets);
Assert.Equal(LibraryIncludeFlags.Runtime, references[0].PrivateAssets);
Assert.Equal("78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F", references[1].ProjectUniqueName);
Assert.Equal(LibraryIncludeFlags.All, references[1].IncludeAssets);
Assert.Equal(LibraryIncludeFlags.None, references[1].ExcludeAssets);
Assert.Equal(LibraryIncludeFlagUtils.DefaultSuppressParent, references[1].PrivateAssets);
}
}
public int Execute(OnExecute execute, string[] args)
{
_app.OnExecute(() =>
{
if (_outputOption.HasValue() && !_frameworkOption.HasValue())
{
Reporter.Error.WriteLine("When the '--output' option is provided, the '--framework' option must also be provided.");
return(1);
}
// Locate the project and get the name and full path
ProjectPathValue = _projectArgument.Value;
if (string.IsNullOrEmpty(ProjectPathValue))
{
ProjectPathValue = Directory.GetCurrentDirectory();
}
OutputValue = _outputOption.Value();
BuildBasePathValue = _buildBasePath.Value();
ConfigValue = _configurationOption.Value() ?? Constants.DefaultConfiguration;
RuntimeValue = _runtimeOption.Value();
VersionSuffixValue = _versionSuffixOption.Value();
PortableMode = _portableOption.HasValue();
IsNativeValue = _nativeOption.HasValue();
ArchValue = _archOption.Value();
IlcArgsValue = _ilcArgsOption.HasValue() ? _ilcArgsOption.Values : Enumerable.Empty <string>();
IlcPathValue = _ilcPathOption.Value();
IlcSdkPathValue = _ilcSdkPathOption.Value();
AppDepSdkPathValue = _appDepSdkPathOption.Value();
IsCppModeValue = _cppModeOption.HasValue();
CppCompilerFlagsValue = _cppCompilerFlagsOption.Value();
// Set defaults based on the environment
var settings = ProjectReaderSettings.ReadFromEnvironment();
if (!string.IsNullOrEmpty(VersionSuffixValue))
{
settings.VersionSuffix = VersionSuffixValue;
}
// Load the project file and construct all the targets
var targets = ProjectContext.CreateContextForEachFramework(ProjectPathValue, settings).ToList();
if (targets.Count == 0)
{
// Project is missing 'frameworks' section
Reporter.Error.WriteLine("Project does not have any frameworks listed in the 'frameworks' section.");
return(1);
}
// Filter the targets down based on the inputs
if (_frameworkOption.HasValue())
{
var fx = NuGetFramework.Parse(_frameworkOption.Value());
targets = targets.Where(t => fx.Equals(t.TargetFramework)).ToList();
if (targets.Count == 0)
{
// We filtered everything out
Reporter.Error.WriteLine($"Project does not support framework: {fx.DotNetFrameworkName}.");
return(1);
}
Debug.Assert(targets.Count == 1);
}
Debug.Assert(targets.All(t => string.IsNullOrEmpty(t.RuntimeIdentifier)));
var success = execute(targets, this);
return(success ? 0 : 1);
});
return(_app.Execute(args));
}
public void NuGetFramework_PortableZeroMoniker()
{
NuGetFramework framework = NuGetFramework.Parse("portable");
Assert.True(framework.IsUnsupported);
}
public static NuGetFramework ParseFrameworkName(string frameworkName)
{
return(frameworkName == null ? null : NuGetFramework.Parse(frameworkName));
}
public void NuGetFramework_ParsePCLNormalizeTest(string framework)
{
Assert.Equal("Profile259", NuGetFramework.Parse(framework).Profile);
}
public void NuGetFramework_PortableRoundTrip()
{
NuGetFramework framework = NuGetFramework.Parse("portable-net45+win8+wp8+wpa81");
Assert.Equal("portable-net45+win8+wp8+wpa81", framework.GetShortFolderName());
}
private static FrameworkRuntimePair CreateFrameworkRuntimePair(string tfm = "net461", string rid = "win-x64")
{
return(new FrameworkRuntimePair(NuGetFramework.Parse(tfm), rid));
}
public void NuGetFramework_PortableWithAny()
{
NuGetFramework framework = NuGetFramework.Parse("portable-win%2Bnet45%2Bwp8");
Assert.Equal(".NETPortable,Version=v0.0,Profile=Profile78", framework.DotNetFrameworkName);
}
public static void ModifyOriginalTargetFrameworkInformationEdit(PackageSpec packageSpec)
{
packageSpec.TargetFrameworks[0].Imports.Add(NuGetFramework.Parse("net461"));
}
public static void ModifyRestoreMetadata(PackageSpec packageSpec)
{
packageSpec.TargetFrameworks[0].Imports.Add(NuGetFramework.Parse("net461"));
}
public override bool Execute()
{
IsReferenceAsset = IsReferenceAssembly;
var nuGetFx = NuGetFramework.Parse(NuGetTargetMoniker);
var suppressions = new HashSet <NuGetFramework>(
SuppressPackageTargetFrameworkCompatibility.NullAsEmpty().Select(
s => NuGetFramework.Parse(s)),
NuGetFramework.Comparer);
var compat = DefaultCompatibilityProvider.Instance;
var packageTargetFrameworks = PackageTargetFrameworks.NullAsEmpty().Where(p => !String.IsNullOrEmpty(p.ItemSpec));
foreach (var packageTargetFramework in packageTargetFrameworks)
{
var packageFx = NuGetFramework.Parse(packageTargetFramework.ItemSpec);
if (!packageFx.Equals(nuGetFx) &&
!compat.IsCompatible(packageFx, nuGetFx) &&
!suppressions.Contains(packageFx))
{
// we might be using a portable combination that doesn't directly map to a PCL profile
// break it apart to make sure every framework is supported by the build framework
if (packageFx.Framework == FrameworkConstants.FrameworkIdentifiers.Portable && packageFx.Profile.Contains("+"))
{
foreach (var portableFramework in packageFx.Profile.Split('+'))
{
var portableFx = NuGetFramework.Parse(portableFramework);
if (!compat.IsCompatible(portableFx, nuGetFx))
{
Log.LogError($"Project is built as {nuGetFx.GetShortFolderName()} but packaged as {packageFx.GetShortFolderName()} and {portableFramework} is not compatible with {nuGetFx.GetShortFolderName()}. To suppress this error you can add <SuppressPackageTargetFrameworkCompatibility Include=\"{packageFx.GetShortFolderName()}\" /> to your project file.");
}
}
}
else
{
Log.LogError($"Project is built as {nuGetFx.GetShortFolderName()} but packaged as {packageFx.GetShortFolderName()} which are not compatible; A {nuGetFx.GetShortFolderName()} asset cannot be referenced by a {packageFx.GetShortFolderName()} project. To suppress this error you can add <SuppressPackageTargetFrameworkCompatibility Include=\"{packageFx.GetShortFolderName()}\" /> to your project file.");
}
}
string runtime = PackageTargetRuntime;
// MSBuild returns an empty string for both non-existent meta-data as well as existent, but empty metadata.
// If someone has defined an empty string here, we want to honor that over PackageTargetRuntime.
if (packageTargetFramework.MetadataNames.Cast <string>().Any(md => md.Equals("TargetRuntime")))
{
runtime = packageTargetFramework.GetMetadata("TargetRuntime");
}
Add(packageFx, runtime);
}
if (_packageDestinations.Count == 0)
{
// If PackageTargetFrameworks is not set, just use the NuGetTargetMoniker
Add(nuGetFx, PackageTargetRuntime);
}
PackageDestinations = _packageDestinations.ToArray();
return(!Log.HasLoggedErrors);
}
internal static TargetFrameworkInformation ToTargetFrameworkInformation(
IVsTargetFrameworkInfo targetFrameworkInfo, bool cpvmEnabled)
{
var tfi = new TargetFrameworkInformation
{
FrameworkName = NuGetFramework.Parse(targetFrameworkInfo.TargetFrameworkMoniker)
};
var ptf = MSBuildStringUtility.Split(GetPropertyValueOrNull(targetFrameworkInfo.Properties, ProjectBuildProperties.PackageTargetFallback))
.Select(NuGetFramework.Parse)
.ToList();
var atf = MSBuildStringUtility.Split(GetPropertyValueOrNull(targetFrameworkInfo.Properties, ProjectBuildProperties.AssetTargetFallback))
.Select(NuGetFramework.Parse)
.ToList();
// Update TFI with fallback properties
AssetTargetFallbackUtility.ApplyFramework(tfi, ptf, atf);
tfi.RuntimeIdentifierGraphPath = GetPropertyValueOrNull(targetFrameworkInfo.Properties, ProjectBuildProperties.RuntimeIdentifierGraphPath);
if (targetFrameworkInfo.PackageReferences != null)
{
tfi.Dependencies.AddRange(
targetFrameworkInfo.PackageReferences
.Cast <IVsReferenceItem>()
.Select(pr => ToPackageLibraryDependency(pr, cpvmEnabled)));
}
if (targetFrameworkInfo is IVsTargetFrameworkInfo2 targetFrameworkInfo2)
{
if (targetFrameworkInfo2.PackageDownloads != null)
{
tfi.DownloadDependencies.AddRange(
targetFrameworkInfo2.PackageDownloads
.Cast <IVsReferenceItem>()
.Select(ToPackageDownloadDependency));
}
if (cpvmEnabled && targetFrameworkInfo is IVsTargetFrameworkInfo3 targetFrameworkInfo3)
{
if (targetFrameworkInfo3.CentralPackageVersions != null)
{
tfi.CentralPackageVersions.AddRange(
targetFrameworkInfo3.CentralPackageVersions
.Cast <IVsReferenceItem>()
.Select(ToCentralPackageVersion)
.Distinct(CentralPackageVersionNameComparer.Default)
.ToDictionary(cpv => cpv.Name));
}
}
if (targetFrameworkInfo2.FrameworkReferences != null)
{
PopulateFrameworkDependencies(tfi, targetFrameworkInfo2);
}
}
return(tfi);
}
static partial void Wain(IEnumerable <string> args)
{
const string csx = "csx";
const string exe = "exe";
var verbose = false;
var help = false;
var recurse = false;
var force = false;
var watching = false;
var incremental = false;
var extraPackageList = new List <PackageReference>();
var extraImportList = new List <string>();
var target = csx;
var targetFramework = NuGetFramework.Parse(AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName);
var options = new OptionSet
{
{ "?|help|h", "prints out the options", _ => help = true },
{ "verbose|v", "enable additional output", _ => verbose = true },
{ "d|debug", "debug break", _ => Debugger.Launch() },
{ "r|recurse", "include sub-directories", _ => recurse = true },
{ "f|force", "force continue on errors", _ => force = true },
{ "w|watch", "watch for changes and re-compile outdated", _ => watching = true },
{ "i|incremental", "compile outdated scripts only", _ => incremental = true },
{ "ref|reference=", "extra NuGet reference", v => { if (!string.IsNullOrEmpty(v))
{
extraPackageList.Add(ParseExtraPackageReference(v));
}
} },
{ "imp|import=", "extra import", v => { extraImportList.Add(v); } },
{ "t|target=", csx + " = C# script (default); " + exe + " = executable", v => target = v },
{ "fx=", $"target framework; default: {targetFramework}", v => targetFramework = NuGetFramework.Parse(v) },
};
var tail = options.Parse(args.TakeWhile(arg => arg != "--"));
if (verbose)
{
Trace.Listeners.Add(new ConsoleTraceListener(useErrorStream: true));
}
if (help || tail.Count == 0)
{
Help(options);
return;
}
var generator =
csx.Equals(target, StringComparison.OrdinalIgnoreCase)
? GenerateCsx
: exe.Equals(target, StringComparison.OrdinalIgnoreCase)
? (Generator)GenerateExecutable
: throw new Exception("Target is invalid or missing. Supported targets are: "
+ string.Join(", ", csx, exe));
extraImportList.RemoveAll(string.IsNullOrEmpty);
// TODO Allow package source to be specified via args
var queries = GetQueries(tail, recurse);
// TODO Allow packages directory to be specified via args
const string packagesDirName = "packages";
var compiler = Compiler(NuGetClient.CreateDefaultFactory(), packagesDirName, extraPackageList, extraImportList,
targetFramework, generator,
watching || incremental, force, verbose);
if (watching)
{
if (tail.Count > 1)
{
// TODO Support multiple watch roots
throw new NotSupportedException(
"Watch mode does not support multiple file specifications. " +
"Use a single wildcard specification instead instead to watch and re-compile several queries.");
}
var tokens = SplitDirFileSpec(tail.First()).Fold((dp, fs) =>
(
dirPath: dp ?? Environment.CurrentDirectory,
fileSpec: fs
));
using (var cts = new CancellationTokenSource())
{
Console.CancelKeyPress += (_, e) =>
{
// TODO Re-consider proper cancellation
Console.WriteLine("Aborting...");
// ReSharper disable once AccessToDisposedClosure
cts.Cancel();
e.Cancel = true;
};
var changes =
FileMonitor.GetFolderChanges(
tokens.dirPath, tokens.fileSpec,
recurse,
NotifyFilters.FileName
| NotifyFilters.LastWrite,
WatcherChangeTypes.Created
| WatcherChangeTypes.Changed
| WatcherChangeTypes.Renamed,
cts.Token);
foreach (var e in from cs in changes.Throttle(TimeSpan.FromSeconds(2))
select cs.Length)
{
Console.WriteLine($"{e} change(s) detected. Re-compiling...");
var count = 0;
var compiledCount = 0;
// ReSharper disable once LoopCanBeConvertedToQuery
// ReSharper disable once LoopCanBePartlyConvertedToQuery
// ReSharper disable once PossibleMultipleEnumeration
foreach (var query in queries)
{
// TODO Re-try on potential file locking issues
var compiled = compiler(query);
count++;
compiledCount += compiled ? 1 : 0;
}
if (count > 1)
{
Console.WriteLine($"Re-compiled {compiledCount:N0} of {count:N0} queries.");
}
}
}
}
else
{
foreach (var query in queries)
{
compiler(query);
}
}
}
public void NuGetFramework_Unsupported(string folderName)
{
Assert.Equal("Unsupported,Version=v0.0", NuGetFramework.Parse(folderName).DotNetFrameworkName);
}
public void NuGetFramework_IncludeUnknownProfile()
{
string actual = NuGetFramework.Parse("net45-custom").DotNetFrameworkName;
Assert.Equal(".NETFramework,Version=v4.5,Profile=custom", actual);
}
public void NuGetFramework_ParsePCLTest()
{
var fw = NuGetFramework.Parse("portable-net40%2Bsl5%2Bwp80%2Bwin8%2Bwpa81");
Assert.Equal("portable-net40+sl5+win8+wp8+wpa81", fw.GetShortFolderName());
}
public void NuGetFramework_Mixed()
{
string actual = NuGetFramework.Parse(".NETFramework3.5").GetShortFolderName();
Assert.Equal("net35", actual);
}
public void NuGetFramework_Numeric(string input, string expected)
{
string actual = NuGetFramework.Parse(input).GetShortFolderName();
Assert.Equal(expected, actual);
}
public void NuGetFramework_ParseFullName(string input, string expected)
{
string actual = NuGetFramework.Parse(input).DotNetFrameworkName;
Assert.Equal(expected, actual);
}
public void NuGetFramework_PortableSingleMoniker()
{
NuGetFramework framework = NuGetFramework.Parse("portable-net45");
Assert.Equal("portable-net45", framework.GetShortFolderName());
}
public void NuGetFramework_Portable(string folder, string expected)
{
string actual = NuGetFramework.Parse(folder).DotNetFrameworkName;
Assert.Equal(expected, actual);
}
public void NuGetFramework_PortableWithOptional()
{
NuGetFramework framework = NuGetFramework.Parse("portable-net4%2Bsl5%2Bwp8%2Bwin8%2Bwpa81%2Bmonotouch%2Bmonoandroid");
Assert.Equal(".NETPortable,Version=v0.0,Profile=Profile328", framework.DotNetFrameworkName);
}
public void NuGetFramework_ProfileName(string folder, string expected)
{
string actual = NuGetFramework.Parse(folder).Profile;
Assert.Equal(expected, actual);
}
public void DependencyGraphSpec_RoundTripMSBuildMetadata()
{
// Arrange
var frameworks = new List <TargetFrameworkInformation>();
frameworks.Add(new TargetFrameworkInformation()
{
FrameworkName = NuGetFramework.Parse("net45")
});
var spec = new PackageSpec(frameworks);
spec.Version = NuGetVersion.Parse("24.5.1.2-alpha.1.2+a.b.c");
var msbuildMetadata = new ProjectRestoreMetadata();
spec.RestoreMetadata = msbuildMetadata;
msbuildMetadata.ProjectUniqueName = "A55205E7-4D08-4672-8011-0925467CC45F";
msbuildMetadata.ProjectPath = "c:\\x\\x.csproj";
msbuildMetadata.ProjectName = PackageSpecName;
msbuildMetadata.ProjectJsonPath = "c:\\x\\project.json";
msbuildMetadata.ProjectStyle = ProjectStyle.PackageReference;
msbuildMetadata.PackagesPath = "c:\\packages";
msbuildMetadata.Sources = new[] { new PackageSource("https://api.nuget.org/v3/index.json") };
var tfmGroup = new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("net45"));
msbuildMetadata.TargetFrameworks.Add(tfmGroup);
tfmGroup.ProjectReferences.Add(new ProjectRestoreReference()
{
ProjectUniqueName = "44B29B8D-8413-42D2-8DF4-72225659619B",
ProjectPath = "c:\\a\\a.csproj"
});
tfmGroup.ProjectReferences.Add(new ProjectRestoreReference()
{
ProjectUniqueName = "78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F",
ProjectPath = "c:\\b\\b.csproj"
});
msbuildMetadata.FallbackFolders.Add("c:\\fallback1");
msbuildMetadata.FallbackFolders.Add("c:\\fallback2");
msbuildMetadata.ConfigFilePaths.Add("c:\\nuget.config");
msbuildMetadata.ConfigFilePaths.Add("d:\\nuget.config");
msbuildMetadata.CrossTargeting = true;
msbuildMetadata.LegacyPackagesDirectory = true;
// Act
PackageSpec readSpec = PackageSpecTestUtility.RoundTrip(spec, PackageSpecName, PackageSpecPath);
ProjectRestoreMetadata msbuildMetadata2 = readSpec.RestoreMetadata;
// Assert
Assert.NotNull(msbuildMetadata2);
Assert.Equal("A55205E7-4D08-4672-8011-0925467CC45F", msbuildMetadata2.ProjectUniqueName);
Assert.Equal("c:\\x\\x.csproj", msbuildMetadata2.ProjectPath);
Assert.Equal(PackageSpecName, msbuildMetadata2.ProjectName);
Assert.Equal("c:\\x\\project.json", msbuildMetadata2.ProjectJsonPath);
Assert.Equal(ProjectStyle.PackageReference, msbuildMetadata2.ProjectStyle);
Assert.Equal("c:\\packages", msbuildMetadata2.PackagesPath);
Assert.Equal("https://api.nuget.org/v3/index.json", string.Join("|", msbuildMetadata.Sources.Select(s => s.Source)));
Assert.Equal("c:\\fallback1|c:\\fallback2", string.Join("|", msbuildMetadata2.FallbackFolders));
Assert.Equal("c:\\nuget.config|d:\\nuget.config", string.Join("|", msbuildMetadata.ConfigFilePaths));
Assert.Equal("44B29B8D-8413-42D2-8DF4-72225659619B|c:\\a\\a.csproj|78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F|c:\\b\\b.csproj", string.Join("|", msbuildMetadata2.TargetFrameworks.Single().ProjectReferences.Select(e => $"{e.ProjectUniqueName}|{e.ProjectPath}")));
Assert.True(msbuildMetadata.CrossTargeting);
Assert.True(msbuildMetadata.LegacyPackagesDirectory);
// Verify build metadata is not lost.
Assert.Equal("24.5.1.2-alpha.1.2+a.b.c", readSpec.Version.ToFullString());
}
public void NuGetFramework_Decimals()
{
string actual = NuGetFramework.Parse("Win10.1.2.3").GetShortFolderName();
Assert.Equal("win10.1.2.3", actual);
}
public IHttpActionResult GetUpdates(
ODataQueryOptions <V2FeedPackage> options,
[FromODataUri] string packageIds,
[FromODataUri] string versions,
[FromODataUri] bool includePrerelease,
[FromODataUri] bool includeAllVersions,
[FromODataUri] string targetFrameworks = "",
[FromODataUri] string versionConstraints = "",
[FromUri] string semVerLevel = null)
{
if (string.IsNullOrEmpty(packageIds) || string.IsNullOrEmpty(versions))
{
return(Ok(Enumerable.Empty <V2FeedPackage>().AsQueryable()));
}
if (!ODataQueryVerifier.AreODataOptionsAllowed(options, ODataQueryVerifier.V2GetUpdates,
_configurationService.Current.IsODataFilterEnabled, nameof(GetUpdates)))
{
return(BadRequest(ODataQueryVerifier.GetValidationFailedMessage(options)));
}
// Workaround https://github.com/NuGet/NuGetGallery/issues/674 for NuGet 2.1 client.
// Can probably eventually be retired (when nobody uses 2.1 anymore...)
// Note - it was URI un-escaping converting + to ' ', undoing that is actually a pretty conservative substitution because
// space characters are never accepted as valid by VersionUtility.ParseFrameworkName.
if (!string.IsNullOrEmpty(targetFrameworks))
{
targetFrameworks = targetFrameworks.Replace(' ', '+');
}
var idValues = packageIds.Trim().ToLowerInvariant().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
var versionValues = versions.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
var targetFrameworkValues = string.IsNullOrEmpty(targetFrameworks)
? null
: targetFrameworks.Split('|').Select(tfx => NuGetFramework.Parse(tfx)).ToList();
var versionConstraintValues = string.IsNullOrEmpty(versionConstraints)
? new string[idValues.Length]
: versionConstraints.Split('|');
if (idValues.Length == 0 || idValues.Length != versionValues.Length || idValues.Length != versionConstraintValues.Length)
{
// Exit early if the request looks invalid
return(Ok(Enumerable.Empty <V2FeedPackage>().AsQueryable()));
}
var versionLookup = idValues.Select((id, i) =>
{
NuGetVersion currentVersion;
if (NuGetVersion.TryParse(versionValues[i], out currentVersion))
{
VersionRange versionConstraint = null;
if (versionConstraintValues[i] != null)
{
if (!VersionRange.TryParse(versionConstraintValues[i], out versionConstraint))
{
versionConstraint = null;
}
}
return(Tuple.Create(id, Tuple.Create(currentVersion, versionConstraint)));
}
return(null);
})
.Where(t => t != null)
.ToLookup(t => t.Item1, t => t.Item2, StringComparer.OrdinalIgnoreCase);
var packages = _packagesRepository.GetAll()
.Include(p => p.PackageRegistration)
.Include(p => p.SupportedFrameworks)
.Where(p =>
p.Listed && (includePrerelease || !p.IsPrerelease) && !p.Deleted &&
idValues.Contains(p.PackageRegistration.Id.ToLower()))
.OrderBy(p => p.PackageRegistration.Id);
var semVerLevelKey = SemVerLevelKey.ForSemVerLevel(semVerLevel);
var queryable = GetUpdates(packages, versionLookup, targetFrameworkValues, includeAllVersions, semVerLevel)
.AsQueryable()
.ToV2FeedPackageQuery(
GetSiteRoot(),
_configurationService.Features.FriendlyLicenses,
semVerLevelKey);
return(QueryResult(options, queryable, MaxPageSize));
}
public void NuGetFramework_Basic(string folderName, string fullName)
{
string output = NuGetFramework.Parse(folderName).DotNetFrameworkName;
Assert.Equal(fullName, output);
}
public ProjectContextBuilder WithTargetFramework(string targetFramework)
{
TargetFramework = NuGetFramework.Parse(targetFramework);
return(this);
}
public async Task Restore_WithLockedModeAndNoObjFolder_RestoreFailsAndWritesOutRestoreResultFiles()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
// Set up solution, project, and packages
var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot);
var net461 = NuGetFramework.Parse("net461");
var projectA = SimpleTestProjectContext.CreateLegacyPackageReference(
"a",
pathContext.SolutionRoot,
net461);
projectA.Properties.Add("RuntimeIdentifier", "win");
var packageX = new SimpleTestPackageContext()
{
Id = "x",
Version = "1.0.0"
};
packageX.Files.Clear();
packageX.AddFile("lib/net461/a.dll");
var packageY = new SimpleTestPackageContext()
{
Id = "y",
Version = "1.0.0"
};
packageY.Files.Clear();
packageY.AddFile("lib/net461/y.dll");
projectA.AddPackageToAllFrameworks(packageX);
solution.Projects.Add(projectA);
solution.Create(pathContext.SolutionRoot);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
PackageSaveMode.Defaultv3,
packageX,
packageY);
var result = RunRestore(pathContext, _successExitCode, "-UseLockFile");
Assert.True(result.Success);
Assert.True(File.Exists(projectA.NuGetLockFileOutputPath));
var originalPackagesLockFileWriteTime = new FileInfo(projectA.NuGetLockFileOutputPath).LastWriteTimeUtc;
projectA.AddPackageToAllFrameworks(packageY);
projectA.Save();
// Remove old obj folders.
Directory.Delete(Path.GetDirectoryName(projectA.AssetsFileOutputPath), recursive: true);
// Act
result = RunRestore(pathContext, _failureExitCode, "-LockedMode");
// Assert
Assert.Contains("NU1004:", result.Errors);
var assetsFile = projectA.AssetsFile;
var logCodes = assetsFile.LogMessages.Select(e => e.Code);
Assert.Contains(NuGetLogCode.NU1004, logCodes);
Assert.Equal(2, assetsFile.Targets.Count);
var ridlessMainTarget = assetsFile.Targets.FirstOrDefault(e => string.IsNullOrEmpty(e.RuntimeIdentifier));
Assert.Equal(net461, ridlessMainTarget.TargetFramework);
var ridMainTarget = assetsFile.Targets.FirstOrDefault(e => "win".Equals(e.RuntimeIdentifier));
Assert.Equal("win", ridMainTarget.RuntimeIdentifier);
Assert.True(File.Exists(projectA.PropsOutput));
Assert.True(File.Exists(projectA.TargetsOutput));
Assert.True(File.Exists(projectA.CacheFileOutputPath));
var packagesLockFileWriteTime = new FileInfo(projectA.NuGetLockFileOutputPath).LastWriteTimeUtc;
packagesLockFileWriteTime.Should().Be(originalPackagesLockFileWriteTime, because: "Locked mode must not overwrite the lock file");
}
}
