Mirrors/velopack
1
0
Fork 0
mirror of https://github.com/velopack/velopack.git synced 2025-10-25 15:19:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

WIP fixing tests

Browse Source
This commit is contained in:
Caelan Sayler
2023-12-17 17:00:38 +00:00
parent 37c5f67a63
commit d337a0598e
32 changed files with 493 additions and 393 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
test/Directory.Build.props Normal file
View File

@@ -0,0 +1,27 @@
<?xml version="1.0" encoding="utf-8"?>
<Project>
<PropertyGroup>
<IsPackable>false</IsPackable>
<LangVersion>latest</LangVersion>
<IsTest>true</IsTest>
<NoWarn>$(NoWarn);CS1998,xUnit2015,xUnit2017,xUnit2005,xUnit2009,xUnit2013,xUnit2004;CA2007</NoWarn>
<SignAssembly>True</SignAssembly>
<AssemblyOriginatorKeyFile>..\..\Squirrel.snk</AssemblyOriginatorKeyFile>
<IsPackable>false</IsPackable>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
<ItemGroup>
<Compile Include="..\GlobalUsings.cs" Link="GlobalUsings.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
<PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
<PackageReference Include="xunit" Version="2.6.3" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.5.5" PrivateAssets="All" />
<PackageReference Include="Xunit.SkippableFact" Version="1.4.13" />
<PackageReference Include="Divergic.Logging.Xunit" Version="4.3.0" />
</ItemGroup>
</Project>

2
test/Squirrel.Packaging.Tests/GlobalUsings.cs → test/GlobalUsings.cs
View File

@@ -4,6 +4,6 @@ global using System.IO;
global using System.Linq;
global using System.Threading.Tasks;
global using Microsoft.Extensions.Logging;
//global using Microsoft.Extensions.Logging.Abstractions;
global using Microsoft.Extensions.Logging.Abstractions;
global using Xunit;
global using Xunit.Abstractions;

4
test/Squirrel.CommandLine.Tests/BaseCommandTests.cs
View File

@@ -1,4 +1,6 @@
namespace Squirrel.CommandLine.Tests;
using Squirrel.Csq.Commands;
namespace Squirrel.CommandLine.Tests;
public abstract class BaseCommandTests<T> : TempFileTestBase
where T : BaseCommand, new()

5
test/Squirrel.CommandLine.Tests/Commands/GitHubCommandTests.cs
View File

@@ -1,4 +1,7 @@
namespace Squirrel.CommandLine.Tests.Commands;
using System.CommandLine;
using Squirrel.Csq.Commands;
namespace Squirrel.CommandLine.Tests.Commands;
public abstract class GitHubCommandTests<T> : BaseCommandTests<T>
where T : GitHubBaseCommand, new()

3
test/Squirrel.CommandLine.Tests/Commands/HttpDownloadCommandTests.cs
View File

@@ -1,4 +1,7 @@

using System.CommandLine;
using Squirrel.Csq.Commands;
namespace Squirrel.CommandLine.Tests.Commands;
public class HttpDownloadCommandTests : BaseCommandTests<HttpDownloadCommand>

5
test/Squirrel.CommandLine.Tests/Commands/S3CommandTests.cs
View File

@@ -1,4 +1,7 @@
namespace Squirrel.CommandLine.Tests.Commands;
using System.CommandLine;
using Squirrel.Csq.Commands;
namespace Squirrel.CommandLine.Tests.Commands;
public abstract class S3CommandTests<T> : BaseCommandTests<T>
where T : S3BaseCommand, new()

3
test/Squirrel.CommandLine.Tests/Commands/WindowsCommandTests.cs
View File

@@ -1,4 +1,7 @@

using System.CommandLine;
using Squirrel.Csq.Commands;
namespace Squirrel.CommandLine.Tests.Commands;
public abstract class ReleaseCommandTests<T> : BaseCommandTests<T>

10
test/Squirrel.CommandLine.Tests/GlobalUsings.cs
View File

@@ -1,10 +0,0 @@
global using System;
global using System.CommandLine;
global using System.Collections.Generic;
global using System.IO;
global using System.Linq;
global using System.Threading.Tasks;
global using Microsoft.Extensions.Logging;
global using Xunit;
global using Xunit.Abstractions;
global using Squirrel.Csq.Commands;

12
test/Squirrel.CommandLine.Tests/Squirrel.CommandLine.Tests.csproj
View File

