Comment puis-je stub/maquette d'une fonction en javascript espace de noms global

Je suis en train de stub/maquette/remplacement d'un appel de fonction au cours des essais qui écrit un journal sur une DB.

function logit(msg) {
  writeMessageToDb(msg);
}

function tryingToTestThisFunction(){
  var error = processSomething();
  if (error) {
    logit(error);
  }
}

J'aimerais logit() simplement imprimer à la console pendant le test...et de faire un "isTesting()" if/else bloc à l'intérieur de la logit() fonction n'est pas une option.

Est-ce possible sans de quelques autres se moquant de cadre. Je suis actuellement à l'aide JsTestDriver pour les tests unitaires et n'ont pas eu la chance d'évaluer tout se moquant de cadres. Une solution idéale à l'heure actuelle serait de gérer cela sans un autre cadre.

OriginalL'auteur tjjava | 2010-12-20

6

- Je utiliser de Jasmin et de Sinon.js (à l'aide de Coffeescript), voici comment j'ai stub les confirmer() méthode à, par exemple, il suffit de retourner la valeur true.
```
beforeEach ->
  @confirmStub = sinon.stub(window, 'confirm')
  @confirmStub.returns(true)

afterEach ->
  @confirmStub.restore()
```
Ce cas est différent de la Fenêtre.confirm() n'est pas une fonction globale.

OriginalL'auteur sivabudh
3

En javascript la dernière définition est la forte prévalence de l'.

donc suffit de redéfinir la méthode logit après la première définition.
```
function logit(msg) {
  console.log(msg);
}
```
exemple : http://www.jsfiddle.net/gaby/UeeQZ/

OriginalL'auteur Gabriele Petrioli
1

pouvez-vous remplacer la méthode de l'objet window? Dans une console Chromée cela fonctionne
```
function test() {console.log('test')};
window.test();
```
OriginalL'auteur hvgotcodes

juste remplacer le logit de la fonction, ce qui peut être appelée à tout moment au plus tard logit est défini.

(function(){
  //keep handle to original logit method.
  var ol = logit;

  //shorter lookup path for slice
  var s = Array.prototype.slice;

  //logit override
  logit = function() {
    //if in testing
    if (typeof IsTesting == "function" && !!IsTesting()) {
      //log the arguments
      console.log.apply(console, s.call(arguments));
    } else {
      //otherwise, call the original function.
      ol.apply(this, s.call(arguments))
    }
  }
}());

REMARQUE: vous pouvez spécifier "msg" comme un paramater et passer directement à la s.appel(arguments).appliquer sur la méthode va passer le tout à travers, qui fonctionne le mieux pour les substitutions de méthode de ce genre.

OriginalL'auteur Tracker1

1

J'ai travaillé sur exactement le même problème. Les développeurs m'a donné une appli HTML5 pour tester, alors, évidemment, je ne peux pas changer leur code pour les tests. J'ai décidé d'utiliser qunit et sinon, le long de avec sinon-qunit.

Pour un newb JavaScript tests unitaires comme moi, j'allais noix avec l'sinon de la documentation et des exemples divers sur le web, comme la plupart d'entre elle semble pour l'implicite de l'environnement qui n'est pas mentionnée. Le code ci-dessous est une page complète, donc j'espère que rien n'est laissé pour la confusion.

La fonction que j'ai à composer est le caller() et je ne peux rien faire à propos de stubme() parce que c'est le développeur du code. Cependant, je peux ajouter sinonstub() dans mon code de test. Mais la façon de l'obtenir pour fonctionner avec sinon? L'sinon documentation vraiment confus de moi pendant un moment, mais ci-dessous est la solution la plus simple. Le stub4stubme objet peut être utilisé pour le contrôle de la fusée d'action, et également obtenir les informations sur ce qui se passe avec la stub des appels.
```
<!DOCTYPE html>

<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="utf-8" />
    <title></title>
    <link rel="stylesheet" href="qunit-1.12.0.css" type="text/css" media="screen" />
</head>
<body>
    <div id="qunit"></div>
    <div id="qunit-fixture"></div>
    <script src="sinon-1.7.3.js"></script>
    <script src="qunit-1.12.0.js"></script>
    <script src="sinon-qunit-0.8.0.js"></script>
    <script>

        //Dev code in another file
        function stubme() {
            return "stubme";
        }

        function caller() {
            return "caller " + stubme();
        }
        //End of dev code

        var sinonstub = function () {
            return "u haz bin stubbed";
        };

        test("Stubbing global environments", function () {
            equal(caller(), "caller stubme");

            var stub4stubme = this.stub(window, "stubme", sinonstub);

            equal(caller(), "caller u haz bin stubbed");
            ok(stubme.called);
        });

    </script>
</body>
</html>
```
Vous avez presque eu votre doigt sur ma confusion. Sinon.stub(fenêtre, "stubme", sinonstub); Pourquoi "de la fenêtre" haut niveau nom de l'objet? Il se passe quelque chose ici sur la variable globale de l'environnement, qui, dans votre exemple est appelé fenêtre parce qu'elle est exécutée dans une fenêtre. Mais l'affiche originale pourrait être en Node.js ou,.... alors, est-il encore "fenêtre", alors?

OriginalL'auteur bmiller

Parce que dans le Javascript n'est pas seulement runtime lié, mais le dernier mot gagne lié, juste redeclare la méthode avec le comportement que vous voulez dans votre test:

function yourTest(){
    oldImpl = logit;   //better to use a setup.
    logit = function(msg){ Console.log.apply(console, s.call(arguments));};
    //do you assertions: assert.... yada.

    logit = oldImpl;  //Do this to keep your test isolated from the others you'll be executing in this test run. Better to use a tear down.
}

OriginalL'auteur Lance Kind

Vous devez vous connecter pour publier un commentaire.