Wie stub-Typoskript-Schnittstelle / Type-definition?

Habe ich schriftlich Typoskript-tests mit qUnit und Sinon, und ich habe genau das gleiche erlebt Schmerzen, die Sie beschreiben.

Angenommen, Sie haben eine Abhängigkeit von einer Schnittstelle, wie:

interface IDependency {
    a(): void;
    b(): boolean;
}

Habe ich es geschafft, zu vermeiden die Notwendigkeit, zusätzliche tools/Bibliotheken mit ein paar Ansätzen, basierend auf sinon stubs/Spione und Gießen.

• Verwenden Sie eine leere object-literal, dann direkt zuweisen sinon stubs, die die Funktionen im code verwendet:

  //Create empty literal as your IDependency (usually in the common "setup" method of the test file)
  let anotherDependencyStub = <IDependency>{};
  
  //Set stubs for every method used in your code 
  anotherDependencyStub.a = sandbox.stub(); //If not used, you won't need to define it here
  anotherDependencyStub.b = sandbox.stub().returns(true); //Specific behavior for the test
  
  //Exercise code and verify expectations
  dependencyStub.a();
  ok(anotherDependencyStub.b());
  sinon.assert.calledOnce(<SinonStub>anotherDependencyStub.b);

• Verwenden Sie Objekt-literal mit leeren Implementierungen der Methoden benötigt, die von Ihrem code, dann wickeln Methoden in sinon spies/stubs als erforderlich

  //Create dummy interface implementation with only the methods used in your code (usually in the common "setup" method of the test file)
  let dependencyStub = <IDependency>{
      a: () => { }, //If not used, you won't need to define it here
      b: () => { return false; }
  };
  
  //Set spies/stubs
  let bStub = sandbox.stub(dependencyStub, "b").returns(true);
  
  //Exercise code and verify expectations
  dependencyStub.a();
  ok(dependencyStub.b());
  sinon.assert.calledOnce(bStub);

Arbeiten Sie ganz nett, wenn Sie kombinieren Sie mit sinon Sandboxen und common setup/teardown, wie die von qUnit-Module.

• In der gemeinsamen setup-erstellen Sie eine neue sandbox und die mock-Objekt-Literale für Ihre Abhängigkeiten.
• Im test-Sie geben einfach den spies/stubs.

Etwas wie dies (mit der ersten option, würde aber funktionieren auf die gleiche Weise, wenn Sie die zweite option):

QUnit["module"]("fooModule", {
    setup: () => {
        sandbox = sinon.sandbox.create();
        dependencyMock = <IDependency>{};
    },
    teardown: () => {
        sandbox.restore();
    }
});

test("My foo test", () => {
    dependencyMock.b = sandbox.stub().returns(true);

    var myCodeUnderTest = new Bar(dependencyMock);
    var result = myCodeUnderTest.doSomething();

    equal(result, 42, "Bar.doSomething returns 42 when IDependency.b returns true");
});

Ich würde Zustimmen, dass dies noch nicht die ideale Lösung aber es funktioniert Recht gut, erfordert keine zusätzlichen Bibliotheken und hält die Höhe der zusätzlichen code, der benötigt wird, um eine geringe, überschaubare Ebene.

InformationsquelleAutor Daniel J.G.

Gibt es wenige Bibliotheken, die ermöglicht, dass TypeMoq, TeddyMocks und Typescript-mockify sind wohl eine der beliebtesten.

Überprüfen Sie die github-repositories und das auswählen, das Euch besser gefällt :
links:

• TeddyMocks: https://github.com/mbraude/TeddyMocks
• TypeMoq: https://github.com/florinn/typemoq
• TypeScriptMockify: https://github.com/brechtbilliet/typescript-mockify

Können Sie auch mehr beliebt libs wie Sinon, aber zuerst müssen Sie ein <any> geben und dann engen Sie es zu <IDependency> Typ (Wie verwende ich Sinon mit Typescript?)

InformationsquelleAutor PolishDeveloper

Können Sie versuchen,moq.ts, aber es hängt ein Proxy-Objekt

interface IDependency {
  a(): number;
  b(): string;
}


import {Mock, It, Times} from 'moq.ts';

const mock = new Mock<IDependency>()
  .setup(instance => instance.a())
  .returns(1);

mock.object().a(); //returns 1

mock.verify(instance => instance.a());//pass
mock.verify(instance => instance.b());//fail

InformationsquelleAutor dvabuzyarov