public async Task <GeneratedTest> CreateGeneratedTestModel(MethodDeclarationSyntax method, Document analysisDocument)
{
//Get the configuration model
var config = await _configurationService.GetConfiguration();
var generatedTest = new GeneratedTest();
generatedTest.RequiredNamespaces = new List <string>();
var projects = IdeApp.Workspace.GetAllProjects();
var unitTestProject = projects.FirstOrDefault(p => p.Name == config.UnitTestProjectName);
if (unitTestProject == null)
{
return(null);
}
var classSyntax = method.Parent as ClassDeclarationSyntax;
var namespaceSyntax = classSyntax.Parent as NamespaceDeclarationSyntax;
var requiredFolders = namespaceSyntax.Name.ToString().Split('.').ToList();
if (requiredFolders == null || !requiredFolders.Any())
{
return(null);
}
//remove the first part of namespace as per setting
if (config.RemoveFirst)
{
requiredFolders.RemoveAt(0);
}
//add the class name of the method as another folder
requiredFolders.Add(classSyntax.Identifier.Text + config.UnitTestClassSuffix);
var outputFile = unitTestProject.BaseDirectory.ToString() + "/";
var namespaceId = config.UnitTestProjectName;
foreach (var item in requiredFolders)
{
outputFile += item.Trim() + "/";
namespaceId += "." + item.Trim();
}
outputFile += method.Identifier.Text + $"{config.UnitTestSuffix}.cs";
generatedTest.FilePath = outputFile;
generatedTest.Namespace = namespaceId;
generatedTest.Name = method.Identifier.Text + config.UnitTestSuffix;
generatedTest.ClassName = classSyntax.Identifier.Text;
generatedTest.MethodName = method.Identifier.Text;
//Get the symantic model in order to resolve namespaces
var editor = await DocumentEditor.CreateAsync(analysisDocument);
var sematicModel = editor.SemanticModel;
//class namespace
generatedTest.RequiredNamespaces.Add(namespaceSyntax.Name.ToString());
//class constructor parameters
var classConstructor = classSyntax.DescendantNodes().OfType <ConstructorDeclarationSyntax>().FirstOrDefault();
if (classConstructor != null && classConstructor.ParameterList != null && classConstructor.ParameterList.Parameters.Any())
{
generatedTest.ClassConstructorParameters = new List <Parameter>();
foreach (var parameter in classConstructor.ParameterList.Parameters)
{
if (parameter.Type is IdentifierNameSyntax ins)
{
var isInterface = false;
var typeInfo = sematicModel.GetTypeInfo(ins);
if (typeInfo.Type is INamedTypeSymbol namedType)
{
if (namedType.TypeKind == TypeKind.Interface)
{
isInterface = true;
}
}
generatedTest.ClassConstructorParameters.Add(new Parameter
{
Name = parameter.Identifier.Text,
ClassName = ins.Identifier.Text,
IsInterface = isInterface
});
generatedTest.AddNamespaces(GetNamespacesForIdentifier(ins, sematicModel));
}
else if (parameter.Type is PredefinedTypeSyntax pds)
{
generatedTest.ClassConstructorParameters.Add(new Parameter
{
Name = parameter.Identifier.Text,
ClassName = pds.ToString()
});
}
else if (parameter.Type is GenericNameSyntax ns)
{
generatedTest.AddNamespaces(GetNamespacesForIdentifier(ns, sematicModel));
generatedTest.ClassConstructorParameters.Add(new Parameter
{
Name = parameter.Identifier.Text,
ClassName = ns.Identifier.Text
});
}
}
}
//Method Parameters
if (method.ParameterList.Parameters.Any())
{
generatedTest.MethodParameters = new List <Parameter>();
foreach (var parameter in method.ParameterList.Parameters)
{
var className = "";
if (parameter.Type is IdentifierNameSyntax ins)
{
className = ins.Identifier.Text;
generatedTest.AddNamespaces(GetNamespacesForIdentifier(ins, sematicModel));
}
else if (parameter.Type is PredefinedTypeSyntax pds)
{
className = pds.ToString();
}
else if (parameter.Type is GenericNameSyntax ns)
{
className = ns.ToString();
generatedTest.AddNamespaces(GetNamespacesForIdentifier(ns, sematicModel));
}
generatedTest.MethodParameters.Add(new Parameter
{
Name = parameter.Identifier.Text,
ClassName = className
});
}
}
//Method return type calculation
var isTask = false;
if (method.ReturnType is GenericNameSyntax gns)
{
isTask |= gns.Identifier.Text.Equals("Task");
if (isTask)
{
generatedTest.ReturnType = gns.TypeArgumentList?.Arguments.FirstOrDefault()?.ToString();
}
else
{
var rType = gns.Identifier.Text;
var arguments = string.Join(",", gns.TypeArgumentList?.Arguments.Select(a => a.ToString()));
if (!string.IsNullOrEmpty(arguments))
{
rType += $"<{arguments}>";
}
generatedTest.ReturnType = rType;
}
generatedTest.AddNamespaces(GetNamespacesForIdentifier(method.ReturnType, sematicModel));
}
else if (method.ReturnType is IdentifierNameSyntax ins)
{
isTask |= ins.Identifier.Text.Equals("Task");
generatedTest.ReturnType = ins.ToString().Equals("Task") ? null : ins.ToString();
generatedTest.AddNamespaces(GetNamespacesForIdentifier(method.ReturnType, sematicModel));
}
else if (method.ReturnType is PredefinedTypeSyntax pns)
{
generatedTest.ReturnType = pns.ToString().Equals("void") ? null : pns.ToString();
}
generatedTest.IsTask = isTask;
return(generatedTest);
}