@@ -1,19 +1,11 @@
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsTest>true</IsTest>
<IsPackable>false</IsPackable>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
<PackageReference Include="xunit" Version="2.6.3" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.5.5" PrivateAssets="All" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\src\Squirrel.Csq\Squirrel.Csq.csproj" />
</ItemGroup>

3
test/Squirrel.CommandLine.Tests/TempFileTestBase.cs
View File

@@ -1,4 +1,5 @@
using Xunit.Sdk;
using System.Threading;
using Xunit.Sdk;
namespace Squirrel.CommandLine.Tests;

19
test/Squirrel.Packaging.Tests/Squirrel.Packaging.Tests.csproj
View File

@@ -1,26 +1,9 @@
<?xml version="1.0" encoding="utf-8"?>
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0-windows</TargetFramework>
<IsPackable>false</IsPackable>
<LangVersion>latest</LangVersion>
<IsTest>true</IsTest>
<NoWarn>$(NoWarn);CS1998,xUnit2015,xUnit2017,xUnit2005,xUnit2009,xUnit2013,xUnit2004;CA2007</NoWarn>
<SignAssembly>True</SignAssembly>
<AssemblyOriginatorKeyFile>..\..\Squirrel.snk</AssemblyOriginatorKeyFile>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
<PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
<PackageReference Include="xunit" Version="2.6.3" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.5.5" PrivateAssets="All" />
<PackageReference Include="Xunit.SkippableFact" Version="1.4.13" />
<PackageReference Include="Divergic.Logging.Xunit" Version="4.3.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\src\Squirrel.Packaging.Windows\Squirrel.Packaging.Windows.csproj" />
</ItemGroup>

105
test/Squirrel.Tests/Legacy/ReleaseEntry.cs → test/Squirrel.Tests/OldSquirrel/ReleaseEntry.cs
View File

