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_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_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_register_with_correct_parameters( ICodeRefactoringContextSubscriber interceptor, InitializeFieldsFromConstructorCodeRefactoringProvider sut ) { const string TestCase = @" namespace Test { public class Foo { public Foo(int intParam) { field = otherField; intParam = 12; } } } "; var cases = new[] { "intParam" }.Select(c => GetContext( TestCase, new TextSpan(TestCase.IndexOf(c, StringComparison.Ordinal) + 1, 0), projectName: "TestSuite", interceptRegister: interceptor.Register )).ToArray(); var actions = new List <InitializeFieldsFromConstructorCodeAction>(); A .CallTo(() => interceptor.Register(A <CodeAction> .Ignored)) .Invokes((CodeAction act) => { actions.Add(act as InitializeFieldsFromConstructorCodeAction); }); foreach (var context in cases) { await sut.ComputeRefactoringsAsync(context); } A .CallTo(() => interceptor.Register(A <CodeAction> .Ignored)) .MustHaveHappened(Repeated.Exactly.Once); Assert.Equal("Initialize field '_intParam'", actions[0].Title); Assert.Equal(cases[0].Document.Id, actions[0].FixParameters.DocumentId); Assert.Equal(cases[0].Document.Project.Solution.Id, actions[0].FixParameters.Solution.Id); Assert.Equal("intParam", actions[0].FixParameters.ParameterName); Assert.Equal(cases[0].Span, actions[0].FixParameters.Span); }
public async Task Should_not_register_when_context_is_not_a_constructor_parameter_or_parameter_name_is_missing( ICodeRefactoringContextSubscriber interceptor, InitializeFieldsFromConstructorCodeRefactoringProvider sut ) { const string TestCase = @" namespace Test { public class Foo { private class Inner { } public Foo() {} public Foo(int intParam, MissingParameterName) { var innerDecl = new DateTime(2016, 3, 21, 0, 0, 0); } public void MyMethod(MyType boolParam) { } } } "; var cases = new[] { "MissingParameterName", "namespace", "Test", "public", "Foo", "class I", "Inner", "Foo(", "innerDecl", "DateTime", "MyMethod", "MyType", "boolParam", "()" }.Select(c => GetContext( TestCase, new TextSpan(TestCase.IndexOf(c, StringComparison.Ordinal) + 1, 0), 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_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_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_if_parameter_is_already_assigned( ICodeRefactoringContextSubscriber interceptor, InitializeFieldsFromConstructorCodeRefactoringProvider sut ) { const string TestCase = @" namespace Test { public class Foo { public Foo(int intParam) { _tmp = intParam; } } public class Foo2 { public Foo(bool boolParam) { this.tmp = boolParam; } } } "; var cases = new[] { "intParam", "boolParam" }.Select(c => GetContext( TestCase, new TextSpan(TestCase.IndexOf(c, StringComparison.Ordinal) + 1, 0), 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_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(); }
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); }