public static IUnitTestGeneratorOptions Create(string solutionFilePath, IGenerationOptions generationOptions, IVersioningOptions versioningOptions)
{
if (generationOptions == null)
{
throw new ArgumentNullException(nameof(generationOptions));
}
if (versioningOptions == null)
{
throw new ArgumentNullException(nameof(versioningOptions));
}
var mutableGenerationOptions = new MutableGenerationOptions(generationOptions);
var mutableVersioningOptions = new MutableVersioningOptions(versioningOptions);
if (!string.IsNullOrWhiteSpace(solutionFilePath))
{
var allFiles = new EditorConfigParser(".unitTestGeneratorConfig").GetConfigurationFilesTillRoot(solutionFilePath);
var allProperties = allFiles.SelectMany(x => x.Sections).SelectMany(x => x);
var properties = new Dictionary <string, string>();
foreach (var pair in allProperties)
{
properties[pair.Key] = pair.Value;
}
properties.ApplyTo(mutableGenerationOptions);
properties.ApplyTo(mutableVersioningOptions);
}
return(new UnitTestGeneratorOptions(mutableGenerationOptions, mutableVersioningOptions));
}
public GenerationItem(ProjectItemModel source, SyntaxNode sourceSymbol, ProjectItems targetProjectItems, string targetPath, HashSet <TargetAsset> requiredAssets, HashSet <IReferencedAssembly> assemblyReferences, Func <string, string> namespaceTransform, IGenerationOptions options)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
Source = source ?? throw new ArgumentNullException(nameof(source));
SourceSymbol = sourceSymbol;
TargetProjectItems = targetProjectItems;
_targetPath = targetPath;
RequiredAssets = requiredAssets ?? throw new ArgumentNullException(nameof(requiredAssets));
NamespaceTransform = namespaceTransform ?? throw new ArgumentNullException(nameof(namespaceTransform));
AssemblyReferences = assemblyReferences ?? throw new ArgumentNullException(nameof(assemblyReferences));
}
public MutableGenerationOptions(IGenerationOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
FrameworkType = options.FrameworkType;
MockingFrameworkType = options.MockingFrameworkType;
CreateProjectAutomatically = options.CreateProjectAutomatically;
AddReferencesAutomatically = options.AddReferencesAutomatically;
AllowGenerationWithoutTargetProject = options.AllowGenerationWithoutTargetProject;
TestProjectNaming = options.TestProjectNaming;
TestFileNaming = options.TestFileNaming;
TestTypeNaming = options.TestTypeNaming;
}
public static string GetTargetFileName(this IGenerationOptions options, string sourceFileName)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (string.IsNullOrWhiteSpace(sourceFileName))
{
throw new ArgumentNullException(nameof(sourceFileName));
}
try
{
return(string.Format(CultureInfo.CurrentCulture, options.TestFileNaming, sourceFileName));
}
catch (FormatException)
{
throw new InvalidOperationException(Strings.TargetNameTransform_GetTargetFileName_Cannot_not_derive_target_file_name__please_check_the_test_file_naming_setting_);
}
}
public ProjectItemModel(ProjectItem projectItem, IGenerationOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
ThreadHelper.ThrowIfNotOnUIThread();
Item = projectItem ?? throw new ArgumentNullException(nameof(projectItem));
FilePath = projectItem.FileNames[1];
TargetProjectName = options.GetTargetProjectName(Item.ContainingProject.Name);
SourceProjectName = Item.ContainingProject.Name;
try
{
TargetProjectName = string.Format(CultureInfo.CurrentCulture, options.TestProjectNaming, Item.ContainingProject.Name);
}
catch (FormatException)
{
throw new InvalidOperationException(Strings.ProjectItemModel_ProjectItemModel_Cannot_not_derive_target_project_name__please_check_the_test_project_naming_setting_);
}
}
public UnitTestGeneratorOptions(IGenerationOptions generationOptions, IVersioningOptions versioningOptions)
{
GenerationOptions = generationOptions ?? throw new ArgumentNullException(nameof(generationOptions));
VersioningOptions = versioningOptions ?? throw new ArgumentNullException(nameof(versioningOptions));
}
public static Project CreateTestProjectInCurrentSolution(DTE2 dte, Project sourceProject, IGenerationOptions options)
{
if (dte == null)
{
throw new ArgumentNullException(nameof(dte));
}
if (sourceProject == null)
{
throw new ArgumentNullException(nameof(sourceProject));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
ThreadHelper.ThrowIfNotOnUIThread();
// ReSharper disable once SuspiciousTypeConversion.Global
var solution = (Solution4)dte.Solution;
var testProjectName = options.GetTargetProjectName(sourceProject.Name);
var directoryName = Path.GetDirectoryName(solution.FileName);
if (string.IsNullOrWhiteSpace(directoryName))
{
throw new InvalidOperationException(Strings.SolutionUtilities_CreateTestProjectInCurrentSolution_Cannot_find_source_project_location);
}
var destination = Path.Combine(directoryName, testProjectName);
var templatePath = solution.GetProjectTemplate("ClassLibrary.zip", "CSharp");
var testProject = dte.Solution.AddFromTemplate(templatePath, destination, testProjectName);
foreach (var p in solution.Projects.OfType <Project>())
{
if (p.Name == testProjectName)
{
(p.Object as VSLangProj.VSProject)?.References.AddProject(sourceProject);
foreach (var projectItem in p.ProjectItems.OfType <ProjectItem>())
{
try
{
if (projectItem.FileCount > 0)
{
File.Delete(projectItem.FileNames[0]);
}
}
catch (IOException)
{
}
try
{
projectItem.Remove();
}
#pragma warning disable CA1031 // Do not catch general exception types
catch
#pragma warning restore CA1031 // Do not catch general exception types
{
// ignored - VS project system is extensible and we don't know exception types up-front
}
}
return(p);
}
}
return(testProject);
}
public static IEnumerable <ProjectItemModel> GetSelectedFiles(DTE2 dte, bool recursive, IGenerationOptions options)
{
if (dte == null)
{
throw new ArgumentNullException(nameof(dte));
}
ThreadHelper.ThrowIfNotOnUIThread();
if (dte.ToolWindows.SolutionExplorer.SelectedItems is Array selectedItems)
{
#pragma warning disable VSTHRD010
var selectedItemObjects = selectedItems.Cast <UIHierarchyItem>().Select(x => x.Object).ToList();
var items = selectedItemObjects.OfType <ProjectItem>().Concat(selectedItemObjects.OfType <Project>().Select(x => x.ProjectItems).SelectMany(x => x.OfType <ProjectItem>()));
#pragma warning restore VSTHRD010
return(GetSelectedFiles(items, recursive, options));
}
return(Enumerable.Empty <ProjectItemModel>());
}
private static IEnumerable <ProjectItemModel> GetSelectedFiles(IEnumerable <ProjectItem> items, bool recursive, IGenerationOptions options)
{
ThreadHelper.ThrowIfNotOnUIThread();
foreach (var item in items)
{
if (item.ProjectItems.Count > 0)
{
if (recursive)
{
foreach (var projectItemSummary in GetSelectedFiles(item.ProjectItems.OfType <ProjectItem>(), true, options))
{
yield return(projectItemSummary);
}
}
}
else
{
yield return(new ProjectItemModel(item, options));
}
}
}
public void SetUp()
{
_generationOptions = Substitute.For <IGenerationOptions>();
_versioningOptions = Substitute.For <IVersioningOptions>();
_testClass = new UnitTestGeneratorOptions(_generationOptions, _versioningOptions);
}
public static FindTargetStatus FindExistingTargetItem(ProjectItemModel source, IGenerationOptions options, out ProjectItem targetItem)
{
ThreadHelper.ThrowIfNotOnUIThread();
#pragma warning disable VSTHRD010
var nameParts = VsProjectHelper.GetNameParts(source.Item);
targetItem = null;
var targetProject = source.TargetProject;
if (targetProject == null)
{
return(FindTargetStatus.ProjectNotFound);
}
var targetProjectItems = FindTargetFolder(targetProject, nameParts, false, out _);
if (targetProjectItems == null)
{
return(FindTargetStatus.FolderNotFound);
}
var extension = Path.GetExtension(source.FilePath);
var baseName = Path.GetFileNameWithoutExtension(source.FilePath);
var testFileName = options.GetTargetFileName(baseName);
targetItem = targetProjectItems.OfType <ProjectItem>().FirstOrDefault(x => string.Equals(x.Name, testFileName + extension, StringComparison.OrdinalIgnoreCase));
return(targetItem == null ? FindTargetStatus.FileNotFound : FindTargetStatus.Found);
#pragma warning restore VSTHRD010
}
public void SetUp()
{
_options = Substitute.For <IGenerationOptions>();
_testClass = new MutableGenerationOptions(_options);
}
