public async Task Should_register_MoveDocument_when_class_has_no_typeidentifier_and_namespace_is_assembly_based(
ICodeRefactoringContextSubscriber interceptor,
FixNamespaceCodeRefactoringProvider sut
)
{
const string TestCase1 = @"
using System;
namespace TestSuite.Test {
public class {
}
";
var created = new List <CodeAction>();
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.Invokes((CodeAction act) => { created.Add(act); });
await Task.WhenAll(new[]
{
TestCase1
}.Select(c => GetContext(
c,
new TextSpan(c.IndexOf("estSuit", StringComparison.Ordinal), 4),
folders: new[] { "Folder" },
interceptRegister: interceptor.Register
))
.Select(sut.ComputeRefactoringsAsync));
var moveActions = created.OfType <MoveDocumentCodeAction>().ToArray();
Assert.Equal(1, moveActions.Length);
Assert.Equal("Test", moveActions[0].FixParameters.Name);
moveActions[0].FixParameters.Folders.ShouldBeEquivalentTo(new[] { "Test" });
}
public async Task Should_not_register_when_namespace_declaration_is_nested(
ICodeRefactoringContextSubscriber interceptor,
FixNamespaceCodeRefactoringProvider sut
)
{
const string TestCase1 = @"
using System;
namespace TestSuite.Test {
namespace Inner {
public class {
}
}
}
";
var cases = new[]
{
TestCase1
}.Select(c => GetContext(
c,
new TextSpan(c.IndexOf("Inner", StringComparison.Ordinal), 4),
projectName: "TestSuite",
folders: new[] { "Folder" },
interceptRegister: interceptor.Register
));
foreach (var context in cases)
{
await sut.ComputeRefactoringsAsync(context);
}
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.MustNotHaveHappened();
}
public async Task Should_not_register_MoveDocument_when_namespace_is_right_for_each_class(
ICodeRefactoringContextSubscriber interceptor,
FixNamespaceCodeRefactoringProvider sut
)
{
const string TestCase1 = @"
using System;
namespace TestSuite.Folder {
public class Foo {}
public class Test {}
public class Other {}
}
";
var created = new List <CodeAction>();
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.Invokes((CodeAction act) => { created.Add(act); });
await Task.WhenAll(new[]
{
TestCase1
}.Select(c => GetContext(
c,
new TextSpan(c.IndexOf("estSuit", StringComparison.Ordinal), 4),
folders: new[] { "Folder" },
interceptRegister: interceptor.Register
))
.Select(sut.ComputeRefactoringsAsync));
var moveActions = created.OfType <MoveDocumentCodeAction>().ToArray();
Assert.Equal(0, moveActions.Length);
}
public async Task _Should_not_register_when_context_is_not_namespace_identifier(
ICodeRefactoringContextSubscriber interceptor,
FixNamespaceCodeRefactoringProvider sut
)
{
const string TestCase = @"
using System;
namespace Test {
public class Foo {}
}
";
await Task.WhenAll(new[]
{
"namespace",
"using",
"System",
"public",
"class",
"Foo"
}.Select(c => GetContext(
TestCase,
new TextSpan(TestCase.IndexOf(c, StringComparison.Ordinal), c.Length),
interceptRegister: interceptor.Register
)).Select(sut.ComputeRefactoringsAsync));
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.MustNotHaveHappened();
}
public async Task Should_register_ChangeNamespace_with_a_single_class_when_namespace_is_assembly_based_and_class_is_equal_to_document(
ICodeRefactoringContextSubscriber interceptor,
FixNamespaceCodeRefactoringProvider sut
)
{
const string TestCase1 = @"
using System;
namespace TestSuite.Folder {
public class Test {}
}
";
var created = new List <CodeAction>();
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.Invokes((CodeAction act) => { created.Add(act); });
await Task.WhenAll(new[]
{
TestCase1
}.Select(c => GetContext(
c,
new TextSpan(c.IndexOf("estSuit", StringComparison.Ordinal), 4),
folders: new[] { "Inner", "Nested" },
interceptRegister: interceptor.Register
))
.Select(sut.ComputeRefactoringsAsync));
var moveActions = created.OfType <ChangeNamespaceCodeAction>().ToArray();
Assert.Equal(1, moveActions.Length);
Assert.Equal("TestSuite.Folder", moveActions[0].FixParameters.NamespaceToFix);
Assert.Equal("TestSuite.Inner.Nested", moveActions[0].FixParameters.NewNamespace);
Assert.Equal($"Change Namespace to '{moveActions[0].FixParameters.NewNamespace}'", moveActions[0].Title);
}
public async Task Should_not_register_with_a_single_class_when_namespace_is_right_and_class_is_equal_to_document(
ICodeRefactoringContextSubscriber interceptor,
FixNamespaceCodeRefactoringProvider sut
)
{
const string TestCase1 = @"
using System;
namespace TestSuite.Folder {
public class Test {}
}
";
var cases = new[]
{
TestCase1
}.Select(c => GetContext(
c,
new TextSpan(c.IndexOf("estSuit", StringComparison.Ordinal), 4),
folders: new[] { "Folder" },
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_MoveDocument_when_namespace_is_assembly_based_for_each_class(
ICodeRefactoringContextSubscriber interceptor,
FixNamespaceCodeRefactoringProvider sut
)
{
const string TestCase1 = @"
using System;
namespace TestSuite {
public class Foo {}
public class Test {}
public class Other {}
}
";
var created = new List <CodeAction>();
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.Invokes((CodeAction act) => { created.Add(act); });
await Task.WhenAll(new[]
{
TestCase1
}.Select(c => GetContext(
c,
new TextSpan(c.IndexOf("estSuit", StringComparison.Ordinal), 4),
folders: new[] { "Folder", "Inner" },
interceptRegister: interceptor.Register
))
.Select(sut.ComputeRefactoringsAsync));
var moveActions = created.OfType <MoveDocumentCodeAction>().ToArray();
Assert.Equal(3, moveActions.Length);
Assert.Equal("Foo", moveActions[0].FixParameters.Name);
moveActions[0].FixParameters.Folders.ShouldBeEquivalentTo(new string[] { });
Assert.Equal($@"Move File to '{moveActions[0].FixParameters.Name}.cs'", moveActions[0].Title);
Assert.Equal("Test", moveActions[1].FixParameters.Name);
moveActions[1].FixParameters.Folders.ShouldBeEquivalentTo(new string[] { });
Assert.Equal($@"Move File to '{moveActions[1].FixParameters.Name}.cs'", moveActions[1].Title);
Assert.Equal("Other", moveActions[2].FixParameters.Name);
moveActions[2].FixParameters.Folders.ShouldBeEquivalentTo(new string[] { });
Assert.Equal($@"Move File to '{moveActions[2].FixParameters.Name}.cs'", moveActions[2].Title);
}
public async Task Should_register_RenameDocument_when_namespace_is_not_assembly_name_based(
ICodeRefactoringContextSubscriber interceptor,
FixNamespaceCodeRefactoringProvider sut
)
{
const string TestCase1 = @"
using System;
namespace Tests {
public class Foo {}
public class Test {}
public class Other {}
}
";
var created = new List <CodeAction>();
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.Invokes((CodeAction act) => { created.Add(act); });
await Task.WhenAll(new[]
{
TestCase1
}.Select(c => GetContext(
c,
new TextSpan(c.IndexOf("est", StringComparison.Ordinal), 3),
folders: new[] { "Folder" },
interceptRegister: interceptor.Register
))
.Select(sut.ComputeRefactoringsAsync));
var moveActions = created.OfType <RenameDocumentCodeAction>().ToArray();
Assert.Equal(2, moveActions.Length);
var action = moveActions[0];
Assert.NotNull(action);
Assert.Equal("Foo", action.FixParameters.Name);
action = moveActions[1];
Assert.NotNull(action);
Assert.Equal("Other", action.FixParameters.Name);
}
public async Task Should_not_register_with_a_single_class_when_namespace_is_equal_to_assembly_and_class_is_equal_to_document(
ICodeRefactoringContextSubscriber interceptor,
FixNamespaceCodeRefactoringProvider sut
)
{
const string TestCase = @"
using System;
namespace TestSuite {
public class Test {}
}
";
var context = GetContext(
TestCase,
new TextSpan(TestCase.IndexOf("Suite", StringComparison.Ordinal), 4),
interceptRegister: interceptor.Register
);
await sut.ComputeRefactoringsAsync(context);
A
.CallTo(() => interceptor.Register(A <CodeAction> .Ignored))
.MustNotHaveHappened();
}
