public async Task Should_match_as_namespace_declaration3()
{
const string CaseTest = @"
using System;
namespace TestSuite.Inner.Other {
public class Foo {}
}
";
var tree = CSharpSyntaxTree.ParseText(CaseTest);
var root = await tree.GetRootAsync();
var cases = new[]
{
"Test",
"Suite",
"Inner",
"Other"
}
.Select(testcase => new TextSpan(CaseTest.IndexOf(testcase, StringComparison.Ordinal), testcase.Length))
.Select(span => root.IsNamespaceDeclaration(span))
.Where(x => x != null)
.ToArray();
Assert.Equal(4, cases.Length);
Assert.Equal("TestSuite.Inner.Other", cases[0].Name.ToString());
Assert.Equal("TestSuite.Inner.Other", cases[1].Name.ToString());
Assert.Equal("TestSuite.Inner.Other", cases[2].Name.ToString());
Assert.Equal("TestSuite.Inner.Other", cases[3].Name.ToString());
}
public async Task Should_not_match_as_namespace_declaration()
{
const string CaseTest = @"
using System;
namespace Test {
public class Foo {}
}
";
var tree = CSharpSyntaxTree.ParseText(CaseTest);
var root = await tree.GetRootAsync();
var cases = new[]
{
"namespace",
"using",
"System",
"public",
"class",
"Foo"
}
.Select(testcase => new TextSpan(CaseTest.IndexOf(testcase, StringComparison.Ordinal), testcase.Length))
.Select(span => root.IsNamespaceDeclaration(span))
.Where(x => x != null);
Assert.Equal(0, cases.Count());
}
public void TestCase4()
{
const string CaseTest = @"using System;
namespace Test {
namespace Inner {
public class Foo {
public string Hello() {return ""Hello"";}
}
public class Other {}
}
}";
var caseNode = GetNode(CaseTest);
var result = caseNode.ExtractClass(new TextSpan(CaseTest.IndexOf("Foo", StringComparison.Ordinal), 1));
const string TestExpected = @"using System;
namespace Test {
namespace Inner {
public class Foo {
public string Hello() {return ""Hello"";}
}
}
}";
Assert.Equal(GetNode(TestExpected).ToString(), result.ToString());
}
public async Task Should_move_Foo_to_folder_inner_into_class_dot_cs()
{
const string CaseTest = @"using System;
namespace Test {
namespace Inner {
public class Foo {
public string Hello() {return ""Hello"";}
}
public class Other {
public string Hello() {return ""Hello"";}
}
}
}";
const string ExpectedNewFileSource = @"using System;
namespace Test {
namespace Inner {
public class Foo {
public string Hello() {return ""Hello"";}
}
}
}";
const string ExpectedSource = @"using System;
namespace Test {
namespace Inner {
public class Other {
public string Hello() {return ""Hello"";}
}
}
}";
var project = CreateProject(CreateSolution(), "TestSuite");
var document = project.AddDocument("Test.cs", CaseTest, new[] { "Folder" });
var action = new TestableMoveClassCodeAction(new MoveClassCodeActionContext
{
Solution = document.Project.Solution,
DocumentId = document.Id,
Folders = new[] { "Inner" },
Name = "Class",
Span = new TextSpan(CaseTest.IndexOf("Foo", System.StringComparison.Ordinal), 3)
});
Assert.Equal("Move class into '\\Inner\\Class.cs'", action.Title);
var newSolution = await action.Execute(CancellationToken.None);
var newProject = newSolution.GetProject(project.Id);
var exp = newProject.GetDocument(document.Id);
var newDocument = newProject.Documents.FirstOrDefault(d => d.Name == "Class.cs");
Assert.NotNull(exp);
Assert.Equal(ExpectedSource, (await exp.GetTextAsync()).ToString());
Assert.Equal(ExpectedNewFileSource, (await newDocument.GetTextAsync()).ToString());
}
public void TestCase2()
{
const string CaseTest = @"using System;
namespace Test {
public class Foo {}
}";
var caseNode = GetNode(CaseTest);
var result = caseNode.ExtractClass(new TextSpan(CaseTest.IndexOf("Test", StringComparison.Ordinal), 1));
Assert.Null(result);
}
public void TestCase1()
{
const string CaseTest = @"namespace Test {
public class Foo {}
}";
var caseNode = GetNode(CaseTest);
var result = caseNode.ExtractClass(new TextSpan(CaseTest.IndexOf("Foo", StringComparison.Ordinal), 1));
const string TestExpected = CaseTest;
Assert.Equal(GetNode(TestExpected).ToString(), result.ToString());
}
public async Task Should_not_register_when_context_is_not_a_basetype(
ICodeRefactoringContextSubscriber interceptor,
MoveClassCodeRefactoringProvider sut
)
{
const string CaseTest = @"
using System;
namespace Test {
public class Foo {
private class Inner { }
public Foo() {
var innerDecl = new DateTime(2016, 3, 21, 0, 0, 0);
}
}
public class Other {
public class InnerOther { }
}
private class Error { }
}
";
var cases = new[]
{
"namespace",
"using",
"System",
"Test",
"Inner",
"InnerOther",
"Error",
"innerDecl",
"DateTime",
"new"
}.Select(c => GetContext(
CaseTest,
new TextSpan(CaseTest.IndexOf(c, StringComparison.Ordinal), c.Length),
projectName: "TestSuite",
interceptRegister: interceptor.Register
));
foreach (var context in cases)
{
await sut.ComputeRefactoringsAsync(context);
}
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.MustNotHaveHappened();
}
public async Task Should_register_rename_and_move_document(
ICodeRefactoringContextSubscriber interceptor,
MoveClassCodeRefactoringProvider sut
)
{
const string CaseTest = @"
using System;
namespace TestSuite.Inner {
public class Foo {
}
}
";
var context = GetContext(
CaseTest,
new TextSpan(CaseTest.IndexOf("Foo", StringComparison.Ordinal), "Foo".Length),
projectName: "TestSuite",
documentName: "Other",
folders: new[] { "Folder" },
interceptRegister: interceptor.Register
);
var actions = new List <CodeAction>();
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.Invokes((CodeAction act) => { actions.Add(act); });
await sut.ComputeRefactoringsAsync(context);
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.MustHaveHappened(Repeated.Exactly.Twice);
Assert.Equal("Rename File to 'Foo.cs'", actions[0].Title);
Assert.Equal("Move File to '\\Inner\\Foo.cs'", actions[1].Title);
}
public async Task Should_register_move_class_when_more_than_one_declaration_exist_and_context_is_a_basetype_and_target_file_by_convention_does_not_exist(
ICodeRefactoringContextSubscriber interceptor,
MoveClassCodeRefactoringProvider sut
)
{
const string CaseTest = @"
using System;
namespace TestSuite {
namespace Inner {
public class Foo {
private class Inner { }
}
}
namespace Folder {
public class OtherClass {
public class InnerOther { }
}
public struct OtherStruct {
}
public enum OtherEnum {
}
}
}
namespace Test {
public class Alone {
private class Inner { }
}
}
";
var cases = new[]
{
"Foo", //class Foo can only be extracted on folder Inner not on itself
"OtherClass", //class OtherClass has right namespace, so can only be extracted in current folder
"OtherStruct", //same as before
"OtherEnum", //same as before
"Alone" //class Alone is from a namespace not based on assembly so can be only extracted in current folder
}.Select(c => GetContext(
CaseTest,
new TextSpan(CaseTest.IndexOf(c, StringComparison.Ordinal), c.Length),
projectName: "TestSuite",
documentName: "Foo",
folders: new[] { "Folder" },
interceptRegister: interceptor.Register
));
var actions = new List <CodeAction>();
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.Invokes((CodeAction act) => { actions.Add(act); });
foreach (var context in cases)
{
await sut.ComputeRefactoringsAsync(context);
}
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.MustHaveHappened(Repeated.Exactly.Times(cases.Count()));
Assert.Equal("Move class into '\\Inner\\Foo.cs'", actions[0].Title);
Assert.Equal("Move class into '\\Folder\\OtherClass.cs'", actions[1].Title);
Assert.Equal("Move class into '\\Folder\\OtherStruct.cs'", actions[2].Title);
Assert.Equal("Move class into '\\Folder\\OtherEnum.cs'", actions[3].Title);
Assert.Equal("Move class into '\\Folder\\Alone.cs'", actions[4].Title);
}
