Parameters and validation for the 'Extract Method' refactoring.

pkg/analysis_server/test/services/refactoring/extract_method_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.services.refactoring.extract_method;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/refactoring/extract_method.dart';
@@ skipping 58 matching lines @@
 class A {
   void res() {}
   main() {
 // start
     print(0);
 // end
   }
 }
 ''');
     _createRefactoringForStartEndComments();
-    // TODO(scheglov) implement
-//    return _assertConditionsError("Class 'A' already declares method with name 'res'.");
+    return _assertConditionsError(
+        "Class 'A' already declares method with name 'res'.");
   }
 
   test_bad_conflict_method_shadowsSuperDeclaration() {
     indexTestUnit('''
 class A {
   void res() {} // marker
 }
 class B extends A {
   main() {
     res();
 // start
     print(0);
 // end
   }
 }
 ''');
     _createRefactoringForStartEndComments();
-    // TODO(scheglov) implement
-//    return _assertConditionsError("Created method will shadow method 'A.res'.");
+    return _assertConditionsError("Created method will shadow method 'A.res'.");
   }
 
   test_bad_conflict_topLevel_alreadyDeclaresFunction() {
     indexTestUnit('''
+library my.lib;
+
 void res() {}
 main() {
 // start
   print(0);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
-    // TODO(scheglov) implement
-//    return _assertConditionsError("Library already declares function with name 'res'.");
+    return _assertConditionsError(
+        "Library already declares function with name 'res'.");
   }
 
   test_bad_conflict_topLevel_willHideInheritedMemberUsage() {
     indexTestUnit('''
 class A {
   void res() {}
 }
 class B extends A {
   foo() {
     res(); // marker
   }
 }
 main() {
 // start
   print(0);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
-    // TODO(scheglov) implement
-//    return _assertConditionsError("Created function will shadow method 'A.res'.");
+    return _assertConditionsError("Created function will shadow method 'A.res'.");
   }
 
   test_bad_constructor_initializer() {
     indexTestUnit('''
 class A {
   int f;
   A() : f = 0 {}
 }
 ''');
     _createRefactoringForString('f = 0');
@@ skipping 188 matching lines @@
   test_bad_newMethodName_notIdentifier() {
     indexTestUnit('''
 main() {
 // start
   print(0);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     refactoring.name = 'bad-name';
-    // TODO(scheglov) implement
-//    return _assertConditionsFatal("Method name must not contain '-'.");
+    // check conditions
+    return _assertConditionsError("Method name must not contain '-'.");
   }
 
   test_bad_notSameParent() {
     indexTestUnit('''
 main() {
   while (false) 
 // start
   { 
   } 
   print(0);
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
     return _assertConditionsFatal(
         'Not all selected statements are enclosed by the same parent statement.');
   }
 
   test_bad_parameterName_duplicate() {
     indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
 // start
   int a = v1 + v2; // marker
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
-    // TODO(scheglov) implement
     // update parameters
-//    {
-//      Parameter[] parameters = refactoring.getParameters();
-//      assertThat(parameters).hasSize(2);
-//      parameters[0].setNewName("dup");
-//      parameters[1].setNewName("dup");
-//      refactoring.setParameters(parameters);
-//    }
-//    // check conditions
-//    refactoringStatus = refactoring.checkFinalConditions(pm);
-//    assertRefactoringStatus(
-//        refactoringStatus,
-//        RefactoringStatusSeverity.ERROR,
-//        "Parameter 'dup' already exists");
+    return refactoring.checkInitialConditions().then((_) {
+      {
+        var parameters = refactoring.parameters.toList();
+        expect(parameters, hasLength(2));
+        parameters[0].name = 'dup';
+        parameters[1].name = 'dup';
+        refactoring.parameters = parameters;
+      }
+      return _assertFinalConditionsError("Parameter 'dup' already exists");
+    });
   }
 
   test_bad_parameterName_inUse() {
     indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
 // start
   int a = v1 + v2; // marker
 // end
 }
 ''');
     _createRefactoringForStartEndComments();
-    // TODO(scheglov) implement
     // update parameters
-//    {
-//      Parameter[] parameters = refactoring.getParameters();
-//      assertThat(parameters).hasSize(2);
-//      parameters[0].setNewName("a");
-//      refactoring.setParameters(parameters);
-//    }
-//    // check conditions
-//    refactoringStatus = refactoring.checkFinalConditions(pm);
-//    assertRefactoringStatus(
-//        refactoringStatus,
-//        RefactoringStatusSeverity.ERROR,
-//        "'a' is already used as a name in the selected code");
+    return refactoring.checkInitialConditions().then((_) {
+      {
+        var parameters = refactoring.parameters.toList();
+        expect(parameters, hasLength(2));
+        parameters[0].name = 'a';
+        refactoring.parameters = parameters;
+      }
+      return _assertFinalConditionsError(
+          "'a' is already used as a name in the selected code");
+    });
   }
 
   test_bad_selectionEndsInSomeNode() {
     indexTestUnit('''
 main() {
 // start
   print(0);
   print(1);
 // end
 }
 ''');
-    _createRefactoringForStartEndString('print(0', 'int(1)');
+    _createRefactoringForStartEndString('print(0', 'rint(1)');
     return _assertConditionsFatal(
         "The selection does not cover a set of statements or an expression. "
             "Extend selection to a valid range.");
   }
 
   test_bad_statements_return_andAssignsVariable() {
     indexTestUnit('''
 main() {
 // start
   var v = 0;
@@ skipping 137 matching lines @@
             "parts of try, catch, or finally block.");
   }
 
   test_bad_typeReference() {
     indexTestUnit('''
 main() {
   int a = 0;
 }
 ''');
     _createRefactoringForString("int");
-    return _assertConditionsFatal(
-        "Cannot extract a single type reference.");
+    return _assertConditionsFatal("Cannot extract a single type reference.");
   }
 
   test_bad_variableDeclarationFragment() {
     indexTestUnit('''
 main() {
   int 
 // start
     a = 1
 // end
     ,b = 2;
@@ skipping 872 matching lines @@
   int v1 = 1;
   int v2 = 2;
   int a = res(v1, v2);
 }
 
 int res(int v1, int v2) => v1 + v2 + v1;
 ''');
   }
 
   test_singleExpression_withVariables_doRename() {
-    // TODO(scheglov)
+    indexTestUnit('''
+main() {
+  int v1 = 1;
+  int v2 = 2;
+  int v3 = 3;
+  int a = v1 + v2 + v1; // marker
+  int b = v2 + v3 + v2;
+}
+''');
+    _createRefactoringForString('v1 + v2 + v1');
+    // apply refactoring
+    return refactoring.checkInitialConditions().then((_) {
+      {
+        var parameters = refactoring.parameters.toList();
+        expect(parameters, hasLength(2));
+        expect(parameters[0].name, 'v1');
+        expect(parameters[1].name, 'v2');
+        parameters[0].name = 'par1';
+        parameters[1].name = 'param2';
+        refactoring.parameters = parameters;
+      }
+      return assertRefactoringFinalConditionsOK().then((_) {
+        refactoring.createGetter = false;
+        return _assertRefactoringChange('''
+main() {
+  int v1 = 1;
+  int v2 = 2;
+  int v3 = 3;
+  int a = res(v1, v2); // marker
+  int b = res(v2, v3);
+}
+
+int res(int par1, int param2) => par1 + param2 + par1;
+''');
+      });
+    });
   }
 
   test_singleExpression_withVariables_doReorder() {
-    // TODO(scheglov)
+    indexTestUnit('''
+main() {
+  int v1 = 1;
+  int v2 = 2;
+  int v3 = 3;
+  int a = v1 + v2; // marker
+  int b = v2 + v3;
+}
+''');
+    _createRefactoringForString('v1 + v2');
+    // apply refactoring
+    return refactoring.checkInitialConditions().then((_) {
+      {
+        var parameters = refactoring.parameters.toList();
+        expect(parameters, hasLength(2));
+        expect(parameters[0].name, 'v1');
+        expect(parameters[1].name, 'v2');
+        var parameter = parameters.removeAt(1);
+        parameters.insert(0, parameter);
+        refactoring.parameters = parameters;
+      }
+      return assertRefactoringFinalConditionsOK().then((_) {
+        refactoring.createGetter = false;
+        return _assertRefactoringChange('''
+main() {
+  int v1 = 1;
+  int v2 = 2;
+  int v3 = 3;
+  int a = res(v2, v1); // marker
+  int b = res(v3, v2);
+}
+
+int res(int v2, int v1) => v1 + v2;
+''');
+      });
+    });
   }
 
   test_singleExpression_withVariables_namedExpression() {
     indexTestUnit('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int a = process(arg: v1 + v2);
 }
 process({arg}) {}
 ''');
     _createRefactoringForString('process(arg: v1 + v2)');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int v1 = 1;
   int v2 = 2;
   int a = res(v1, v2);
 }
 
 res(int v1, int v2) => process(arg: v1 + v2);
 process({arg}) {}
 ''');
   }
 
   test_singleExpression_withVariables_newType() {
-    // TODO(scheglov)
+    indexTestUnit('''
+main() {
+  int v1 = 1;
+  int v2 = 2;
+  int v3 = 3;
+  int a = v1 + v2 + v3;
+}
+''');
+    _createRefactoringForString('v1 + v2 + v3');
+    // apply refactoring
+    return refactoring.checkInitialConditions().then((_) {
+      {
+        var parameters = refactoring.parameters.toList();
+        expect(parameters, hasLength(3));
+        expect(parameters[0].name, 'v1');
+        expect(parameters[1].name, 'v2');
+        expect(parameters[2].name, 'v3');
+        parameters[0].type = 'num';
+        parameters[1].type = 'dynamic';
+        parameters[2].type = '';
+        refactoring.parameters = parameters;
+      }
+      return assertRefactoringFinalConditionsOK().then((_) {
+        refactoring.createGetter = false;
+        return _assertRefactoringChange('''
+main() {
+  int v1 = 1;
+  int v2 = 2;
+  int v3 = 3;
+  int a = res(v1, v2, v3);
+}
+
+int res(num v1, v2, v3) => v1 + v2 + v3;
+''');
+      });
+    });
   }
 
   test_singleExpression_withVariables_useBestType() {
     indexTestUnit('''
 main() {
   var v1 = 1;
   var v2 = 2;
   var a = v1 + v2 + v1; // marker
 }
 ''');
@@ skipping 535 matching lines @@
 
   Future _assertConditionsFatal(String message) {
     return refactoring.checkAllConditions().then((status) {
       assertRefactoringStatus(
           status,
           RefactoringProblemSeverity.FATAL,
           expectedMessage: message);
     });
   }
 
+  Future _assertFinalConditionsError(String message) {
+    return refactoring.checkFinalConditions().then((status) {
+      assertRefactoringStatus(
+          status,
+          RefactoringProblemSeverity.ERROR,
+          expectedMessage: message);
+    });
+  }
+
+  Future _assertRefactoringChange(String expectedCode) {
+    return refactoring.createChange().then((SourceChange refactoringChange) {
+      this.refactoringChange = refactoringChange;
+      assertTestChangeResult(expectedCode);
+    });
+  }
+
   /**
    * Checks that all conditions are OK and the result of applying the [Change]
    * to [testUnit] is [expectedCode].
    */
   Future _assertSuccessfulRefactoring(String expectedCode) {
     return assertRefactoringConditionsOK().then((_) {
       refactoring.createGetter = false;
-      return refactoring.createChange().then((SourceChange refactoringChange) {
-        this.refactoringChange = refactoringChange;
-        assertTestChangeResult(expectedCode);
-      });
+      return _assertRefactoringChange(expectedCode);
     });
   }
 
   void _createRefactoring(int offset, int length) {
     refactoring =
         new ExtractMethodRefactoringImpl(searchEngine, testUnit, offset, length);
     refactoring.name = 'res';
   }
 
-
-//  Future _assertInitialConditions_fatal_selection() {
-//    return refactoring.checkInitialConditions().then((status) {
-//      assertRefactoringStatus(
-//          status,
-//          RefactoringProblemSeverity.FATAL,
-//          expectedMessage: 'Expression must be selected to activate this refactoring.');
-//    });
-//  }
-
   void _createRefactoringForStartEndComments() {
     int offset = findEnd('// start') + '\n'.length;
     int end = findOffset('// end');
     _createRefactoring(offset, end - offset);
   }
 
   void _createRefactoringForStartEndString(String startSearch,
       String endSearch) {
     int offset = findOffset(startSearch);
     int end = findOffset(endSearch);
     _createRefactoring(offset, end - offset);
   }
 
   /**
    * Creates a new refactoring in [refactoring] for the selection range of the
    * given [search] pattern.
    */
   void _createRefactoringForString(String search) {
     int offset = findOffset(search);
     int length = search.length;
     _createRefactoring(offset, length);
   }
 
   void _createRefactoringWithSuffix(String selectionSearch, String suffix) {
     int offset = findOffset(selectionSearch + suffix);
     int length = selectionSearch.length;
     _createRefactoring(offset, length);
   }
 }