@@ -3,28 +3,17 @@ using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Text.RegularExpressions;
using NuGet;
using System.Runtime.Serialization;
using System.Threading.Tasks;
using System.Collections.Concurrent;
namespace Squirrel.Tests.Legacy
namespace Squirrel.Tests.OldSquirrel
{
public interface IReleaseEntry
{
string SHA1 { get; }
string Filename { get; }
long Filesize { get; }
bool IsDelta { get; }
string EntryAsString { get; }
SemanticVersion Version { get; }
string PackageName { get; }
float? StagingPercentage { get; }
//string GetReleaseNotes(string packageDirectory);
//Uri GetIconUrl(string packageDirectory);
}
[DataContract]
public class ReleaseEntry : IReleaseEntry
public class ReleaseEntry
{
[DataMember] public string SHA1 { get; protected set; }
[DataMember] public string BaseUrl { get; protected set; }
@@ -55,18 +44,8 @@ namespace Squirrel.Tests.Legacy
}
}
static readonly Regex _suffixRegex = new Regex(@"(-full|-delta)?\.nupkg$", RegexOptions.Compiled);
static readonly Regex _versionRegex = new Regex(@"\d+(\.\d+){0,3}(-[A-Za-z][0-9A-Za-z-]*)?$", RegexOptions.Compiled);
public static SemanticVersion ToSemanticVersion(string fileName)
{
var name = _suffixRegex.Replace(fileName, "");
var version = _versionRegex.Match(name).Value;
return new SemanticVersion(version);
}
[IgnoreDataMember]
public SemanticVersion Version { get { return ToSemanticVersion(Filename); } }
public SemanticVersion Version { get { return Filename.ToSemanticVersion(); } }
static readonly Regex packageNameRegex = new Regex(@"^([\w-]+)-\d+\..+\.nupkg$");
[IgnoreDataMember]
@@ -179,7 +158,7 @@ namespace Squirrel.Tests.Legacy
return new ReleaseEntry[0];
}
fileContents = Utility.RemoveByteOrderMarkerIfPresent(fileContents);
//fileContents = Utility.RemoveByteOrderMarkerIfPresent(fileContents);
var ret = fileContents.Split('\n')
.Where(x => !String.IsNullOrWhiteSpace(x))
@@ -196,7 +175,7 @@ namespace Squirrel.Tests.Legacy
return new ReleaseEntry[0];
}
fileContents = Utility.RemoveByteOrderMarkerIfPresent(fileContents);
//fileContents = Utility.RemoveByteOrderMarkerIfPresent(fileContents);
var ret = fileContents.Split('\n')
.Where(x => !String.IsNullOrWhiteSpace(x))
@@ -208,44 +187,44 @@ namespace Squirrel.Tests.Legacy
}
public static void WriteReleaseFile(IEnumerable<ReleaseEntry> releaseEntries, Stream stream)
{
Contract.Requires(releaseEntries != null && releaseEntries.Any());
Contract.Requires(stream != null);
//public static void WriteReleaseFile(IEnumerable<ReleaseEntry> releaseEntries, Stream stream)
//{
// Contract.Requires(releaseEntries != null && releaseEntries.Any());
// Contract.Requires(stream != null);
using (var sw = new StreamWriter(stream, Encoding.UTF8)) {
sw.Write(String.Join("\n", releaseEntries
.OrderBy(x => x.Version)
.ThenByDescending(x => x.IsDelta)
.Select(x => x.EntryAsString)));
}
}
// using (var sw = new StreamWriter(stream, Encoding.UTF8)) {
// sw.Write(String.Join("\n", releaseEntries
// .OrderBy(x => x.Version)
// .ThenByDescending(x => x.IsDelta)
// .Select(x => x.EntryAsString)));
// }
//}
public static void WriteReleaseFile(IEnumerable<ReleaseEntry> releaseEntries, string path)
{
Contract.Requires(releaseEntries != null && releaseEntries.Any());
Contract.Requires(!String.IsNullOrEmpty(path));
//public static void WriteReleaseFile(IEnumerable<ReleaseEntry> releaseEntries, string path)
//{
// Contract.Requires(releaseEntries != null && releaseEntries.Any());
// Contract.Requires(!String.IsNullOrEmpty(path));
using (var f = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None)) {
WriteReleaseFile(releaseEntries, f);
}
}
// using (var f = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None)) {
// WriteReleaseFile(releaseEntries, f);
// }
//}
public static ReleaseEntry GenerateFromFile(Stream file, string filename, string baseUrl = null)
{
Contract.Requires(file != null && file.CanRead);
Contract.Requires(!String.IsNullOrEmpty(filename));
//public static ReleaseEntry GenerateFromFile(Stream file, string filename, string baseUrl = null)
//{
// Contract.Requires(file != null && file.CanRead);
// Contract.Requires(!String.IsNullOrEmpty(filename));
var hash = Utility.CalculateStreamSHA1(file);
return new ReleaseEntry(hash, filename, file.Length, filenameIsDeltaFile(filename), baseUrl);
}
// var hash = Utility.CalculateStreamSHA1(file);
// return new ReleaseEntry(hash, filename, file.Length, filenameIsDeltaFile(filename), baseUrl);
//}
public static ReleaseEntry GenerateFromFile(string path, string baseUrl = null)
{
using (var inf = File.OpenRead(path)) {
return GenerateFromFile(inf, Path.GetFileName(path), baseUrl);
}
}
//public static ReleaseEntry GenerateFromFile(string path, string baseUrl = null)
//{
// using (var inf = File.OpenRead(path)) {
// return GenerateFromFile(inf, Path.GetFileName(path), baseUrl);
// }
//}
//public static List<ReleaseEntry> BuildReleasesFile(string releasePackagesDir)
//{
@@ -300,7 +279,7 @@ namespace Squirrel.Tests.Legacy
// return releaseEntries
// .Where(x => x.IsDelta == false)
// .Where(x => x.Version < package.ToSemanticVersion())
// .OrderByDescending(x => x.Version)
// .OrderByDescending(x => x.Version)
// .Select(x => new ReleasePackage(Path.Combine(targetDir, x.Filename), true))
// .FirstOrDefault();
//}

27
test/Squirrel.Tests/OldSquirrel/ReleaseExtensions.cs Normal file
View File

@@ -0,0 +1,27 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
namespace Squirrel.Tests.OldSquirrel
{
public static class VersionExtensions
{
static readonly Regex _suffixRegex = new Regex(@"(-full|-delta)?\.nupkg$", RegexOptions.Compiled);
static readonly Regex _versionRegex = new Regex(@"\d+(\.\d+){0,3}(-[A-Za-z][0-9A-Za-z-]*)?$", RegexOptions.Compiled);
//public static SemanticVersion ToSemanticVersion(this IReleasePackage package)
//{
// return package.InputPackageFile.ToSemanticVersion();
//}
public static SemanticVersion ToSemanticVersion(this string fileName)
{
var name = _suffixRegex.Replace(fileName, "");
var version = _versionRegex.Match(name).Value;
return new SemanticVersion(version);
}
}
}

