public async Task RecursivelyGetProjectReferences_ReturnsProjectReferences()
{
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\SolutionPath\Project1\Project1.csproj"), Helpers.GetProjectFileWithProjectReferences(
new string[] {
@"..\Project2\Project2.csproj",
}) },
{ XFS.Path(@"c:\SolutionPath\Project2\Project2.csproj"), Helpers.GetProjectFileWithProjectReferences(
new string[] {
@"..\Project3\Project3.csproj",
}) },
{ XFS.Path(@"c:\SolutionPath\Project3\Project3.csproj"), new MockFileData(@"<Project></Project>") },
});
var mockDotnetUtilsService = new Mock <IDotnetUtilsService>();
var mockPackageFileService = new Mock <IPackagesFileService>();
var mockProjectAssetsFileService = new Mock <IProjectAssetsFileService>();
var projectFileService = new ProjectFileService(
mockFileSystem,
mockDotnetUtilsService.Object,
mockPackageFileService.Object,
mockProjectAssetsFileService.Object);
var projects = await projectFileService.RecursivelyGetProjectReferencesAsync(XFS.Path(@"c:\SolutionPath\Project1\Project1.csproj")).ConfigureAwait(false);
var sortedProjects = new List <string>(projects);
sortedProjects.Sort();
Assert.Collection(sortedProjects,
item => Assert.Equal(XFS.Path(@"c:\SolutionPath\Project2\Project2.csproj"), item),
item => Assert.Equal(XFS.Path(@"c:\SolutionPath\Project3\Project3.csproj"), item));
}
public StudioViewsEditorViewModel(EditorController editorController,
FilterItemService filterItemService, ProjectService projectService, ProjectFileService projectFileService,
SdlxliffMerger sdlxliffMerger, SdlxliffExporter sdlxliffExporter, SdlxliffReader sdlxliffReader)
{
_filterItemService = filterItemService;
_projectService = projectService;
_projectFileService = projectFileService;
_sdlxliffMerger = sdlxliffMerger;
_sdlxliffExporter = sdlxliffExporter;
_sdlxliffReader = sdlxliffReader;
_editorController = editorController;
_editorController.ActiveDocumentChanged += EditorController_ActiveDocumentChanged;
ActivateDocument(_editorController.ActiveDocument);
// Default values
ExportSelectedSegments = true;
FilterItems = new List <FilterItem>(_filterItemService.GetFilterItems());
SelectedExcludeFilterItems = new ObservableCollection <FilterItem>(
_filterItemService.GetFilterItems(FilterItems, new List <string> {
"Locked"
}));
SelectedTabItem = 0;
}
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));
}
private void Run(IReadOnlyCollection <SystemFileInfo> importFiles, Language language)
{
var projectHelper = new ProjectService(_projectsController, _studioVersionService);
var analysisBands = projectHelper.GetAnalysisBands(_projectsController.CurrentProject ?? _projectsController.SelectedProjects.FirstOrDefault());
var filterItemService = new FilterItemService(analysisBands);
var commonService = new ProjectFileService();
var segmentVisitor = new SegmentVisitor();
var segmentBuilder = new SegmentBuilder();
var paragraphUnitProvider = new ParagraphUnitProvider(segmentVisitor, filterItemService, segmentBuilder);
var sdlxliffImporter = new SdlxliffImporter(commonService, filterItemService, paragraphUnitProvider, segmentBuilder);
var sdlXliffReader = new SdlxliffReader();
_window = new StudioViewsFilesImportView();
var model = new StudioViewsFilesImportViewModel(_window, _filesController, language, commonService, filterItemService, sdlxliffImporter, sdlXliffReader);
_window.DataContext = model;
if (importFiles != null)
{
model.AddFiles(importFiles);
}
_window.ShowDialog();
if (model.DialogResult != DialogResult.OK)
{
return;
}
OpenMessageWindow(model);
}
protected override void Initialize()
{
_editorController = SdlTradosStudio.Application.GetController <EditorController>();
_projectsController = SdlTradosStudio.Application.GetController <ProjectsController>();
_studioVersionService = new StudioVersionService();
var commonService = new ProjectFileService();
var projectHelper = new ProjectService(_projectsController, _studioVersionService);
var analysisBands = projectHelper.GetAnalysisBands(_projectsController.CurrentProject ?? _projectsController.SelectedProjects.FirstOrDefault());
var filterItemService = new FilterItemService(analysisBands);
var sdlxliffMerger = new SdlxliffMerger();
var segmentBuilder = new SegmentBuilder();
var segmentVisitor = new SegmentVisitor();
var paragraphUnitProvider = new ParagraphUnitProvider(segmentVisitor, filterItemService);
var sdlxliffExporter = new SdlxliffExporter(segmentBuilder);
var sdlXliffReader = new SdlxliffReader();
var displayFilter = new DisplayFilter();
var model = new StudioViewsEditorViewModel(_editorController, filterItemService,
commonService, sdlxliffMerger, sdlxliffExporter, sdlXliffReader, paragraphUnitProvider, displayFilter);
_control = new StudioViewsEditorView {
DataContext = model
};
}
public void TestInitialize()
{
_directoryServiceMoq = new Mock <IDirectoryService>();
_directoryServiceMoq.Setup(m => m.Exists(It.IsAny <string>())).Returns(false);
_directoryServiceMoq.Setup(m => m.GetCurrentDirectory()).Returns("testDirectory");
_projectFileService = new ProjectFileService(_directoryServiceMoq.Object);
_projectFileService.ProjectDirectory = Directory;
}
static void Execute(string basePath, SearchQueryFilter filter, string?setVersion, string outputFile,
string outputFileFormatStr)
{
var tools = new ProjectNugetVersionUpdater(new DotNetPackageReferenceUpdater());
var projFileService = new ProjectFileService();
OutputFileFormat outputFormat = !string.IsNullOrEmpty(outputFileFormatStr) ?
Enum.Parse <OutputFileFormat>(outputFileFormatStr, true)
: OutputFileFormat.Default;
IProjectFileResultsRenderer projectFileRenderer;
basePath = Path.GetFullPath(basePath);
var projFiles = projFileService.GetProjectFilesByFilter(basePath, filter);
if (!string.IsNullOrEmpty(outputFile))
{
var outputFilePath = Path.GetFullPath(outputFile);
Console.Write($"Writing output to {outputFilePath}");
if (!string.IsNullOrEmpty(outputFileFormatStr))
{
Console.Write($" format: {outputFileFormatStr}");
}
Console.WriteLine();
// no format so just redirect
FileOutput.RedirectConsoleToFile(outputFilePath);
}
switch (outputFormat)
{
case OutputFileFormat.Json:
projectFileRenderer = new ProjectFileJsonRenderer();
break;
default:
projectFileRenderer = new ProjectFileConsoleRenderer();
break;
}
projectFileRenderer.RenderResults(basePath, filter, projFiles);
if (!string.IsNullOrEmpty(setVersion))
{
var startTabPad = 10;
var strPad = new string(' ', startTabPad);
if (projFileService.SetNugetPackageVersions(filter, setVersion, projFiles, strPad, tools))
{
return;
}
}
}
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 StudioViewsFilesSplitViewModel(Window window, List <ProjectFile> selectedFiles, ProjectFileService projectFileService,
SdlxliffMerger sdlxliffMerger, SdlxliffExporter sdlxliffExporter, SdlxliffReader sdlxliffReader)
{
_window = window;
_selectedFiles = selectedFiles;
_projectFileService = projectFileService;
_sdlxliffMerger = sdlxliffMerger;
_sdlxliffExporter = sdlxliffExporter;
_sdlxliffReader = sdlxliffReader;
WindowTitle = PluginResources.StudioViews_SplitSelectedFiles_Name;
DialogResult = DialogResult.None;
Reset(null);
}
public StudioViewsFilesImportViewModel(Window window, List <ProjectFile> selectedProjectFiles, ProjectFileService projectFileService,
FilterItemService filterItemService, SdlxliffImporter sdlxliffImporter, SdlxliffReader sdlxliffReader)
{
_window = window;
_filterItemService = filterItemService;
_selectedProjectFiles = selectedProjectFiles;
_sdlxliffImporter = sdlxliffImporter;
_sdlxliffReader = sdlxliffReader;
_projectFileService = projectFileService;
WindowTitle = PluginResources.WindowTitle_Import;
DialogResult = DialogResult.None;
Reset(null);
}
public StudioViewsFilesImportViewModel(Window window, FilesController filesController, Language language, ProjectFileService projectFileService,
FilterItemService filterItemService, SdlxliffImporter sdlxliffImporter, SdlxliffReader sdlxliffReader)
{
_window = window;
_filterItemService = filterItemService;
_filesController = filesController;
_language = language;
_sdlxliffImporter = sdlxliffImporter;
_sdlxliffReader = sdlxliffReader;
_projectFileService = projectFileService;
WindowTitle = PluginResources.WindowTitle_Import;
DialogResult = DialogResult.None;
Reset(null);
}
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);
});
}
protected override void Execute()
{
var selectedFiles = _filesController.SelectedFiles.Where(projectFile => projectFile.Role == FileRole.Translatable).ToList();
if (selectedFiles.Count == 0)
{
MessageBox.Show(PluginResources.Message_No_files_selected, PluginResources.Plugin_Name, MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
var missingFiles = selectedFiles.Any(file => file.LocalFileState == LocalFileState.Missing);
if (missingFiles)
{
MessageBox.Show(PluginResources.Message_Missing_Project_Files_Download_From_Server, PluginResources.Plugin_Name, MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
var project = _projectsController.CurrentProject ?? _projectsController.SelectedProjects.FirstOrDefault();
var projectFileService = new ProjectFileService();
var sdlxliffMerger = new SdlxliffMerger();
var segmentBuilder = new SegmentBuilder();
var sdlxliffExporter = new SdlxliffExporter(segmentBuilder);
var sdlXliffReader = new SdlxliffReader();
var projectHelper = new ProjectService(_projectsController, _studioVersionService);
var analysisBands = projectHelper.GetAnalysisBands(_projectsController.CurrentProject ?? _projectsController.SelectedProjects.FirstOrDefault());
var filterItemService = new FilterItemService(analysisBands);
_window = new StudioViewsFilesSplitView();
var model = new StudioViewsFilesSplitViewModel(_window, project, selectedFiles, projectFileService, filterItemService,
sdlxliffMerger, sdlxliffExporter, sdlXliffReader);
_window.DataContext = model;
_window.ShowDialog();
if (model.DialogResult != DialogResult.OK)
{
return;
}
OpenMessageWindow(model);
}
protected override void Initialize()
{
_editorController = SdlTradosStudio.Application.GetController <EditorController>();
_projectsController = SdlTradosStudio.Application.GetController <ProjectsController>();
var commonService = new ProjectFileService();
var filterItemHelper = new FilterItemService();
var projectHelper = new ProjectService(_projectsController);
var sdlxliffMerger = new SdlxliffMerger();
var sdlxliffExporter = new SdlxliffExporter();
var sdlXliffReader = new SdlxliffReader();
var model = new StudioViewsEditorViewModel(_editorController, filterItemHelper, projectHelper,
commonService, sdlxliffMerger, sdlxliffExporter, sdlXliffReader);
_control = new StudioViewsEditorView {
DataContext = model
};
}
public void TestInitialize()
{
_projectMoq = new Mock <ProjectModel>();
_dialogServiceMoq = new Mock <IDialogService>();
_projectLoadSaveMoq = new Mock <IProjectLoadSave>();
_testDialogMoq = new Mock <IFileDialog>();
_testDialogMoq.Setup(d => d.ShowDialog()).Returns(MessageBoxResult.Cancel);
_testDialogMoq.SetupAllProperties();
_directoryServiceMoq = new Mock <IDirectoryService>();
_directoryServiceMoq.Setup(m => m.Exists(It.IsAny <string>())).Returns(false);
_directoryServiceMoq.Setup(m => m.GetCurrentDirectory()).Returns("testDirectory");
_projectFileService = new ProjectFileService(
_directoryServiceMoq.Object,
_testDialogMoq.Object,
_testDialogMoq.Object,
_projectLoadSaveMoq.Object,
_dialogServiceMoq.Object)
{
ProjectDirectory = Directory
};
}
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);
});
}
protected override void Execute()
{
var selectedFiles = _filesController.SelectedFiles.Where(projectFile => projectFile.Role == FileRole.Translatable).ToList();
if (selectedFiles.Count == 0)
{
MessageBox.Show(PluginResources.Message_No_files_selected, PluginResources.Plugin_Name, MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
var missingFiles = selectedFiles.Any(file => file.LocalFileState == LocalFileState.Missing);
if (missingFiles)
{
MessageBox.Show(PluginResources.Message_Missing_Project_Files_Download_From_Server, PluginResources.Plugin_Name, MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
var commonService = new ProjectFileService();
var sdlxliffMerger = new SdlxliffMerger();
var segmentBuilder = new SegmentBuilder();
var sdlxliffExporter = new SdlxliffExporter(segmentBuilder);
var sdlXliffReader = new SdlxliffReader();
_window = new StudioViewsFilesSplitView();
var model = new StudioViewsFilesSplitViewModel(_window, selectedFiles, commonService,
sdlxliffMerger, sdlxliffExporter, sdlXliffReader);
_window.DataContext = model;
_window.ShowDialog();
if (model.DialogResult != DialogResult.OK)
{
return;
}
OpenMessageWindow(model);
}
public async Task GetProjectReferences_ReturnsProjectReferences()
{
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\SolutionPath\Project\Project.csproj"), Helpers.GetProjectFileWithProjectReferences(
new string[] {
@"..\Project1\Project1.csproj",
@"..\Project2\Project2.csproj",
@"..\Project3\Project3.csproj",
}) },
});
var projectFileService = new ProjectFileService(mockFileSystem);
var projects = await projectFileService.GetProjectReferencesAsync(XFS.Path(@"c:\SolutionPath\Project\Project.csproj"));
var sortedProjects = new List <string>(projects);
sortedProjects.Sort();
Assert.Collection(sortedProjects,
item => Assert.Equal(XFS.Path(@"c:\SolutionPath\Project1\Project1.csproj"), item),
item => Assert.Equal(XFS.Path(@"c:\SolutionPath\Project2\Project2.csproj"), item),
item => Assert.Equal(XFS.Path(@"c:\SolutionPath\Project3\Project3.csproj"), item));
}
public void GetPropertyUseProjectFileName(string projectFilePath, string baseIntermediateOutputPath, string expected)
{
string outputPath = ProjectFileService.GetProjectProperty(XFS.Path(projectFilePath), XFS.Path(baseIntermediateOutputPath));
Assert.Equal(XFS.Path(expected), outputPath);
}
public void Initialize()
{
var mockDb = new MockDataContext();
#region Initialize files.
var f1 = new ProjectFile
{
ID = 1,
_projectID = 2,
_projectFileName = "TestFile_01",
_projectFileData = "...lorem ipsum...",
_projectFileType = ".css",
_aceExtension = "css"
};
mockDb._projectFiles.Add(f1);
var f2 = new ProjectFile
{
ID = 2,
_projectID = 2,
_projectFileName = "TestFile_02",
_projectFileData = "...lorem ipsum...",
_projectFileType = ".css",
_aceExtension = "css"
};
mockDb._projectFiles.Add(f2);
var f3 = new ProjectFile
{
ID = 3,
_projectID = 3,
_projectFileName = "TestFile_03",
_projectFileData = "...lorem ipsum...",
_projectFileType = ".cs",
_aceExtension = "csharp"
};
mockDb._projectFiles.Add(f3);
var f4 = new ProjectFile
{
ID = 4,
_projectID = 3,
_projectFileName = "TestFile_04",
_projectFileData = "...lorem ipsum...",
_projectFileType = ".cs",
_aceExtension = "csharp"
};
mockDb._projectFiles.Add(f4);
#endregion
#region Initialize Projects.
var p1 = new Project
{
ID = 1,
_projectFileTypeId = 1,
_projectName = "TestProject_01"
};
mockDb._projects.Add(p1);
var p2 = new Project
{
ID = 2,
_projectFileTypeId = 2,
_projectName = "TestProject_02"
};
mockDb._projects.Add(p2);
var p3 = new Project
{
ID = 3,
_projectFileTypeId = 3,
_projectName = "TestProject_03"
};
mockDb._projects.Add(p1);
#endregion
_service = new ProjectFileService(mockDb);
}
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);
}
public async Task RecursivelyGetProjectNugetPackages_ReturnsNugetPackages()
{
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\SolutionPath\Project1\Project1.csproj"), Helpers.GetProjectFileWithReferences(
new string[] {
@"..\Project2\Project2.csproj",
@"..\Project3\Project3.csproj",
},
new 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"
},
}) },
{ XFS.Path(@"c:\SolutionPath\Project2\Project2.csproj"), Helpers.GetProjectFileWithReferences(
new string[] {
@"..\Project3\Project3.csproj",
},
new NugetPackage[] {
new NugetPackage {
Name = "Package1", Version = "1.2.4"
},
}) },
{ XFS.Path(@"c:\SolutionPath\Project3\Project3.csproj"), Helpers.GetProjectFileWithReferences(
null,
new NugetPackage[] {
new NugetPackage {
Name = "Package1", Version = "1.2.3"
},
}) },
});
var projectFileService = new ProjectFileService(mockFileSystem);
var packages = await projectFileService.RecursivelyGetProjectNugetPackagesAsync(XFS.Path(@"c:\SolutionPath\Project1\Project1.csproj"));
var sortedPackages = new List <NugetPackage>(packages);
sortedPackages.Sort();
Assert.Collection(sortedPackages,
item => {
Assert.Equal("Package1", item.Name);
Assert.Equal("1.2.3", item.Version);
},
item => {
Assert.Equal("Package1", item.Name);
Assert.Equal("1.2.4", item.Version);
},
item => {
Assert.Equal("Package2", item.Name);
Assert.Equal("1.2.3", item.Version);
},
item => {
Assert.Equal("Package3", item.Name);
Assert.Equal("1.2.3", item.Version);
}
);
}
public ProjectFileServiceTests(ITestOutputHelper outputHelper) : base(outputHelper)
{
_projectFileService = new ProjectFileService();
}
public void IsTestProjectFalse()
{
string szProjectPath = System.Environment.CurrentDirectory + XFS.Path(@"\..\..\..\..\CycloneDX\CycloneDX.csproj");
Assert.False(ProjectFileService.IsTestProject(szProjectPath));
}
