private static MethodArgumentDescriptor[] GetArgumentDescriptors(List <ParameterSyntax> argumentList, SemanticModel semanticModel, MockFramework mockFramework)
{
MethodArgumentDescriptor[] argumentDescriptors = new MethodArgumentDescriptor[argumentList.Count()];
for (int i = 0; i < argumentDescriptors.Count(); i++)
{
string argumentName = argumentList[i].Identifier.Text;
ParameterModifier modifier = GetArgumentModifier(argumentList[i]);
var namedTypeSymbol = InjectableType.TryCreateInjectableTypeFromParameterNode(argumentList[i], semanticModel, mockFramework);
if (namedTypeSymbol != null)
{
argumentDescriptors[i] = new MethodArgumentDescriptor(namedTypeSymbol, argumentName, modifier);
continue;
}
var argumentType = argumentList[i].Type;
string typeName = argumentType.ToString();
argumentDescriptors[i] = new MethodArgumentDescriptor(new TypeDescriptor(typeName, null), argumentName, modifier);
}
return(argumentDescriptors);
}
private async Task <TestGenerationContext> CollectTestGenerationContextAsync(
ProjectItemSummary selectedFile,
string targetProjectNamespace,
TestFramework testFramework,
MockFramework mockFramework)
{
Microsoft.CodeAnalysis.Solution solution = CreateUnitTestBoilerplateCommandPackage.VisualStudioWorkspace.CurrentSolution;
DocumentId documentId = solution.GetDocumentIdsWithFilePath(selectedFile.FilePath).FirstOrDefault();
if (documentId == null)
{
throw new InvalidOperationException("Could not find document in solution with file path " + selectedFile.FilePath);
}
var document = solution.GetDocument(documentId);
SyntaxNode root = await document.GetSyntaxRootAsync();
SemanticModel semanticModel = await document.GetSemanticModelAsync();
SyntaxNode firstClassDeclaration = root.DescendantNodes().FirstOrDefault(node => node.Kind() == SyntaxKind.ClassDeclaration);
if (firstClassDeclaration == null)
{
throw new InvalidOperationException("Could not find class declaration.");
}
if (firstClassDeclaration.ChildTokens().Any(node => node.Kind() == SyntaxKind.AbstractKeyword))
{
throw new InvalidOperationException("Cannot unit test an abstract class.");
}
SyntaxToken classIdentifierToken = firstClassDeclaration.ChildTokens().FirstOrDefault(n => n.Kind() == SyntaxKind.IdentifierToken);
if (classIdentifierToken == default(SyntaxToken))
{
throw new InvalidOperationException("Could not find class identifier.");
}
NamespaceDeclarationSyntax namespaceDeclarationSyntax = null;
if (!TypeUtilities.TryGetParentSyntax(firstClassDeclaration, out namespaceDeclarationSyntax))
{
throw new InvalidOperationException("Could not find class namespace.");
}
// Find property injection types
var injectableProperties = new List <InjectableProperty>();
string classFullName = namespaceDeclarationSyntax.Name + "." + classIdentifierToken;
INamedTypeSymbol classType = semanticModel.Compilation.GetTypeByMetadataName(classFullName);
foreach (ISymbol member in classType.GetBaseTypesAndThis().SelectMany(n => n.GetMembers()))
{
if (member.Kind == SymbolKind.Property)
{
IPropertySymbol property = (IPropertySymbol)member;
foreach (AttributeData attribute in property.GetAttributes())
{
if (PropertyInjectionAttributeNames.Contains(attribute.AttributeClass.ToString()))
{
var injectableProperty = InjectableProperty.TryCreateInjectableProperty(property.Name, property.Type.ToString(), mockFramework);
if (injectableProperty != null)
{
injectableProperties.Add(injectableProperty);
}
}
}
}
}
string className = classIdentifierToken.ToString();
// Find constructor injection types
List <InjectableType> constructorInjectionTypes = new List <InjectableType>();
SyntaxNode constructorDeclaration = firstClassDeclaration.ChildNodes().FirstOrDefault(n => n.Kind() == SyntaxKind.ConstructorDeclaration);
if (constructorDeclaration != null)
{
constructorInjectionTypes.AddRange(
GetParameterListNodes(constructorDeclaration)
.Select(node => InjectableType.TryCreateInjectableTypeFromParameterNode(node, semanticModel, mockFramework)));
}
// Find public method declarations
IList <MethodDescriptor> methodDeclarations = new List <MethodDescriptor>();
foreach (MethodDeclarationSyntax methodDeclaration in
firstClassDeclaration.ChildNodes().Where(
n => n.Kind() == SyntaxKind.MethodDeclaration &&
((MethodDeclarationSyntax)n).Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword))))
{
var parameterList = GetParameterListNodes(methodDeclaration).ToList();
var parameterTypes = GetArgumentDescriptors(parameterList, semanticModel, mockFramework);
var isAsync =
methodDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.AsyncKeyword)) ||
DoesReturnTask(methodDeclaration);
var hasReturnType = !DoesReturnNonGenericTask(methodDeclaration) && !DoesReturnVoid(methodDeclaration);
methodDeclarations.Add(new MethodDescriptor(methodDeclaration.Identifier.Text, parameterTypes, isAsync, hasReturnType));
}
string unitTestNamespace;
string relativePath = this.GetRelativePath(selectedFile);
if (string.IsNullOrEmpty(relativePath))
{
unitTestNamespace = targetProjectNamespace;
}
else
{
List <string> defaultNamespaceParts = targetProjectNamespace.Split('.').ToList();
List <string> unitTestNamespaceParts = new List <string>(defaultNamespaceParts);
unitTestNamespaceParts.AddRange(relativePath.Split('\\'));
unitTestNamespace = string.Join(".", unitTestNamespaceParts);
}
List <InjectableType> injectedTypes = new List <InjectableType>(injectableProperties);
injectedTypes.AddRange(constructorInjectionTypes.Where(t => t != null));
GenerateMockNames(injectedTypes);
return(new TestGenerationContext(
mockFramework,
testFramework,
document,
unitTestNamespace,
className,
namespaceDeclarationSyntax.Name.ToString(),
injectableProperties,
constructorInjectionTypes,
injectedTypes,
methodDeclarations));
}
private async Task <TestGenerationContext> CollectTestGenerationContextAsync(
ProjectItemSummary selectedFile,
string targetProjectNamespace,
TestFramework testFramework,
MockFramework mockFramework,
IBoilerplateSettings settings)
{
Microsoft.CodeAnalysis.Solution solution = CreateUnitTestBoilerplateCommandPackage.VisualStudioWorkspace.CurrentSolution;
DocumentId documentId = solution.GetDocumentIdsWithFilePath(selectedFile.FilePath).FirstOrDefault();
if (documentId == null)
{
throw new InvalidOperationException("Could not find document in solution with file path " + selectedFile.FilePath);
}
var document = solution.GetDocument(documentId);
SyntaxNode root = await document.GetSyntaxRootAsync();
SemanticModel semanticModel = await document.GetSemanticModelAsync();
SyntaxNode firstClassLikeDeclaration = root.DescendantNodes().FirstOrDefault(node =>
{
var kind = node.Kind();
return(kind == SyntaxKind.ClassDeclaration || kind == SyntaxKind.StructDeclaration || kind == (SyntaxKind)9063); // record - Cannot update CodeAnalysis library because it's not found in VS 2019
});
if (firstClassLikeDeclaration == null)
{
throw new InvalidOperationException("Could not find class, struct or record declaration.");
}
if (firstClassLikeDeclaration.ChildTokens().Any(node => node.Kind() == SyntaxKind.AbstractKeyword))
{
throw new InvalidOperationException("Cannot unit test an abstract class.");
}
SyntaxToken classIdentifierToken = firstClassLikeDeclaration.ChildTokens().FirstOrDefault(n => n.Kind() == SyntaxKind.IdentifierToken);
if (classIdentifierToken == default(SyntaxToken))
{
throw new InvalidOperationException("Could not find class identifier.");
}
object namespaceDeclarationSyntax = null;
// 8842 is NamespaceDeclaration
// 8845 is FileScopedNamespaceDeclaration
// We would normally look for a node descended from BaseNamespaceDeclarationSyntax, but we don't have that type defined in the v1 Microsoft.CodeAnalysis DLL.
// We can fix this once we are building against a higher version and can drop support for VS 2019.
if (!TypeUtilities.TryGetParentSyntax(firstClassLikeDeclaration, (syntaxNode) => { return(syntaxNode.RawKind == 8842 || syntaxNode.RawKind == 8845); }, out namespaceDeclarationSyntax))
{
throw new InvalidOperationException("Could not find class namespace.");
}
// Find property injection types
var injectableProperties = new List <InjectableProperty>();
// We need to get the name via reflection since the DLL we are building against does not have the BaseNamespaceDeclarationSyntax or FileScopedNamespaceDeclarationSyntax types.
string qualifiedNamespaceString = namespaceDeclarationSyntax.GetType().GetProperty("Name").GetValue(namespaceDeclarationSyntax, null).ToString();
string classFullName = qualifiedNamespaceString + "." + classIdentifierToken;
INamedTypeSymbol classType = semanticModel.Compilation.GetTypeByMetadataName(classFullName);
foreach (ISymbol member in classType.GetBaseTypesAndThis().SelectMany(n => n.GetMembers()))
{
if (member.Kind == SymbolKind.Property)
{
IPropertySymbol property = (IPropertySymbol)member;
foreach (AttributeData attribute in property.GetAttributes())
{
if (PropertyInjectionAttributeNames.Contains(attribute.AttributeClass.ToString()))
{
var injectableProperty = InjectableProperty.TryCreateInjectableProperty(property.Name, property.Type.ToString(), mockFramework);
if (injectableProperty != null)
{
injectableProperties.Add(injectableProperty);
}
}
}
}
}
string className = classIdentifierToken.ToString();
// Find constructor injection types
List <InjectableType> constructorInjectionTypes = new List <InjectableType>();
SyntaxNode constructorDeclaration = firstClassLikeDeclaration.ChildNodes().FirstOrDefault(n => n.Kind() == SyntaxKind.ConstructorDeclaration);
if (constructorDeclaration != null)
{
constructorInjectionTypes.AddRange(
GetParameterListNodes(constructorDeclaration)
.Select(node => InjectableType.TryCreateInjectableTypeFromParameterNode(node, semanticModel, mockFramework)));
}
// Find public method declarations
IList <MethodDescriptor> methodDeclarations = new List <MethodDescriptor>();
foreach (MethodDeclarationSyntax methodDeclaration in
firstClassLikeDeclaration.ChildNodes().Where(
n => n.Kind() == SyntaxKind.MethodDeclaration &&
((MethodDeclarationSyntax)n).Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword))))
{
var parameterList = GetParameterListNodes(methodDeclaration).ToList();
var parameterTypes = GetArgumentDescriptors(parameterList, semanticModel, mockFramework);
var attributeList = GetAttributeListNodes(methodDeclaration);
var isAsync =
methodDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.AsyncKeyword)) ||
DoesReturnTask(methodDeclaration);
var hasReturnType = !DoesReturnNonGenericTask(methodDeclaration) && !DoesReturnVoid(methodDeclaration);
string returnType = methodDeclaration.ReturnType.ToFullString();
methodDeclarations.Add(new MethodDescriptor(methodDeclaration.Identifier.Text, parameterTypes, isAsync, hasReturnType, returnType, attributeList));
}
string unitTestNamespace;
string relativePath = this.GetRelativePath(selectedFile);
if (string.IsNullOrEmpty(relativePath))
{
unitTestNamespace = targetProjectNamespace;
}
else
{
List <string> defaultNamespaceParts = targetProjectNamespace.Split('.').ToList();
List <string> unitTestNamespaceParts = new List <string>(defaultNamespaceParts);
unitTestNamespaceParts.AddRange(relativePath.Split('\\'));
unitTestNamespace = string.Join(".", unitTestNamespaceParts);
}
List <InjectableType> injectedTypes = new List <InjectableType>(injectableProperties);
injectedTypes.AddRange(constructorInjectionTypes.Where(t => t != null));
GenerateMockNames(injectedTypes);
return(new TestGenerationContext(
mockFramework,
testFramework,
document,
settings,
unitTestNamespace,
className,
qualifiedNamespaceString,
injectableProperties,
constructorInjectionTypes,
injectedTypes,
methodDeclarations));
}