Comment puis-je affirmer qu'une méthode particulière a été appelée à l'aide de NUnit?

Comment puis-je tester une méthode particulière a été appelé avec les paramètres en tant que résultat d'un test? Je suis à l'aide de NUnit.

La méthode ne retourne rien. il écrit simplement sur un fichier. Je suis à l'aide d'un objet fantaisie pour System.IO.File. Si je veux tester que la fonction a été appelée ou non.

OriginalL'auteur Umair Ahmed | 2009-12-03

  1. 11

    Plus de contexte est nécessaire. Donc je vais en mettre un ici l'ajout Moq pour le mélange:

    pubilc class Calc {
    public int DoubleIt(string a) {
        return ToInt(a)*2;
    }

    public virtual int ToInt(string s) {
        return int.Parse(s);
    }
}

//The test:
var mock = new Mock<Calc>();
string parameterPassed = null;
mock.Setup(c => x.ToInt(It.Is.Any<int>())).Returns(3).Callback(s => parameterPassed = s);

mock.Object.DoubleIt("3");
Assert.AreEqual("3", parameterPassed);
    Cela fonctionne lorsque Calc n'est pas abstraite ou une interface ? Autant que je sache Moq faire des proxies dynamiques pour faire ses se moque pas de la génération de nouvelles instructions IL pour que cela soit possible...

    OriginalL'auteur Dmytrii Nagirniak

  2. 11

    Vous devez utiliser une infrastructure factices, comme Typemock ou Rhino Se Moque De, ou NMocks2.

    NUnit a aussi un Nunit.Maquette, mais il n'est pas bien connu.

    La syntaxe pour moq peut être trouvé ici:

    var mock = new Mock<ILoveThisFramework>();

//WOW! No record/reply weirdness?! :)
mock.Setup(framework => framework.DownloadExists("2.0.0.0"))
    .Returns(true)
    .AtMostOnce();

//Hand mock.Object as a collaborator and exercise it, 
//like calling methods on it...
ILoveThisFramework lovable = mock.Object;
bool download = lovable.DownloadExists("2.0.0.0");

//Verify that the given method was indeed called with the expected value
mock.Verify(framework => framework.DownloadExists("2.0.0.0"));

    Aussi, notez que vous pouvez seulement se moquer interface, donc si votre objet à partir de System.IO.File ne dispose pas d'une interface, alors probablement que vous ne pouvez pas le faire. Vous avez de l'envelopper votre appel à System.IO.File à l'intérieur de votre propre classe personnalisée pour le travail.

    NUnit juste exécute les tests, il ne fait pas de moqueries ou de vérification. Des responsabilités différentes. Vous devriez être en mesure de vérifier les attentes sur votre maquette de l'objet, bien que je n'ai pas utilisé Moq.
    yep je cherchais au mauvais endroit... je cherchais dans nunit. maintenant, je suis en train de regarder moq. 🙂
    MOQ vous permettra de vous moquer de classes abstraites.

    OriginalL'auteur Graviton

  3. 3

    Par l'aide d'une maquette pour une interface.

    Dire que vous avez votre classe ImplClass qui utilise l'interface Finder et vous voulez vous assurer que la Search fonction est appelée avec l'argument "bonjour";

    nous avons donc:

    public interface Finder 
{
  public string Search(string arg);
}

    et

    public class ImplClass
{
  public ImplClass(Finder finder)
  {
    ...
  }
  public void doStuff();
}

    Ensuite, vous pouvez écrire une maquette de votre code de test

    private class FinderMock : Finder
{
  public int numTimesCalled = 0;
  string expected;
  public FinderMock(string expected)
  {
    this.expected = expected;
  }
  public string Search(string arg)
  {
    numTimesCalled++;
    Assert.AreEqual(expected, arg);
  }
}

    puis le code de test:

    FinderMock mock = new FinderMock("hello");
ImplClass impl = new ImplClass(mock);
impl.doStuff();
Assert.AreEqual(1, mock.numTimesCalled);

    OriginalL'auteur tster