Make @ConfineMetaClassChanges repeatable (#1187)

closes #1030

Author: Vampire

docs/extensions.adoc

@@ -377,25 +377,7 @@ To confine meta class changes to the scope of a feature method or spec class, us
 
 [source,groovy]
 ----
-@Stepwise
-class FooSpec extends Specification {
-  @ConfineMetaClassChanges([String])
-  def "I run first"() {
-    when:
-    String.metaClass.someMethod = { delegate }
-
-    then:
-    String.metaClass.hasMetaMethod('someMethod')
-  }
-
-  def "I run second"() {
-    when:
-    "Foo".someMethod()
-
-    then:
-    thrown(MissingMethodException)
-  }
-}
+include::{sourcedir}/extension/ConfineMetaClassChangesDocSpec.groovy[tag=example]
 ----
 
 When applied to a spec class, the meta classes are restored to the state that they were in before `setupSpec` was executed,
@@ -404,6 +386,9 @@ after `cleanupSpec` is executed.
 When applied to a feature method, the meta classes are restored to as they were after `setup` was executed,
 before `cleanup` is executed.
 
+To confine meta class changes for multiple classes, you can either give multiple classes to the `value` attribute
+of the annotation or you can apply the annotation multiple times to the same target.
+
 CAUTION: Temporarily changing the meta classes is only safe when specs are
 run in a single thread per JVM. Even though many execution environments do limit themselves to one thread
 per JVM, keep in mind that Spock cannot enforce this.

docs/release_notes.adoc

@@ -12,6 +12,8 @@ include::include.adoc[]
 - `AbstractAnnotationDrivenExtension` is now deprecated and its logic was moved to `default` methods of
   `IAnnotationDrivenExtension` which should be implemented directly now instead of extending the abstract class.
 
+- `@ConfineMetaClassChanges` is now repeatable
+
 
 == 2.0-M3 (2020-06-11)
 

spock-core/src/main/java/org/spockframework/runtime/extension/builtin/ConfineMetaClassChangesExtension.java

@@ -20,26 +20,34 @@
 import org.spockframework.runtime.model.FeatureInfo;
 import org.spockframework.runtime.model.IInterceptable;
 import org.spockframework.runtime.model.SpecInfo;
-import org.spockframework.util.CollectionUtil;
-
 import spock.util.mop.ConfineMetaClassChanges;
 
+import java.util.Arrays;
+import java.util.List;
+
+import static java.util.stream.Collectors.toSet;
+
 /**
  * @author Luke Daley
  * @author Peter Niederwieser
  */
 public class ConfineMetaClassChangesExtension implements IAnnotationDrivenExtension<ConfineMetaClassChanges> {
   @Override
-  public void visitSpecAnnotation(ConfineMetaClassChanges annotation, SpecInfo spec) {
-    addInterceptor(annotation, spec.getBottomSpec());
+  public void visitSpecAnnotations(List<ConfineMetaClassChanges> annotations, SpecInfo spec) {
+    addInterceptor(annotations, spec.getBottomSpec());
   }
 
   @Override
-  public void visitFeatureAnnotation(ConfineMetaClassChanges annotation, FeatureInfo feature) {
-    addInterceptor(annotation, feature.getFeatureMethod());
+  public void visitFeatureAnnotations(List<ConfineMetaClassChanges> annotations, FeatureInfo feature) {
+    addInterceptor(annotations, feature.getFeatureMethod());
   }
 
-  private void addInterceptor(ConfineMetaClassChanges annotation, IInterceptable interceptable) {
-    interceptable.addInterceptor(new ConfineMetaClassChangesInterceptor(CollectionUtil.asSet(annotation.value())));
+  private void addInterceptor(List<ConfineMetaClassChanges> annotations, IInterceptable interceptable) {
+    interceptable.addInterceptor(new ConfineMetaClassChangesInterceptor(
+      annotations
+        .stream()
+        .map(ConfineMetaClassChanges::value)
+        .flatMap(Arrays::stream)
+        .collect(toSet())));
   }
 }

spock-core/src/main/java/spock/util/mop/ConfineMetaClassChanges.java

@@ -20,6 +20,7 @@
 
 import org.spockframework.runtime.extension.ExtensionAnnotation;
 import org.spockframework.runtime.extension.builtin.ConfineMetaClassChangesExtension;
+import org.spockframework.util.Beta;
 
 /**
  * Confines any changes made to the meta classes of the specified classes to the
@@ -35,15 +36,26 @@
  * <p>If a feature method is annotated, the meta classes are restored to as they
  * were after <tt>setup()</tt> was executed, before <tt>cleanup() is executed.
  * For a data-driven feature method, meta classes are restored after each iteration.
- * 
+ *
  * @author Luke Daley
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.TYPE, ElementType.METHOD})
 @ExtensionAnnotation(ConfineMetaClassChangesExtension.class)
+@Repeatable(ConfineMetaClassChanges.Container.class)
 public @interface ConfineMetaClassChanges {
   /**
    * The classes whose meta class changes are to be confined.
    */
   Class<?>[] value();
+
+  /**
+   * @since 2.0
+   */
+  @Beta
+  @Retention(RetentionPolicy.RUNTIME)
+  @Target({ElementType.TYPE, ElementType.METHOD})
+  @interface Container {
+    ConfineMetaClassChanges[] value();
+  }
 }

spock-specs/src/test/groovy/org/spockframework/docs/extension/ConfineMetaClassChangesDocSpec.groovy

@@ -0,0 +1,27 @@
+package org.spockframework.docs.extension
+
+import spock.lang.Specification
+import spock.lang.Stepwise
+import spock.util.mop.ConfineMetaClassChanges
+
+// tag::example[]
+@Stepwise
+class ConfineMetaClassChangesDocSpec extends Specification {
+  @ConfineMetaClassChanges(String)
+  def "I run first"() {
+    when:
+    String.metaClass.someMethod = { delegate }
+
+    then:
+    String.metaClass.hasMetaMethod('someMethod')
+  }
+
+  def "I run second"() {
+    when:
+    "Foo".someMethod()
+
+    then:
+    thrown(MissingMethodException)
+  }
+}
+// end::example[]

spock-specs/src/test/groovy/spock/util/mop/ConfineMetaClassChangesSpec.groovy

@@ -23,28 +23,28 @@ import spock.lang.*
  */
 @Stepwise
 class ConfineMetaClassChangesSpec extends EmbeddedSpecification {
-  
+
   def setupSpec() {
     newValue = 1
   }
-  
+
   def "change the metaclass"() {
     expect: value == 1
     when: newValue = 2
     then: value == 2
   }
-  
+
   def "value is still changed value"() {
     expect: value == 2
   }
-  
+
   @ConfineMetaClassChanges(String)
   def "change it again, but with restore annotation"() {
     expect: value == 2
     when: newValue = 3
     then: value == 3
   }
-  
+
   def "changes have been reverted"() {
     expect: value == 2
   }
@@ -56,7 +56,7 @@ class ConfineMetaClassChangesSpec extends EmbeddedSpecification {
 
   @ConfineMetaClassChanges([String, Integer])
   def "change more than one type"() {
-    expect: 
+    expect:
     value == 2
 
     when:
@@ -67,7 +67,7 @@ class ConfineMetaClassChangesSpec extends EmbeddedSpecification {
     getValue("") == 3
     getValue(1) == 3
   }
-  
+
   def "changes are reverted on both"() {
     expect:
     getValue("") == 2
@@ -78,7 +78,33 @@ class ConfineMetaClassChangesSpec extends EmbeddedSpecification {
     then:
     thrown(MissingMethodException)
   }
-  
+
+  @ConfineMetaClassChanges(String)
+  @ConfineMetaClassChanges(Integer)
+  def "change more than one type with multiple annotations"() {
+    expect:
+    value == 2
+
+    when:
+    setNewValue(3, String)
+    setNewValue(3, Integer)
+
+    then:
+    getValue("") == 3
+    getValue(1) == 3
+  }
+
+  def "changes are still reverted on both"() {
+    expect:
+    getValue("") == 2
+
+    when:
+    getValue(1)
+
+    then:
+    thrown(MissingMethodException)
+  }
+
   def "exercise a spec level restore"() {
     setup:
     newValue = 2
@@ -112,7 +138,7 @@ class ConfineMetaClassChangesSpec extends EmbeddedSpecification {
     ""                          | 3
     "@ConfineMetaClassChanges(String)" | 2
   }
-  
+
   @ConfineMetaClassChanges(String)
   def "meta classes are restored after each iteration"() {
     expect:
@@ -126,27 +152,27 @@ class ConfineMetaClassChangesSpec extends EmbeddedSpecification {
     where:
     i << [2,2]
   }
-  
+
   def "meta class was restored after parameterised"() {
     expect:
     value == 2
   }
-  
+
   @ConfineMetaClassChanges([])
   def "annotation with empty list/array value doesn't cause an error"(){
     expect: true
   }
-  
+
   def cleanupSpec() {
     [String, Integer].each {
       GroovySystem.metaClassRegistry.removeMetaClass(it)
     }
   }
-  
+
   static setNewValue(value, type = String) {
     type.metaClass.getIsolateMetaClassExtensionValue = { -> value }
   }
-  
+
   static getValue(seed = "") {
     seed.getIsolateMetaClassExtensionValue()
   }