10
test/Squirrel.Tests/Legacy/SemanticVersion.cs → test/Squirrel.Tests/OldSquirrel/SemanticVersion.cs
View File

@@ -1,8 +1,10 @@
using System;

using System;
using System.ComponentModel;
using System.Globalization;
using System.Text.RegularExpressions;
namespace Squirrel.Tests.Legacy
namespace Squirrel.Tests.OldSquirrel
{
/// <summary>
/// A hybrid implementation of SemVer that supports semantic versioning as described at http://semver.org while not strictly enforcing it to
@@ -118,7 +120,7 @@ namespace Squirrel.Tests.Legacy
public static SemanticVersion Parse(string version)
{
if (String.IsNullOrEmpty(version)) {
throw new ArgumentException("Argument_Cannot_Be_Null_Or_Empty");
throw new ArgumentException("Argument_Cannot_Be_Null_Or_Empty", "version");
}
SemanticVersion semVer;
@@ -187,7 +189,7 @@ namespace Squirrel.Tests.Legacy
}
SemanticVersion other = obj as SemanticVersion;
if (other == null) {
throw new ArgumentException("TypeMustBeASemanticVersion");
throw new ArgumentException("TypeMustBeASemanticVersion", "obj");
}
return CompareTo(other);
}

21
test/Squirrel.Tests/OldSquirrel/Utility.cs Normal file
View File

@@ -0,0 +1,21 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Squirrel.Tests.OldSquirrel
{
internal static class Utility
{
public static bool IsHttpUrl(string urlOrPath)
{
var uri = default(Uri);
if (!Uri.TryCreate(urlOrPath, UriKind.Absolute, out uri)) {
return false;
}
return uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps;
}
}
}

131
test/Squirrel.Tests/ReleaseEntryTests.cs
View File

