public async Task ReplacesSetupMethodInClass()
{
var document = DocumentProvider.CreateDocumentFromFile(TestClassWithEmptyConstructor);
var root = document.GetSyntaxRootAsync().Result;
var testClass = root.DescendantNodesAndSelf().OfType <ClassDeclarationSyntax>().First();
_target = new DocumentBuilder(_memberFinder.Object, _fieldFinder.Object, document, testClass);
var newSetupMethod =
SyntaxNodeProvider.GetSyntaxNodeFromFile <ConstructorDeclarationSyntax>(Constructor, "ClassUnderTestTests");
var existingSetupMethod = root.DescendantNodes().OfType <ConstructorDeclarationSyntax>().First();
_memberFinder.Setup(_ =>
_.FindSimilarNode(It.IsAny <SyntaxList <MemberDeclarationSyntax> >(),
It.Is <SyntaxNode>(s => s == newSetupMethod)))
.Returns(existingSetupMethod);
var actual = await _target.WithSetupMethod(newSetupMethod)
.BuildAsync(new CancellationToken());
var actualRoot = await actual.GetSyntaxRootAsync();
var actualMethods = actualRoot.DescendantNodes().OfType <ConstructorDeclarationSyntax>().ToList();
Assert.Single((IEnumerable)actualMethods);
Assert.Equal(newSetupMethod.GetText().ToString(), actualMethods.First().GetText().ToString());
}
public async Task RewritesDefaultConstructor(string filePath)
{
// Arrange
var filePathClassUnderTest = "files.ClassUnderTest.txt";
var filePaths = new[] { filePath, filePathClassUnderTest };
var documents = DocumentProvider.CreateCompilationAndReturnDocuments(filePaths);
var documentWithTestClass = documents[filePath];
var root = await documentWithTestClass.GetSyntaxRootAsync();
var testClass = root.DescendantNodesAndSelf().OfType <ClassDeclarationSyntax>().First();
var documentWithClassUnderTest = documents[filePathClassUnderTest];
var classUnderTest = SyntaxNodeProvider.GetSyntaxNodeFromDocument <ClassDeclarationSyntax>(documentWithClassUnderTest, "ClassUnderTest");
var semanticModel = await documentWithClassUnderTest.GetSemanticModelAsync();
_classUnderTestFinder.Setup(_ => _.GetAsync(It.IsAny <Solution>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new ClassUnderTest(classUnderTest, semanticModel));
// Act
var actual = await _target.RegenerateSetup(documentWithTestClass, testClass, new CancellationToken());
// Assert
var actualText = await actual.GetTextAsync();
_testOutput.WriteLine(actualText.ToString().Replace(";", ";\n"));
var expected = await DocumentProvider.CreateDocumentFromFile("files.TestClass_WithFinalSetupConstructor.txt").GetTextAsync();
Assert.Equal(expected.ToString().RemoveWhitespace(), actualText.ToString().RemoveWhitespace());
}
public async Task SetsFields(string testClassFilePath)
{
// Arrange
var document = DocumentProvider.CreateDocumentFromFile(testClassFilePath);
var root = document.GetSyntaxRootAsync().Result;
var testClass = root.DescendantNodesAndSelf().OfType <ClassDeclarationSyntax>().First();
_target = new DocumentBuilder(_memberFinder.Object, _fieldFinder, document, testClass);
var newFieldDeclarations =
SyntaxNodeProvider.GetAllSyntaxNodesFromFile <FieldDeclarationSyntax>(FieldDeclarations).ToList();
var expectedFieldDeclarations =
SyntaxNodeProvider.GetAllSyntaxNodesFromFile <FieldDeclarationSyntax>(TestClassWithAllFields).ToList();
var expected = GetCollectionTextAsString(expectedFieldDeclarations);
// Act
var actual = await _target.WithFields(newFieldDeclarations)
.BuildAsync(new CancellationToken());
// Assert
var actualRoot = await actual.GetSyntaxRootAsync();
var actualFields = GetCollectionTextAsString(actualRoot.DescendantNodes().OfType <FieldDeclarationSyntax>());
_testOutput.WriteLine(actualFields);
Assert.Equal(expected, actualFields);
}
public void Returns_CorrectName_For_Parameter(string filePath, string parameterName, string expected)
{
var parameterSyntax = SyntaxNodeProvider.GetSyntaxNodeFromFile <ParameterSyntax>(filePath, parameterName);
var actual = _target.GetFromParameter(parameterSyntax);
Assert.Equal(expected, actual);
}
public void GeneratesFieldNameWithUnderscoreAndLowerCase(string filePath, string parameterType, string expected)
{
var parameterSyntax = SyntaxNodeProvider.GetSyntaxNodeFromFile <ParameterSyntax>(filePath, parameterType);
var actual = _target.GetFromParameter(parameterSyntax);
Assert.Equal(expected, actual);
}
public void Returns_SimilarClassSyntaxNode_IfExists(string filePath, string filePathCompared, string constructorOrMethodName, bool expected)
{
var memberSyntax = SyntaxNodeProvider.GetSyntaxNodeFromFile <MemberDeclarationSyntax>(filePath, constructorOrMethodName);
var classSyntax = SyntaxNodeProvider.GetSyntaxNodeFromFile <ClassDeclarationSyntax>(filePathCompared, "TestClass");
var actual = _target.FindSimilarNode(classSyntax.Members, memberSyntax);
Assert.Equal(expected, actual != null);
}
public void CanFindSimilarField_When_FieldExistsWithSameType(string searchInFile)
{
var fieldSyntax = FieldDeclarationProvider.GetFieldDeclarationFromFile(FileContainingFieldToUse, FieldNameToUse);
var classSyntax = SyntaxNodeProvider.GetSyntaxNodeFromFile <ClassDeclarationSyntax>(searchInFile, ClassNameToUse);
var actual = _target.FindSimilarNode(classSyntax.Members, fieldSyntax);
Assert.NotNull(actual);
}
public void Returns_FieldDeclarationsWithCorrectName_ForEach_Parameter(string filePath, string parameterName, string expected)
{
var parameterSyntax = SyntaxNodeProvider.GetSyntaxNodeFromFile <ParameterSyntax>(filePath, parameterName);
var syntaxGenerator = new SyntaxGeneratorProvider().GetSyntaxGenerator();
var actual = _target.GetGenericFieldDeclaration(parameterSyntax, "Mock", syntaxGenerator);
var actualTextWithoutSpaces = actual.GetText().ToString().Replace(" ", "");
var expectedTextWithoutSpaces = expected.Replace(" ", "");
Assert.Equal(expectedTextWithoutSpaces, actualTextWithoutSpaces);
}
public void ReturnsConstructorWithBody()
{
var filePath = "files.ConstructorGenerator_DocumentWithOneClassAndVariables.txt";
var source = TextFileReader.ReadFile(filePath);
var methodBody = SyntaxNodeProvider.GetAllSyntaxNodesFromFile <LocalDeclarationStatementSyntax>(filePath);
var syntaxGenerator = new SyntaxGeneratorProvider().GetSyntaxGenerator(source);
var className = "ClassA";
var actual = _target.Constructor(className, methodBody, syntaxGenerator);
Assert.Single(actual.DescendantNodes().OfType <LocalDeclarationStatementSyntax>());
}
public async Task Adds_Usings_For_All_Parameters(string filePath, string parameterName, string expectedNamespaces)
{
var source = TextFileReader.ReadFile(filePath);
var document = DocumentProvider.CreateDocument(source);
var parameterSyntax = SyntaxNodeProvider.GetSyntaxNodeFromDocument <ParameterSyntax>(document, parameterName);
var syntaxGenerator = new SyntaxGeneratorProvider().GetSyntaxGenerator();
var semanticModel = await document.GetSemanticModelAsync();
var usingDirectives = _target.UsingDirectives(semanticModel.Compilation, new[] { parameterSyntax }, new List <string>(), syntaxGenerator);
Assert.Equal(expectedNamespaces, usingDirectives.First().Name.ToString());
}
public void ReturnsAllConstructorParameters()
{
var textFilePath = "files.Class_WithConstructorWithTwoParameters.txt";
var classDeclarationSyntax = SyntaxNodeProvider.GetSyntaxNodeFromFile <ClassDeclarationSyntax>(textFilePath, "TestClass");
var actual = _target.GetParametersOfConstructor(classDeclarationSyntax).ToList();
Assert.Equal(2, actual.Count);
var firstParameter = actual.First();
Assert.Equal("someType", firstParameter.Identifier.Text);
Assert.Equal("ISomeType", firstParameter.Type.ToString());
var secondParameter = actual.Skip(1).First();
Assert.Equal("someOtherType", secondParameter.Identifier.Text);
Assert.Equal("ISomeOtherType", secondParameter.Type.ToString());
}
public async Task SetsConstructorAndFields(string testClassFilePath)
{
// Arrange
var document = DocumentProvider.CreateDocumentFromFile(testClassFilePath);
var root = document.GetSyntaxRootAsync().Result;
var testClass = root.DescendantNodesAndSelf().OfType <ClassDeclarationSyntax>().First();
_target = new DocumentBuilder(_memberFinder, _fieldFinder, document, testClass);
var newFieldDeclarations =
SyntaxNodeProvider.GetAllSyntaxNodesFromFile <FieldDeclarationSyntax>(FieldDeclarations).ToList();
var expectedFieldDeclarations =
SyntaxNodeProvider.GetAllSyntaxNodesFromFile <FieldDeclarationSyntax>(TestClassWithConstructorAndFields)
.ToList();
var expectedFields = GetCollectionTextAsString(expectedFieldDeclarations);
var newSetupMethod =
SyntaxNodeProvider.GetSyntaxNodeFromFile <ConstructorDeclarationSyntax>(Constructor, "ClassUnderTestTests");
// Act
var actual = await _target.WithSetupMethod(newSetupMethod)
.WithFields(newFieldDeclarations)
.BuildAsync(new CancellationToken());
// Assert
var actualRoot = await actual.GetSyntaxRootAsync();
_testOutput.WriteLine(actualRoot.GetText().ToString());
var actualFields = GetCollectionTextAsString(actualRoot.DescendantNodes().OfType <FieldDeclarationSyntax>());
Assert.Equal(expectedFields, actualFields);
var actualMethods = actualRoot.DescendantNodes().OfType <ConstructorDeclarationSyntax>().ToList();
Assert.Single((IEnumerable)actualMethods);
Assert.Equal(newSetupMethod.GetText().ToString(), actualMethods.First().GetText().ToString());
}
