public void FindBestVersionMatch_MissingVersionRange()
{
// Arrange
var target = GetToolsService();
var inputVersions = new[] { "1.0.0" };
var input = new FindBestVersionMatchInput
{
VersionRange = null,
Versions = string.Join("\n", inputVersions)
};
// Act
var output = target.FindBestVersionMatch(input);
// Assert
Assert.Same(input, output.Input);
Assert.Equal(InputStatus.Missing, output.InputStatus);
Assert.Empty(output.Invalid);
Assert.False(output.IsVersionRangeValid);
Assert.True(output.IsVersionValid);
Assert.Null(output.VersionRange);
Assert.Equal(1, output.Versions.Count);
var outputVersion = output.Versions.First();
Assert.Equal(inputVersions[0], outputVersion.Input);
Assert.Equal(GetVersionNormalizedString(inputVersions[0]), outputVersion.Version.NormalizedString);
Assert.False(outputVersion.Satisfies);
Assert.Null(output.BestMatch);
}
public void FindBestVersionMatch_Invalid()
{
// Arrange
var target = GetToolsService();
var inputVersions = new[] { "a", "b" };
var input = new FindBestVersionMatchInput
{
VersionRange = "[1.0.0, )",
Versions = string.Join("\n", inputVersions)
};
// Act
var output = target.FindBestVersionMatch(input);
// Assert
Assert.Same(input, output.Input);
Assert.Equal(InputStatus.Invalid, output.InputStatus);
Assert.Equal(2, output.Invalid.Count);
Assert.Equal(inputVersions[0], output.Invalid[0]);
Assert.Equal(inputVersions[1], output.Invalid[1]);
Assert.True(output.IsVersionRangeValid);
Assert.False(output.IsVersionValid);
Assert.Equal(GetVersionRangeNormalizedString(input.VersionRange), output.VersionRange.NormalizedString);
Assert.Equal(0, output.Versions.Count);
Assert.Null(output.BestMatch);
}
public void FindBestVersionMatch_Mixed()
{
// Arrange
var target = GetToolsService();
var inputVersions = new[] { "1.1.0", "1.2.0", "0.9.0", "a" };
var input = new FindBestVersionMatchInput
{
VersionRange = "[1.0.0, 2.0.0]",
Versions = string.Join("\n", inputVersions)
};
// Act
var output = target.FindBestVersionMatch(input);
// Assert
Assert.Same(input, output.Input);
Assert.Equal(InputStatus.Valid, output.InputStatus);
Assert.Equal(1, output.Invalid.Count);
Assert.Equal(inputVersions[3], output.Invalid[0]);
Assert.True(output.IsVersionRangeValid);
Assert.True(output.IsVersionValid);
Assert.Equal(GetVersionRangeNormalizedString(input.VersionRange), output.VersionRange.NormalizedString);
Assert.Equal(3, output.Versions.Count);
var outputVersionA = output.Versions.ElementAt(0);
Assert.Equal(inputVersions[0], outputVersionA.Input);
Assert.Equal(GetVersionNormalizedString(inputVersions[0]), outputVersionA.Version.NormalizedString);
Assert.True(outputVersionA.Satisfies);
var outputVersionB = output.Versions.ElementAt(1);
Assert.Equal(inputVersions[1], outputVersionB.Input);
Assert.Equal(GetVersionNormalizedString(inputVersions[1]), outputVersionB.Version.NormalizedString);
Assert.True(outputVersionB.Satisfies);
var outputVersionC = output.Versions.ElementAt(2);
Assert.Equal(inputVersions[2], outputVersionC.Input);
Assert.Equal(GetVersionNormalizedString(inputVersions[2]), outputVersionC.Version.NormalizedString);
Assert.False(outputVersionC.Satisfies);
Assert.Same(outputVersionA, output.BestMatch);
}
public void FindBestVersionMatch_NullInput()
{
// Arrange
var target = GetToolsService();
FindBestVersionMatchInput input = null;
// Act
var output = target.FindBestVersionMatch(input);
// Assert
Assert.Same(input, output.Input);
Assert.Equal(InputStatus.Missing, output.InputStatus);
Assert.Empty(output.Invalid);
Assert.False(output.IsVersionRangeValid);
Assert.False(output.IsVersionValid);
Assert.Null(output.VersionRange);
Assert.Empty(output.Versions);
Assert.Null(output.BestMatch);
}
public void FindBestVersionMatch_MissingVersions()
{
// Arrange
var target = GetToolsService();
var input = new FindBestVersionMatchInput
{
VersionRange = "[1.0.0, )",
Versions = null
};
// Act
var output = target.FindBestVersionMatch(input);
// Assert
Assert.Same(input, output.Input);
Assert.Equal(InputStatus.Missing, output.InputStatus);
Assert.Empty(output.Invalid);
Assert.True(output.IsVersionRangeValid);
Assert.False(output.IsVersionValid);
Assert.Equal(GetVersionRangeNormalizedString(input.VersionRange), output.VersionRange.NormalizedString);
Assert.Empty(output.Versions);
Assert.Null(output.BestMatch);
}
public async Task <IActionResult> FindBestVersionMatch([FromRoute] string nuGetVersion, [FromQuery] FindBestVersionMatchInput input, CancellationToken token)
{
var redirect = GetVersionRedirect();
if (redirect != null)
{
return(redirect);
}
var toolsService = await _toolsFactory.GetServiceAsync(nuGetVersion, token);
if (toolsService == null)
{
return(NotFound());
}
var output = toolsService.FindBestVersionMatch(input);
var versionedOutput = await GetSelectedVersionOutputAsync(toolsService, output, token);
return(View(versionedOutput));
}
public FindBestVersionMatchOutput FindBestVersionMatch(FindBestVersionMatchInput input)
{
var outputVersions = new List <OutputVersion>();
var invalid = new List <string>();
var output = new FindBestVersionMatchOutput
{
InputStatus = InputStatus.Missing,
Versions = outputVersions,
Invalid = invalid,
Input = input,
IsOperationSupported = _versionRangeLogic.FindBestMatchAvailable,
};
if (input == null)
{
return(output);
}
var versionRangeMissing = string.IsNullOrWhiteSpace(input.VersionRange);
var versionsMissing = string.IsNullOrWhiteSpace(input.Versions);
var versionRange = default(TVersionRange);
if (!versionRangeMissing)
{
try
{
versionRange = _versionRangeLogic.Parse(input.VersionRange);
output.VersionRange = versionRange;
output.IsVersionRangeValid = true;
}
catch (Exception)
{
output.IsVersionRangeValid = false;
}
}
if (!versionsMissing)
{
using (var reader = new StringReader(input.Versions))
{
string line;
while ((line = reader.ReadLine()) != null)
{
line = line.Trim();
if (string.IsNullOrEmpty(line))
{
continue;
}
try
{
var version = _versionLogic.Parse(line);
var pair = new OutputVersion
{
Input = line,
Version = version
};
if (output.VersionRange != null)
{
pair.Satisfies = _versionRangeLogic.Satisfies(versionRange, version);
}
outputVersions.Add(pair);
}
catch (Exception)
{
invalid.Add(line);
}
}
}
output.IsVersionValid = output.Versions.Any();
}
if (!versionRangeMissing && !versionsMissing)
{
if (output.IsVersionRangeValid && output.IsVersionValid)
{
output.InputStatus = InputStatus.Valid;
if (output.IsOperationSupported)
{
var versions = output.Versions.Select(x => (TVersion)x.Version).ToArray();
var bestMatch = _versionRangeLogic.FindBestMatch(versionRange, versions);
if (bestMatch != null)
{
output.BestMatch = output.Versions.First(x => x.Version.Equals(bestMatch));
}
}
}
else
{
output.InputStatus = InputStatus.Invalid;
}
}
return(output);
}