@@ -1,14 +1,49 @@
using System;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using NuGet.Versioning;
using Squirrel.Tests.TestHelpers;
using Xunit;
using OldReleaseEntry = Squirrel.Tests.OldSquirrel.ReleaseEntry;
using OldSemanticVersion = Squirrel.Tests.OldSquirrel.SemanticVersion;
namespace Squirrel.Tests
{
public class ReleaseEntryTests
{
[Theory]
[InlineData(@"MyCoolApp-1.0-full.nupkg", "MyCoolApp", "1.0", "")]
[InlineData(@"MyCoolApp-1.0.0-full.nupkg", "MyCoolApp", "1.0.0", "")]
[InlineData(@"MyCoolApp-1.0.0-delta.nupkg", "MyCoolApp", "1.0.0", "")]
[InlineData(@"MyCoolApp-1.0.0-win-x64-full.nupkg", "MyCoolApp", "1.0.0", "win-x64")]
[InlineData(@"MyCoolApp-123.456.789-win-x64-full.nupkg", "MyCoolApp", "123.456.789", "win-x64")]
[InlineData(@"MyCoolApp-123.456.789-hello-win-x64-full.nupkg", "MyCoolApp", "123.456.789", "hello-win-x64")]
public void NewEntryCanRoundTripToOldSquirrel(string fileName, string id, string version, string metadata)
{
var size = 80396;
var sha = "14db31d2647c6d2284882a2e101924a9c409ee67";
var re = new ReleaseEntry(sha, fileName, size, null, null, null);
StringBuilder file = new StringBuilder();
file.AppendLine(re.EntryAsString);
var parsed = OldReleaseEntry.ParseReleaseFile(file.ToString());
Assert.True(parsed.Count() == 1);
var oldEntry = parsed.First();
Assert.Equal(fileName, oldEntry.Filename);
Assert.Equal(id, oldEntry.PackageName);
Assert.Equal(size, oldEntry.Filesize);
Assert.Equal(sha, oldEntry.SHA1);
Assert.Null(oldEntry.BaseUrl);
Assert.Null(oldEntry.Query);
Assert.True(oldEntry.Version.Version == OldSemanticVersion.Parse(version).Version);
Assert.Equal(oldEntry.Version.SpecialVersion, metadata);
}
[Theory]
[InlineData(@"94689fede03fed7ab59c24337673a27837f0c3ec MyCoolApp-1.0.nupkg 1004502", "MyCoolApp-1.0.nupkg", 1004502, null, null)]
[InlineData(@"3a2eadd15dd984e4559f2b4d790ec8badaeb6a39 MyCoolApp-1.1.nupkg 1040561", "MyCoolApp-1.1.nupkg", 1040561, null, null)]
@@ -21,12 +56,12 @@ namespace Squirrel.Tests
{
var fixture = ReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(fileName, fixture.Filename);
Assert.Equal(fileName, fixture.OriginalFilename);
Assert.Equal(fileSize, fixture.Filesize);
Assert.Equal(baseUrl, fixture.BaseUrl);
Assert.Equal(query, fixture.Query);
var old = Legacy.ReleaseEntry.ParseReleaseEntry(releaseEntry);
var old = OldReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(fileName, old.Filename);
Assert.Equal(fileSize, old.Filesize);
Assert.Equal(baseUrl, old.BaseUrl);
@@ -40,7 +75,7 @@ namespace Squirrel.Tests
public void ParseValidReleaseEntryLinesWithDots(string releaseEntry, string packageName)
{
var fixture = ReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(packageName, fixture.PackageName);
Assert.Equal(packageName, fixture.PackageId);
}
[Theory]
@@ -50,7 +85,7 @@ namespace Squirrel.Tests
public void ParseValidReleaseEntryLinesWithDashes(string releaseEntry, string packageName)
{
var fixture = ReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(packageName, fixture.PackageName);
Assert.Equal(packageName, fixture.PackageId);
}
[Theory]
@@ -106,10 +141,7 @@ namespace Squirrel.Tests
[InlineData("0600000000000000000000000000000000000000 MyCoolApp-1.2.3.4-beta1.nupkg 123", 1, 2, 3, 4, "beta1", false)]
[InlineData("0700000000000000000000000000000000000000 MyCoolApp-1.2.3.4-beta1-full.nupkg 123", 1, 2, 3, 4, "beta1", false)]
[InlineData("0800000000000000000000000000000000000000 MyCoolApp-1.2.3.4-beta1-delta.nupkg 123", 1, 2, 3, 4, "beta1", true)]
[InlineData("0900000000000000000000000000000000000000 MyCoolApp-1.2.3-beta1-win7-x64.nupkg 123", 1, 2, 3, 0, "beta1-win7-x64", false)]
[InlineData("0010000000000000000000000000000000000000 MyCoolApp-1.2.3-beta1-win7-x64-full.nupkg 123", 1, 2, 3, 0, "beta1-win7-x64", false)]
[InlineData("0020000000000000000000000000000000000000 MyCoolApp-1.2.3-beta1-win7-x64-delta.nupkg 123", 1, 2, 3, 0, "beta1-win7-x64", true)]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-beta.22-win7-x64-full.nupkg 123", 1, 2, 3, 0, "beta1-win7-x64", false)]
public void ParseVersionTest(string releaseEntry, int major, int minor, int patch, int revision, string prerelease, bool isDelta)
{
var fixture = ReleaseEntry.ParseReleaseEntry(releaseEntry);
@@ -117,11 +149,48 @@ namespace Squirrel.Tests
Assert.Equal(new NuGetVersion(major, minor, patch, revision, prerelease, null), fixture.Version);
Assert.Equal(isDelta, fixture.IsDelta);
var old = Legacy.ReleaseEntry.ParseReleaseEntry(releaseEntry);
var old = OldReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(new NuGetVersion(major, minor, patch, revision, prerelease, null), new NuGetVersion(old.Version.ToString()));
Assert.Equal(isDelta, old.IsDelta);
}
[Theory]
[InlineData("0900000000000000000000000000000000000000 MyCoolApp-1.2.3-beta1-win7-x64.nupkg 123", 1, 2, 3, 0, "beta1", "win7-x64", false)]
[InlineData("0010000000000000000000000000000000000000 MyCoolApp-1.2.3-beta1-win7-x64-full.nupkg 123", 1, 2, 3, 0, "beta1", "win7-x64", false)]
[InlineData("0020000000000000000000000000000000000000 MyCoolApp-1.2.3-beta1-win7-x64-delta.nupkg 123", 1, 2, 3, 0, "beta1", "win7-x64", true)]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-osx-full.nupkg 123", 1, 2, 3, 0, "", "osx", false)]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-osx-arm64-full.nupkg 123", 1, 2, 3, 0, "", "osx-arm64", false)]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-hello-osx-arm64-full.nupkg 123", 1, 2, 3, 0, "hello", "osx-arm64", false)]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-x86-full.nupkg 123", 1, 2, 3, 0, "", "x86", false)]
public void ParseVersionWithRidTest(string releaseEntry, int major, int minor, int patch, int revision, string prerelease, string rid, bool isDelta)
{
var fixture = ReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(new NuGetVersion(major, minor, patch, revision, prerelease, null), fixture.Version);
Assert.Equal(isDelta, fixture.IsDelta);
if (!String.IsNullOrEmpty(rid))
Assert.Equal(RID.Parse(rid), fixture.Rid);
var old = OldReleaseEntry.ParseReleaseEntry(releaseEntry);
var legacyPre = !String.IsNullOrEmpty(prerelease) && !String.IsNullOrEmpty(rid) ? $"{prerelease}-{rid}" : String.IsNullOrEmpty(prerelease) ? rid : prerelease;
Assert.Equal(new NuGetVersion(major, minor, patch, revision, legacyPre, null), new NuGetVersion(old.Version.ToString()));
Assert.Equal(isDelta, old.IsDelta);
}
[Theory]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-beta.22-win7-x64-full.nupkg 123", 1, 2, 3, 0, "beta.22", "win7-x64", false)]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-beta.22-x64-full.nupkg 123", 1, 2, 3, 0, "beta.22", "x64", false)]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-beta.22-win-full.nupkg 123", 1, 2, 3, 0, "beta.22", "win", false)]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-hello.55-osx-arm64-full.nupkg 123", 1, 2, 3, 0, "hello.55", "osx-arm64", false)]
[InlineData("0030000000000000000000000000000000000000 MyCoolApp-1.2.3-hello.55-full.nupkg 123", 1, 2, 3, 0, "hello.55", "", false)]
public void ParseVersionWithSemVer2(string releaseEntry, int major, int minor, int patch, int revision, string prerelease, string rid, bool isDelta)
{
var fixture = ReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(new NuGetVersion(major, minor, patch, revision, prerelease, null), fixture.Version);
Assert.Equal(isDelta, fixture.IsDelta);
if (!String.IsNullOrEmpty(rid))
Assert.Equal(RID.Parse(rid), fixture.Rid);
}
[Theory]
[InlineData("0000000000000000000000000000000000000000 MyCool-App-1.2.nupkg 123", "MyCool-App")]
[InlineData("0000000000000000000000000000000000000000 MyCool_App-1.2-full.nupkg 123", "MyCool_App")]
@@ -144,20 +213,20 @@ namespace Squirrel.Tests
public void CheckPackageName(string releaseEntry, string expected)
{
var fixture = ReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(expected, fixture.PackageName);
Assert.Equal(expected, fixture.PackageId);
var old = Legacy.ReleaseEntry.ParseReleaseEntry(releaseEntry);
var old = OldReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(expected, old.PackageName);
}
[Theory]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2.nupkg 123 # 10%", 1, 2, 0, 0, "", false, 0.1f)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-full.nupkg 123 # 90%", 1, 2, 0, 0, "", false, 0.9f)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-delta.nupkg 123", 1, 2, 0, 0, "", true, null)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-delta.nupkg 123 # 5%", 1, 2, 0, 0, "", true, 0.05f)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-win7-x64-delta.nupkg 123", 1, 2, 0, 0, "win7-x64", true, null)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-win7-x64-full.nupkg 123 # 5%", 1, 2, 0, 0, "win7-x64", false, 0.05f)]
public void ParseStagingPercentageTest(string releaseEntry, int major, int minor, int patch, int revision, string prerelease, bool isDelta, float? stagingPercentage)
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2.nupkg 123 # 10%", 1, 2, 0, 0, "", "", false, 0.1f)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-full.nupkg 123 # 90%", 1, 2, 0, 0, "", "", false, 0.9f)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-delta.nupkg 123", 1, 2, 0, 0, "", "", true, null)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-delta.nupkg 123 # 5%", 1, 2, 0, 0, "", "", true, 0.05f)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-win7-x64-delta.nupkg 123", 1, 2, 0, 0, "", "win7-x64", true, null)]
[InlineData("0000000000000000000000000000000000000000 MyCoolApp-1.2-win7-x64-full.nupkg 123 # 5%", 1, 2, 0, 0, "", "win7-x64", false, 0.05f)]
public void ParseStagingPercentageTest(string releaseEntry, int major, int minor, int patch, int revision, string prerelease, string rid, bool isDelta, float? stagingPercentage)
{
var fixture = ReleaseEntry.ParseReleaseEntry(releaseEntry);
@@ -170,8 +239,9 @@ namespace Squirrel.Tests
Assert.Null(fixture.StagingPercentage);
}
var old = Legacy.ReleaseEntry.ParseReleaseEntry(releaseEntry);
Assert.Equal(new NuGetVersion(major, minor, patch, revision, prerelease, null), new NuGetVersion(old.Version.ToString()));
var old = OldReleaseEntry.ParseReleaseEntry(releaseEntry);
var legacyPre = !String.IsNullOrEmpty(prerelease) && !String.IsNullOrEmpty(rid) ? $"{prerelease}-{rid}" : String.IsNullOrEmpty(prerelease) ? rid : prerelease;
Assert.Equal(new NuGetVersion(major, minor, patch, revision, legacyPre, null), new NuGetVersion(old.Version.ToString()));
Assert.Equal(isDelta, old.IsDelta);
if (stagingPercentage.HasValue) {
@@ -433,7 +503,7 @@ namespace Squirrel.Tests
var entries = ReleaseEntry.ParseReleaseFile(_ridReleaseEntries);
var e = Utility.FindLatestFullVersion(entries, RID.Parse("win-x86"));
Assert.Equal("MyApp-1.4-win-x86.nupkg", e.Filename);
Assert.Equal("MyApp-1.4-win-x86.nupkg", e.OriginalFilename);
}
[Fact]
@@ -450,7 +520,24 @@ namespace Squirrel.Tests
var entries = ReleaseEntry.ParseReleaseFile(_ridReleaseEntries);
var e = Utility.FindLatestFullVersion(entries, RID.Parse("win-x86"));
Assert.Equal("MyApp-1.3-win.nupkg", e.Filename);
Assert.Equal("MyApp-1.3-win.nupkg", e.OriginalFilename);
}
[Fact]
public void FindCurrentVersionWithExactRidMatchOnlyArchitecture()
{
string _ridReleaseEntries = """
0000000000000000000000000000000000000000 MyApp-1.3-win-x86.nupkg 123
0000000000000000000000000000000000000000 MyApp-1.4.nupkg 123
0000000000000000000000000000000000000000 MyApp-1.4-win-x64.nupkg 123
0000000000000000000000000000000000000000 MyApp-1.4-win.nupkg 123
0000000000000000000000000000000000000000 MyApp-1.4-osx-x86.nupkg 123
""";
var entries = ReleaseEntry.ParseReleaseFile(_ridReleaseEntries);
var e = Utility.FindLatestFullVersion(entries, RID.Parse("win-x86"));
Assert.Equal("MyApp-1.3-win.nupkg", e.OriginalFilename);
}
static string MockReleaseEntry(string name, float? percentage = null)

15
test/Squirrel.Tests/Squirrel.Tests.csproj
View File

@@ -3,25 +3,10 @@
<PropertyGroup>
<TargetFramework>net6.0-windows</TargetFramework>
<Description>Squirrel.Tests</Description>
<Title>Squirrel.Tests</Title>
<IsPackable>false</IsPackable>
<LangVersion>latest</LangVersion>
<IsTest>true</IsTest>
<NoWarn>CS1998,xUnit2015,xUnit2017,xUnit2005,xUnit2009,xUnit2013,xUnit2004</NoWarn>
<SignAssembly>True</SignAssembly>
<AssemblyOriginatorKeyFile>..\..\Squirrel.snk</AssemblyOriginatorKeyFile>
<NoWarn>$(NoWarn);CA2007</NoWarn>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
<PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
<PackageReference Include="xunit" Version="2.6.3" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.5.5" PrivateAssets="All" />
<PackageReference Include="System.IO.Packaging" Version="8.0.0" />
<PackageReference Include="Xunit.SkippableFact" Version="1.4.13" />
<PackageReference Include="Divergic.Logging.Xunit" Version="4.3.0" />
</ItemGroup>
<ItemGroup>