private static void TestEvents()
{
using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"))
{
int n1 = 0;
int n2 = 0;
int n3 = 0;
proxy.TestEvent2 += (sender, data) =>
{
Console.WriteLine("event2:{0}", data.Data[0].width);
n2++;
};
proxy.TestEvent += (sender, data) =>
{
Console.WriteLine("event1:{0}", data.Data);
n1++;
};
proxy.TestEvent3 += (sender, data) =>
{
Console.WriteLine("event3:{0}", data.Data);
n3++;
};
for (long i = 0, prev = i; i < 20; i++)
{
Console.WriteLine(prev = proxy.UseWS().Sum(i, prev).Result);
}
Thread.Sleep(10000);
Console.WriteLine("{0}, {1}, {2}", n1, n2, n3);
}
}
public void TestMethodsWS()
{
using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0").UseWS())
{
TestMethods(proxy);
}
}
private static void TestMethods()
{
using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"))
{
try
{
Console.WriteLine(proxy/*.UseWS()*/.ThrowError().Result);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
var task = proxy.Sum(1, 2);
Console.WriteLine(task.Result);
var r = new GeneratedTest.RenderOptions {width = 1, height = 2, renderMode = GeneratedTest.RenderMode.Production};
var taskEcho = proxy.Echo(r);
Console.WriteLine(taskEcho.Result.ToString());
var o = new JObject();
o["a"] = JToken.FromObject(new[] { 1, 2 });
var taskEcho2 = proxy.EchoObject(o);
Console.WriteLine(taskEcho2.Result.ToString());
// binary message
var bytes = proxy.EchoStringAsBuffer("binary").Result;
Console.WriteLine("bytes: {0}, message: {1}", bytes.Length,
System.Text.Encoding.Default.GetString(bytes));
var bytesLength = proxy.GetBufferSize(bytes).Result;
Console.WriteLine("bytes buffer size: {0}", bytesLength);
}
}
private static void TestEvents()
{
using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"))
{
int n1 = 0;
int n2 = 0;
int n3 = 0;
proxy.TestEvent2 += (sender, data) =>
{
Console.WriteLine("event2:{0}", data.Data[0].width);
n2++;
};
proxy.TestEvent += (sender, data) =>
{
Console.WriteLine("event1:{0}", data.Data);
n1++;
};
proxy.TestEvent3 += (sender, data) =>
{
Console.WriteLine("event3:{0}", data.Data);
n3++;
};
for (long i = 0, prev = i; i < 20; i++)
{
Console.WriteLine(prev = proxy.UseWS().Sum(i, prev).Result);
}
Thread.Sleep(10000);
Console.WriteLine("{0}, {1}, {2}", n1, n2, n3);
}
}
public void TestMethodsHTTP()
{
using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0").UseHTTP())
{
TestMethods(proxy);
}
}
public static void UpdateTest(GeneratedTest newTest)
{
using (Entities e = new Entities())
{
}
//todo
}
public AddUnitTestDialog(MonoDevelop.Ide.Gui.Document document, MethodDeclarationSyntax currentMethod, GeneratedTest generatedTestModel)
{
_testGeneratorService = CompositionManager.Instance.GetExportedValue <ITestGeneratorService>();
_currentMethod = currentMethod;
_document = document;
_generatedTestModel = generatedTestModel;
WindowPosition = WindowPosition.CenterAlways;
Title = "Add Unit test method";
//entry setup
_unitTestNameTitle = new Label
{
Text = "Unit test name:"
};
_unitTestName = new Entry();
_unitTestName.Activated += EntryActivated;
//button setup
_confirm = new Button
{
Label = "Create"
};
_confirm.Clicked += Confirm_Clicked;
VBox.Add(_unitTestNameTitle);
VBox.Add(_unitTestName);
VBox.Add(_confirm);
VBox.ShowAll();
}
public void TestUnsubscribe()
{
var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0");
var n1 = 0;
EventHandler<GeneratedTest.DataEventArgs<long>> testEventHandler = (sender, data) =>
{
n1++;
};
proxy.TestEvent += testEventHandler;
Thread.Sleep(1500);
proxy.TestEvent -= testEventHandler;
Thread.Sleep(2000);
Assert.AreEqual(n1, 1);
}
public void TestUnsubscribe()
{
var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0");
var n1 = 0;
EventHandler <GeneratedTest.DataEventArgs <long> > testEventHandler = (sender, data) =>
{
n1++;
};
proxy.TestEvent += testEventHandler;
Thread.Sleep(1500);
proxy.TestEvent -= testEventHandler;
Thread.Sleep(2000);
Assert.AreEqual(n1, 1);
}
public async Task <ActionResult> Solve(int?id)
{
if (id == null)
{
return(View("Error"));
}
var test = await db.Tests.FindAsync(id);
if (test == null)
{
return(View("Error"));
}
var u = db.Users.Find(User.Identity.GetUserId());
var generated = new GeneratedTest()
{
Date = DateTime.Now, Score = null, User = u, Test = test
};
db.GeneratedTests.Add(generated);
var questions = test.Questions.ToList();
questions.Shuffle(new Random());
var testquestions = new List <Question>();
for (int i = 0; i <= test.QuestionLimit - 1; i++)
{
if (i >= questions.Count)
{
break;
}
var questionanswer = new UserQuestionAnswer()
{
Question = questions[i]
};
db.UserQuestionAnswers.Add(questionanswer);
questionanswer.GeneratedTest = generated;
testquestions.Add(questions[i]);
}
await db.SaveChangesAsync();
return(View(new TestSolveViewModel()
{
GeneratedId = generated.Id,
Name = test.Name,
CourseId = test.Course.Id,
Questions = testquestions
}));
}
//create generated test
public static WebResult AddGeneratedTest(GeneratedTest newtest)
{
using (Entities e = new Entities())
{
WebResult wb = new WebResult();
try
{
//add new test
test t = e.tests.Add(TestCasting.TestToDAL(newtest.test));
e.SaveChanges();
//add rand questions to the new test
List <question> newQuesList = RandQues(t.test_id, t.level, newtest.american,
newtest.yesNo, newtest.match, newtest.classes.FirstOrDefault().teacher_id, newtest.subCategories);
t.classes.AddRange(ClassCasting.ClassesToDAL(newtest.classes));
newQuesList.ForEach(q =>
{
question qq = new question()
{
question_level = q.question_level,
question_id = q.question_id,
question_text = q.question_text,
//// answers = q.answers,
// sub_category = q.sub_category,
sub_category_id = q.sub_category_id,
// tests = q.tests,
// type = q.type,
type_id = q.type_id
};
t.questions.Add(qq);
});
//t.questions.AddRange(newQuesList.ToList());
wb.status = true;
wb.message = "succeed";
wb.value = TestCasting.TestToDTO(t);
e.SaveChanges();
return(wb);
}
catch (Exception ex)
{
wb.status = false;
wb.message = ex.Message;
return(wb);
}
}
}
private static void TestUnsubscribe()
{
var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0");
int n1 = 0;
EventHandler <GeneratedTest.DataEventArgs <long> > testEventHandler = (sender, data) =>
{
Console.WriteLine("event1:{0}", data.Data);
n1++;
};
proxy.TestEvent += testEventHandler;
Thread.Sleep(5000);
Console.WriteLine(n1);
proxy.TestEvent -= testEventHandler;
Thread.Sleep(5000);
Console.WriteLine(n1);
}
public IHttpActionResult AddGeneratedTest([FromBody] GeneratedTest newtest)
{
try
{
if (ModelState.IsValid)
{
return(Ok(TestLogic.AddGeneratedTest(newtest)));
}
var errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.ToList();
return(BadRequest(errors.ToString()));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void TestEvents()
{
using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"))
{
int n1 = 0;
int n2 = 0;
int n3 = 0;
proxy.TestEvent2 += (sender, data) =>
{
Console.WriteLine("event2:{0}", data.Data[0].width);
n2++;
};
proxy.TestEvent += (sender, data) =>
{
Console.WriteLine("event1:{0}", data.Data);
n1++;
};
proxy.TestEvent3 += (sender, data) =>
{
Console.WriteLine("event3:{0}", data.Data);
n3++;
};
string s = null;
proxy.TestBinaryEvent += (sender, data) =>
{
s = Encoding.UTF8.GetString(data.Data);
Console.WriteLine(s);
};
Thread.Sleep(6000);
Assert.IsTrue(n1 > 0);
Assert.IsTrue(n2 > 0);
Assert.IsTrue(n3 > 0);
Assert.AreEqual(s, "test binary event");
}
}
public void TestEvents()
{
using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"))
{
int n1 = 0;
int n2 = 0;
int n3 = 0;
proxy.TestEvent2 += (sender, data) =>
{
Console.WriteLine("event2:{0}", data.Data[0].width);
n2++;
};
proxy.TestEvent += (sender, data) =>
{
Console.WriteLine("event1:{0}", data.Data);
n1++;
};
proxy.TestEvent3 += (sender, data) =>
{
Console.WriteLine("event3:{0}", data.Data);
n3++;
};
string s = null;
proxy.TestBinaryEvent += (sender, data) =>
{
s = Encoding.UTF8.GetString(data.Data);
Console.WriteLine(s);
};
Thread.Sleep(6000);
Assert.IsTrue(n1 > 0);
Assert.IsTrue(n2 > 0);
Assert.IsTrue(n3 > 0);
Assert.AreEqual(s, "test binary event");
}
}
private void TestMethods(GeneratedTest proxy)
{
try
{
Console.WriteLine(proxy.ThrowError().Result);
Assert.Fail("Server-side exception was not rethrown on the client");
}
catch (Exception)
{
}
var task = proxy.Sum(1, 2);
Assert.AreEqual(task.Result, 3);
var r = new GeneratedTest.RenderOptions {
width = 1, height = 2, renderMode = GeneratedTest.RenderMode.Production
};
var taskEcho = proxy.Echo(r);
Assert.AreEqual(r.width, taskEcho.Result.width);
Assert.AreEqual(r.height, taskEcho.Result.height);
Assert.AreEqual(r.renderMode, taskEcho.Result.renderMode);
var o = new JObject();
o["a"] = JToken.FromObject(new[] { 1, 2 });
var taskEcho2 = proxy.EchoObject(o);
Assert.AreEqual(o["a"].ToString(), taskEcho2.Result["a"].ToString());
var bytes = proxy.EchoStringAsBuffer("binary").Result;
Assert.AreEqual("binary", Encoding.UTF8.GetString(bytes));
var bytesLength = proxy.GetBufferSize(bytes).Result;
Assert.AreEqual(bytes.LongLength, bytesLength);
}
public async Task <MonoDevelop.Ide.Gui.Document> OpenDocument(GeneratedTest generatedTestModel)
{
var config = await _configurationService.GetConfiguration();
var projects = IdeApp.Workspace.GetAllProjects();
var unitTestProject = projects.FirstOrDefault(p => p.Name == config.UnitTestProjectName);
if (unitTestProject == null)
{
return(null);
}
var file = unitTestProject.Files.FirstOrDefault(f => f.FilePath == generatedTestModel.FilePath);
if (file == null)
{
try
{
await _fileService.GenerateFile(generatedTestModel.Namespace, generatedTestModel.Name, generatedTestModel.FilePath);
file = new ProjectFile(generatedTestModel.FilePath, BuildAction.Compile)
{
Visible = true,
};
unitTestProject.AddFile(file);
}
catch (Exception e)
{
Debug.WriteLine(e);
return(null);
}
}
var document = await IdeApp.Workbench.OpenDocument(file.FilePath, unitTestProject, true);
return(document);
}
private static void TestMethods()
{
using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"))
{
try
{
Console.WriteLine(proxy /*.UseWS()*/.ThrowError().Result);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
var task = proxy.Sum(1, 2);
Console.WriteLine(task.Result);
var r = new GeneratedTest.RenderOptions {
width = 1, height = 2, renderMode = GeneratedTest.RenderMode.Production
};
var taskEcho = proxy.Echo(r);
Console.WriteLine(taskEcho.Result.ToString());
var o = new JObject();
o["a"] = JToken.FromObject(new[] { 1, 2 });
var taskEcho2 = proxy.EchoObject(o);
Console.WriteLine(taskEcho2.Result.ToString());
// binary message
var bytes = proxy.EchoStringAsBuffer("binary").Result;
Console.WriteLine("bytes: {0}, message: {1}", bytes.Length,
System.Text.Encoding.Default.GetString(bytes));
var bytesLength = proxy.GetBufferSize(bytes).Result;
Console.WriteLine("bytes buffer size: {0}", bytesLength);
}
}
private static void TestUnsubscribe()
{
var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0");
int n1 = 0;
EventHandler<GeneratedTest.DataEventArgs<long>> testEventHandler = (sender, data) =>
{
Console.WriteLine("event1:{0}", data.Data);
n1++;
};
proxy.TestEvent += testEventHandler;
Thread.Sleep(5000);
Console.WriteLine(n1);
proxy.TestEvent -= testEventHandler;
Thread.Sleep(5000);
Console.WriteLine(n1);
}
private void TestMethods(GeneratedTest proxy)
{
try
{
Console.WriteLine(proxy.ThrowError().Result);
Assert.Fail("Server-side exception was not rethrown on the client");
}
catch (Exception)
{
}
var task = proxy.Sum(1, 2);
Assert.AreEqual(task.Result, 3);
var r = new GeneratedTest.RenderOptions { width = 1, height = 2, renderMode = GeneratedTest.RenderMode.Production };
var taskEcho = proxy.Echo(r);
Assert.AreEqual(r.width, taskEcho.Result.width);
Assert.AreEqual(r.height, taskEcho.Result.height);
Assert.AreEqual(r.renderMode, taskEcho.Result.renderMode);
var o = new JObject();
o["a"] = JToken.FromObject(new[] { 1, 2 });
var taskEcho2 = proxy.EchoObject(o);
Assert.AreEqual(o["a"].ToString(), taskEcho2.Result["a"].ToString());
var bytes = proxy.EchoStringAsBuffer("binary").Result;
Assert.AreEqual("binary", Encoding.UTF8.GetString(bytes));
var bytesLength = proxy.GetBufferSize(bytes).Result;
Assert.AreEqual(bytes.LongLength, bytesLength);
}
public MethodDeclarationSyntax GenerateUnitTestMethodDeclaration(string returnTypeName, SyntaxTokenList modifiers, string methodName, string testFramework, GeneratedTest generatedTestModel)
{
var annotation = "nunit".Equals(testFramework) ? "Test" : "Fact";
var bodyStatements = new List <StatementSyntax>();
var addedArrange = false;
if (!string.IsNullOrWhiteSpace(generatedTestModel.ReturnType))
{
bodyStatements.Add(SyntaxFactory.ParseStatement($"var expected = default({generatedTestModel.ReturnType});\n").WithLeadingTrivia(SyntaxFactory.Comment("//Arrange\n")));
addedArrange = true;
}
var methodParams = "";
if (generatedTestModel.MethodParameters != null && generatedTestModel.MethodParameters.Any())
{
foreach (var parameter in generatedTestModel.MethodParameters)
{
if (!addedArrange)
{
bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = default({parameter.ClassName});\n").WithLeadingTrivia(SyntaxFactory.Comment("//Arrange\n")));
addedArrange = true;
}
else
{
bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = default({parameter.ClassName});\n"));
}
methodParams += $"{parameter.Name}, ";
}
}
var ctorParams = "";
if (generatedTestModel.ClassConstructorParameters != null && generatedTestModel.ClassConstructorParameters.Any())
{
foreach (var parameter in generatedTestModel.ClassConstructorParameters)
{
if (!addedArrange)
{
if (parameter.IsInterface)
{
bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = new Mock<{parameter.ClassName}>();\n").WithLeadingTrivia(SyntaxFactory.Comment("//Arrange\n")));
}
else
{
bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = default({parameter.ClassName});\n").WithLeadingTrivia(SyntaxFactory.Comment("//Arrange\n")));
}
addedArrange = true;
}
else
{
if (parameter.IsInterface)
{
bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = new Mock<{parameter.ClassName}>();\n"));
}
else
{
bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = default({parameter.ClassName});\n"));
}
}
ctorParams += parameter.IsInterface ? $"{parameter.Name}.Object, " : $"{parameter.Name}, ";
}
}
var classCtor = SyntaxFactory.ParseStatement($"var vm = new {generatedTestModel.ClassName}({ctorParams.TrimEnd(' ').TrimEnd(',')});\n").WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
bodyStatements.Add(classCtor);
var resultSection = string.IsNullOrWhiteSpace(generatedTestModel.ReturnType) ? "" : "var result = ";
var awaitSection = generatedTestModel.IsTask ? "await " : "";
bodyStatements.Add(SyntaxFactory.ParseStatement($"{resultSection}{awaitSection}vm.{generatedTestModel.MethodName}({methodParams.TrimEnd(' ').TrimEnd(',')});\n").WithLeadingTrivia(SyntaxFactory.Comment("//Act\n")));
//Generate the assert section
if ("nunit".Equals(testFramework))
{
if (!string.IsNullOrWhiteSpace(generatedTestModel.ReturnType))
{
bodyStatements.Add(SyntaxFactory.ParseStatement("Assert.That(expected == result);\n").WithLeadingTrivia(SyntaxFactory.Comment("//Assert\n")));
}
else
{
bodyStatements.Add(SyntaxFactory.ParseStatement("Assert.That(true);\n").WithLeadingTrivia(SyntaxFactory.Comment("//Assert\n")));
}
}
else
{
if (!string.IsNullOrWhiteSpace(generatedTestModel.ReturnType))
{
bodyStatements.Add(SyntaxFactory.ParseStatement($"Assert.Equal<{generatedTestModel.ReturnType}>(expected, result);\n").WithLeadingTrivia(SyntaxFactory.Comment("//Assert\n")));
}
else
{
bodyStatements.Add(SyntaxFactory.ParseStatement("Assert.True(true);\n").WithLeadingTrivia(SyntaxFactory.Comment("//Assert\n")));
}
}
var method = SyntaxFactory.MethodDeclaration(attributeLists: SyntaxFactory.List <AttributeListSyntax>(),
modifiers: modifiers,
returnType: SyntaxFactory.ParseTypeName(returnTypeName),
explicitInterfaceSpecifier: null,
identifier: SyntaxFactory.Identifier(methodName),
typeParameterList: null,
parameterList: SyntaxFactory.ParameterList(),
constraintClauses: SyntaxFactory.List <TypeParameterConstraintClauseSyntax>(),
body: SyntaxFactory.Block(bodyStatements),
semicolonToken: SyntaxFactory.Token(SyntaxKind.None))
// Annotate that this node should be formatted
.WithAdditionalAnnotations(Formatter.Annotation)
.WithAttributeLists(
SyntaxFactory.SingletonList(
SyntaxFactory.AttributeList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Attribute(
SyntaxFactory.IdentifierName(annotation))))));
return(method);
}
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);
}
public async Task GenerateUnitTest(string unitTestName, MethodDeclarationSyntax currentMethod, MonoDevelop.Ide.Gui.Document document, GeneratedTest generatedTestModel)
{
var returnType = generatedTestModel.IsTask ? "Task" : "void";
var modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
if (generatedTestModel.IsTask)
{
modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword));
}
var config = await _configurationService.GetConfiguration();
var annotation = "Test";
if ("xunit".Equals(config.TestFramework))
{
annotation = "Fact";
}
var newMethod = GenerateUnitTestMethodDeclaration(returnType, modifiers, unitTestName, annotation, generatedTestModel);
var analysisDoc = document.GetAnalysisDocument();
var editor = await DocumentEditor.CreateAsync(analysisDoc);
var cuRoot = editor.SemanticModel.SyntaxTree.GetCompilationUnitRoot();
if (cuRoot == null)
{
return;
}
//add required using statements that havent already been added
if (generatedTestModel.RequiredNamespaces != null && generatedTestModel.RequiredNamespaces.Any())
{
var usingNames = cuRoot.Usings.Select(u => u.Name.ToString());
var requiredUsings = new List <UsingDirectiveSyntax>();
foreach (var usingStatement in generatedTestModel.RequiredNamespaces)
{
if (!usingNames.Contains(usingStatement))
{
requiredUsings.Add(GenerateUsingSyntax(usingStatement));
}
}
if (requiredUsings.Any())
{
var updatedRoot = cuRoot.AddUsings(requiredUsings.ToArray());
editor.ReplaceNode(cuRoot, updatedRoot);
cuRoot = updatedRoot;
}
}
var lastMethod = cuRoot.DescendantNodes().OfType <MethodDeclarationSyntax>().LastOrDefault();
if (lastMethod != null)
{
editor.InsertAfter(lastMethod, newMethod);
}
else
{
var classDeclaration = cuRoot.DescendantNodes().OfType <ClassDeclarationSyntax>().First();
var newClassDeclaration = classDeclaration.AddMembers(newMethod);
editor.ReplaceNode(classDeclaration, newClassDeclaration);
}
var newDocument = editor.GetChangedDocument();
var newRoot = await newDocument.GetSyntaxRootAsync();
var textBuffer = document.GetContent <ITextBuffer>();
Microsoft.CodeAnalysis.Workspace.TryGetWorkspace(textBuffer.AsTextContainer(), out var workspace);
newRoot = Formatter.Format(newRoot, Formatter.Annotation, workspace);
workspace.TryApplyChanges(newDocument.WithSyntaxRoot(newRoot).Project.Solution);
await document.Save();
}
