public async Task GetProjectNugetPackages_ReturnsMultipleNugetPackages()
{
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\Project\Project.csproj"), Helpers.GetProjectFileWithPackageReferences(
new List <NugetPackage> {
new NugetPackage {
Name = "Package1", Version = "1.2.3"
},
new NugetPackage {
Name = "Package2", Version = "1.2.3"
},
new NugetPackage {
Name = "Package3", Version = "1.2.3"
},
}) },
});
var projectFileService = new ProjectFileService(mockFileSystem);
var packages = await projectFileService.GetProjectNugetPackagesAsync(XFS.Path(@"c:\Project\Project.csproj"));
var sortedPackages = new List <NugetPackage>(packages);
sortedPackages.Sort();
Assert.Collection(sortedPackages,
item => Assert.Equal("Package1", item.Name),
item => Assert.Equal("Package2", item.Name),
item => Assert.Equal("Package3", item.Name));
}
public async Task GetProjectNugetPackages_IgnoresImplicitPackageVersions()
{
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\Project\Project.csproj"), Helpers.GetProjectFileWithPackageReference("Package", "") },
});
var projectFileService = new ProjectFileService(mockFileSystem);
var packages = await projectFileService.GetProjectNugetPackagesAsync(XFS.Path(@"c:\Project\Project.csproj"));
Assert.Empty(packages);
}
public async Task GetProjectNugetPackages_WithPackagesConfig_ReturnsMultipleNugetPackages()
{
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\Project\Project.csproj"), "" },
{ XFS.Path(@"c:\Project\packages.config"), "" },
});
var mockDotnetUtilsService = new Mock <IDotnetUtilsService>();
mockDotnetUtilsService
.Setup(s => s.Restore(It.IsAny <string>()))
.Returns(new DotnetUtilsResult());
var mockPackageFileService = new Mock <IPackagesFileService>();
mockPackageFileService
.Setup(s => s.GetNugetPackagesAsync(It.IsAny <string>()))
.ReturnsAsync(
new HashSet <NugetPackage>
{
new NugetPackage {
Name = "Package1", Version = "1.2.3"
},
new NugetPackage {
Name = "Package2", Version = "1.2.3"
},
new NugetPackage {
Name = "Package3", Version = "1.2.3"
},
}
);
var mockProjectAssetsFileService = new Mock <IProjectAssetsFileService>();
mockProjectAssetsFileService
.Setup(s => s.GetNugetPackages(It.IsAny <string>()))
.Returns(new HashSet <NugetPackage>());
var projectFileService = new ProjectFileService(
mockFileSystem,
mockDotnetUtilsService.Object,
mockPackageFileService.Object,
mockProjectAssetsFileService.Object);
var packages = await projectFileService.GetProjectNugetPackagesAsync(XFS.Path(@"c:\Project\Project.csproj")).ConfigureAwait(false);
var sortedPackages = new List <NugetPackage>(packages);
sortedPackages.Sort();
Assert.Collection(sortedPackages,
item => Assert.Equal("Package1", item.Name),
item => Assert.Equal("Package2", item.Name),
item => Assert.Equal("Package3", item.Name));
}
public async Task GetProjectNugetPackages_ReturnsNugetPackage()
{
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\Project\Project.csproj"), Helpers.GetProjectFileWithPackageReference("Package", "1.2.3") },
});
var projectFileService = new ProjectFileService(mockFileSystem);
var packages = await projectFileService.GetProjectNugetPackagesAsync(XFS.Path(@"c:\Project\Project.csproj"));
Assert.Collection(packages,
item => {
Assert.Equal("Package", item.Name);
Assert.Equal("1.2.3", item.Version);
});
}
public async Task GetProjectNugetPackages_WithProjectAssetsFileWithoutRestore_ReturnsNugetPackage()
{
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\Project\Project.csproj"), "" },
{ XFS.Path(@"c:\Project\obj\project.assets.json"), "" },
});
var mockDotnetUtilsService = new Mock <IDotnetUtilsService>();
mockDotnetUtilsService
.Setup(s => s.Restore(It.IsAny <string>()))
.Throws(new ApplicationException("Restore should not be called"));
var mockPackageFileService = new Mock <IPackagesFileService>();
var mockProjectAssetsFileService = new Mock <IProjectAssetsFileService>();
mockProjectAssetsFileService
.Setup(s => s.GetNugetPackages(It.IsAny <string>(), It.IsAny <bool>()))
.Returns(new HashSet <NugetPackage>
{
new NugetPackage {
Name = "Package", Version = "1.2.3"
},
});
var projectFileService = new ProjectFileService(
mockFileSystem,
mockDotnetUtilsService.Object,
mockPackageFileService.Object,
mockProjectAssetsFileService.Object);
projectFileService.DisablePackageRestore = true;
var packages = await projectFileService.GetProjectNugetPackagesAsync(XFS.Path(@"c:\Project\Project.csproj"), "", false).ConfigureAwait(false);
Assert.Collection(packages,
item => {
Assert.Equal("Package", item.Name);
Assert.Equal("1.2.3", item.Version);
});
}
async Task <int> OnExecute()
{
Console.WriteLine();
// check parameter values
if (string.IsNullOrEmpty(SolutionOrProjectFile))
{
Console.Error.WriteLine($"A path is required");
return((int)ExitCode.SolutionOrProjectFileParameterMissing);
}
if (string.IsNullOrEmpty(outputDirectory))
{
Console.Error.WriteLine($"The output directory is required");
return((int)ExitCode.OutputDirectoryParameterMissing);
}
if (string.IsNullOrEmpty(githubUsername) ^ string.IsNullOrEmpty(githubToken))
{
Console.Error.WriteLine($"Both GitHub username and token are required");
return((int)ExitCode.GitHubParameterMissing);
}
// instantiate services
var fileDiscoveryService = new FileDiscoveryService(Program.fileSystem);
// GitHubService requires its own HttpClient as it adds a default authorization header
GithubService githubService;
if (string.IsNullOrEmpty(githubUsername) || string.IsNullOrEmpty(githubToken))
{
githubService = new GithubService(new HttpClient());
}
else
{
githubService = new GithubService(new HttpClient(), githubUsername, githubToken);
}
var nugetService = new NugetService(Program.httpClient, githubService, baseUrl);
var packagesFileService = new PackagesFileService(Program.fileSystem);
var projectFileService = new ProjectFileService(Program.fileSystem);
var solutionFileService = new SolutionFileService(Program.fileSystem);
var packages = new HashSet <NugetPackage>();
// determine what we are analyzing and do the analysis
var fullSolutionOrProjectFilePath = Program.fileSystem.Path.GetFullPath(SolutionOrProjectFile);
var attr = Program.fileSystem.File.GetAttributes(fullSolutionOrProjectFilePath);
if (SolutionOrProjectFile.ToLowerInvariant().EndsWith(".sln", StringComparison.OrdinalIgnoreCase))
{
packages = await solutionFileService.GetSolutionNugetPackages(fullSolutionOrProjectFilePath);
}
else if (Utils.IsSupportedProjectType(SolutionOrProjectFile) && scanProjectReferences)
{
packages = await projectFileService.RecursivelyGetProjectNugetPackagesAsync(fullSolutionOrProjectFilePath);
}
else if (Utils.IsSupportedProjectType(SolutionOrProjectFile))
{
packages = await projectFileService.GetProjectNugetPackagesAsync(fullSolutionOrProjectFilePath);
}
else if (Program.fileSystem.Path.GetFileName(SolutionOrProjectFile).ToLowerInvariant().Equals("packages.config", StringComparison.OrdinalIgnoreCase))
{
packages = await packagesFileService.GetNugetPackagesAsync(fullSolutionOrProjectFilePath);
}
else if (attr.HasFlag(FileAttributes.Directory))
{
packages = await packagesFileService.RecursivelyGetNugetPackagesAsync(fullSolutionOrProjectFilePath);
}
else
{
Console.Error.WriteLine($"Only .sln, .csproj, .vbproj, and packages.config files are supported");
return((int)ExitCode.InvalidOptions);
}
// get all the components from the NuGet packages
var components = new HashSet <Component>();
try
{
foreach (var package in packages)
{
var component = await nugetService.GetComponentAsync(package);
if (component != null)
{
components.Add(component);
}
}
}
catch (InvalidGitHubApiCredentialsException)
{
return((int)ExitCode.InvalidGitHubApiCredentials);
}
catch (GitHubApiRateLimitExceededException)
{
return((int)ExitCode.GitHubApiRateLimitExceeded);
}
// create the BOM
Console.WriteLine();
Console.WriteLine("Creating CycloneDX BoM");
var bomXml = BomService.CreateXmlDocument(components, noSerialNumber);
// check if the output directory exists and create it if needed
var bomPath = Program.fileSystem.Path.GetFullPath(outputDirectory);
if (!Program.fileSystem.Directory.Exists(bomPath))
{
Program.fileSystem.Directory.CreateDirectory(bomPath);
}
// write the BOM to disk
var bomFile = Program.fileSystem.Path.Combine(bomPath, "bom.xml");
Console.WriteLine("Writing to: " + bomFile);
using (var fileStream = Program.fileSystem.FileStream.Create(bomFile, FileMode.Create))
using (var writer = new StreamWriter(fileStream, new UTF8Encoding(false))) {
bomXml.Save(writer);
}
return(0);
}
