Lorsque Spock @Partagé annotation doit être préféré à un champ statique?

Il n'y a pas grand chose à ajouter, toute la question est dans le titre.

Tenir compte de ces deux instances de la classe Foo utilisé dans un Spock spécification.

@Shared Foo foo1 = new Foo()

static Foo foo2 = new Foo()

Dans l'ensemble, je sais que l'idée derrière @Shared annotation, mais je suppose que c'est mieux d'utiliser les fonctionnalités de langage, qui dans ce cas serait static champ.

Sont-t-il des cas dans lesquels on doit la préférence sur les autres ou c'est plutôt une question de goût?

Autant que je sache, ils sont en fait le même point de vue fonctionnel, mais @Shared meilleure montre votre intention

InformationsquelleAutor topr | 2016-03-10

13

Spock est tout au sujet de expressivité et clarté.

Statique est un mot-clé Java qui montre le fonctionnement interne de la classe (que ce champ est le même pour toutes les instances)

@Partagé est un Spock fonctionnalité qui dit au lecteur que cette variable est la même pour toutes les fonctionnalité de méthodes. C'est un enseignement spécifiquement pour le test unitaire et fait l'unité de test plus clair pour le lecteur.

La même chose peut être dite pour les principaux Spock blocs. Si vous pensez à ce sujet, ils n'ont pas vraiment changer quoi que ce soit sur le code.
```
public void myScenario(){
  int a = 2 + 3;
  assertEquals(5,a);
}

public void "simple addition scenario"(){
  when: "I add two numbers"
    int a = 2 +3

  then: "I expect the correct result"
  a == 5
}
```
Les deux tests unitaires faire exactement la même chose techniquement. La deuxième est cependant de montrer plus clairement l'intention. Le lorsque: et alors: les étiquettes ne sont pas vraiment faire n'importe quoi avec le code autre que de préciser son intention.

Donc, pour résumer, @Partagé est de rendre le test plus lisible. (Voir aussi @Question, @Titre etc., ils existent pour la même raison)
- Eh bien, il y a une légère différence en avoir et ne pas avoir", puis " bloquer. Les assertions sont implicites sur tout non nul de la ligne dans un bloc. Mais d'accord, le plus de valeur vient en lisibilité. Merci pour la réponse, je suis jusqu'à droit de vote, mais va attendre un peu plus pour voir si d'autres apparaissent. Je suis curieux de voir si il y a un autre pas de "sucre syntaxique" raisons de préférer @Partagé sur statique (ou l'inverse).
InformationsquelleAutor kazanaki

Contrairement à JUnit, où vous devez déclarer la variable de champ statique et d'attribuer de la valeur dans

@BeforeClass
public static void setupClass()

de sorte qu'il a été initialisé, juste une fois, par suite de tests (pas chaque méthode), dans Spock vous pouvez utiliser le champ de variable et de les annoter avec @Shared.

Considérons l'exemple suivant:

class SharedTestSpec extends spock.lang.Specification {

    @Shared
    def shared = shared()

    def shared() {
        "I came from ${this.class.simpleName}"
    }

    def 'Test one'() {
        given:
            println("test one, shared: $shared")
        expect: true
    }

    def 'Test two'() {
        given:
            println("test two, shared: $shared")
        expect: true

    }
}

class SubclassSpec extends SharedTestSpec {

    @Override
    def shared() {
        println("They've got me!")
        "I came from ${this.class.simpleName}"
    }
}

De course SubclassSpec vous donne la sortie suivante:

test one, shared: I came from SubclassSpec
test two, shared: I came from SubclassSpec
They've got me!

Ne peut pas expliquer l'ordre d'impression, mais c'est en raison de l'AST.

Intéressant, merci. Pour résumer les deux réponses: @Shared fait spécification plus lisible et permet à l'avantage d'une instance basée sur des méthodes (comme la suppression).

InformationsquelleAutor Valya

Comme une approche plus exhaustive, voici un exemple de test avec des sorties:

@Unroll
class BasicSpec extends Specification {

    int initializedVariable

    int globalVariable = 200

    static int STATIC_VARIABLE = 300

    @Shared
    int sharedVariable = 400

    void setup() {
        initializedVariable = 100
    }

    void 'no changes'() {
        expect:
            printVariables()
            /*
            initializedVariable: 100
            globalVariable: 200
            STATIC_VARIABLE: 300
            sharedVariable: 400
             */
    }

    void 'change values'() {
        setup:
            initializedVariable = 1100
            globalVariable = 1200
            STATIC_VARIABLE = 1300
            sharedVariable = 1400

        expect:
            printVariables()
            /*
            initializedVariable: 1100
            globalVariable: 1200
            STATIC_VARIABLE: 1300
            sharedVariable: 1400
             */
    }

    void 'print values again'() {
        expect:
            printVariables()
            /*
            initializedVariable: 100
            globalVariable: 200
            STATIC_VARIABLE: 1300
            sharedVariable: 1400
             */
    }

    private void printVariables() {
        println "initializedVariable: $initializedVariable"
        println "globalVariable: $globalVariable"
        println "STATIC_VARIABLE: $STATIC_VARIABLE"
        println "sharedVariable: $sharedVariable\n"
    }
}

Le plus surprenant pour moi est que la variable dans la classe " setup() méthode AINSI QUE la mondiale, instanciées variable obtenir réinitialisé à chaque test (sans doute parce que la classe est à nouveau instancié pour chaque cas de test). Pendant ce temps, le static et la @Shared variable fonctionner comme prévu. En conséquence, les deux derniers sont également peuvent être consultés dans where clauses, qui sont exécutées avant que certains de ceux qui sont inscrites avant dans chaque cas de test.

Les variables d'Instance sont instancié pour chaque @Test cas, pas étonnant, même pour JUnit. Pouvez-vous expliquer la dernière phrase? Je n'ai pas l'obtenir.

InformationsquelleAutor Igor

Vous devez vous connecter pour publier un commentaire.