Mock/Stub-Konstruktor

Ich habe den folgenden code:

class Clients
  constructor : ->
    @clients = []

  createClient : (name)->

    client = new Client name
    @clients.push client

Ich bin testing mit Jasmine BDD wie diese:

describe 'Test Constructor', ->

  it 'should create a client with the name foo', ->

    clients = new clients
    clients.createClient 'Foo'
    Client.should_have_been_called_with 'Foo'

  it 'should add Foo to clients', ->

    clients = new clients
    clients.createClient 'Foo'

    expect(clients.clients[0]).toEqual SomeStub

In meinem ersten test möchte ich prüfen, ob der Konstruktor aufgerufen wird mit dem richtigen Namen. In meinem zweiten ich will einfach nur, um zu bestätigen, dass alles, was heraus kam der neue Client wurde Hinzugefügt, um das array.

Ich bin mit Jasmine BDD und es ist ein Weg, um Spione/mocks/stubs, aber es scheint, es ist nicht möglich, test-Konstruktor. Also ich bin auf der Suche in einer Art und Weise zu testen, der Konstruktor wäre es schön, wenn es einen Weg gibt, dass ich brauche nicht eine extra Bibliothek, aber ich bin für alles offen.

InformationsquelleAutor Pickels | 2011-09-25

Ich denke, der beste plan ist hier zu ziehen, die Schaffung des neuen Client Objekt in eine separate Methode. Dies ermöglicht es Ihnen zu testen, die Clients Klasse in isolation und mock verwenden Client Objekte.

Habe ich Schlagsahne einige Beispiel-code, aber ich habe es noch nicht getestet mit Jasmin. Hoffentlich können Sie das wesentliche, wie es funktioniert:

class Clients
  constructor: (@clientFactory) ->
    @clients = []

  createClient : (name)->
    @clients.push @clientFactory.create name

clientFactory = (name) -> new Client name

describe 'Test Constructor', ->

  it 'should create a client with the name foo', ->
    mockClientFactory = (name) ->
    clients = new Clients mockClientFactory

    clients.createClient 'Foo'

    mockClientFactory.should_have_been_called_with 'Foo'

  it 'should add Foo to clients', ->
    someStub = {}
    mockClientFactory = (name) -> someStub
    clients = new Clients mockClientFactory

    clients.createClient 'Foo'

    expect(clients.clients[0]).toEqual someStub

Den basic plan ist jetzt eine separate Funktion (clientFactory) neue Client Objekte. Diese Fabrik ist dann verspottet in den tests, so dass Sie genau Steuern, was zurückgegeben wird, und überprüfen, dass es wurde als richtig.

Ich hatte Angst, ich würde zu lösen haben, es auf diese Weise. Trotzdem Super Antwort, danke.

InformationsquelleAutor Karl

9

Es ist möglich, die stub-Konstruktoren in Jasmin, die syntax ist nur etwas unerwartetes:
```
spy = spyOn(window, 'Clients');
```
In anderen Worten, Sie nicht stub, die new Methode, Sie stub name der Klasse selbst in dem Kontext, in dem es lebt, in diesem Fall window. Sie können dann die Kette auf eine andReturn() zurück ein fake Objekt deiner Wahl, oder ein andCallThrough() zu nennen, den echten Konstruktor.

Siehe auch: Spionage auf einen Konstruktor mit Jasmin
- Dies funktioniert nicht wirklich, wenn Clients eine variable ist, die auf eine Schließung.
InformationsquelleAutor jpatokal
0

Meine Lösung endete ähnlich wie @zpatokal

Landete ich mit einem Modul auf meiner app (nicht wirklich große app), und Spott von dort. Ein Haken ist, dass and.callThrough wird nicht funktionieren, da der Konstruktor wird aufgerufen, aus dem Jasmin-Methode, so hatte ich zu tun, einige Tricks mit and.callFake.

On-Einheit.Kaffee
```
class PS.Unit
```
Auf die Geräte.Kaffee
```
class PS.Units
  constructor: ->
    new PS.Unit
```
Und auf spec-Dateien:
```
Unit = PS.Unit

describe 'Units', ->
  it 'should create a Unit', ->
    spyOn(PS, 'Unit').and.callFake -> new Unit arguments... # and.callThrough()
    expect(PS.Unit).toHaveBeenCalled()
```
InformationsquelleAutor Zequez

Klarere Lösung mit den letzten Jasmin version:

window.Client = jasmine.createSpy 'Client'
clients.createClient 'Foo'
expect(window.Client).toHaveBeenCalledWith 'Foo'

InformationsquelleAutor Benj

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.