Mohca Testfehler

Question

Ich muss storeDocument Funktion testen, wenn debug = false die createStorageDocument aufrufen wird. Aber für meine folgende Test-Code gibt einen Fehler 'TypeError: Versucht, undefinierte Eigenschaft createStorageDocument als Funktion'

Was mache ich falsch?

Und ich würde eine Lösung bevorzugen, stub fetch innerhalb createStorageDocument Funktion anstelle von createStorageDocument selbst, Kann jemand erklären, wie zu tun? Ich bin sehr neu in Mokka und node.js

import fetch from 'node-fetch'; 
 
import documentStorageResponseMock from '../../../test/mock/documentStorageResponseMock'; 
 

 
const storageGatewayUrl = 'url'; 
 
const storageGatewayApiKey = 'key'; 
 

 
/** 
 
* Merge storage id into booking response. 
 
* 
 
* @param booking 
 
* @param documentId 
 
* @returns {*} 
 
*/ 
 
function mergeDocumentId(booking, documentId) { 
 
    const mergedBooking = booking; 
 

 
    mergedBooking.successfulBooking.documentId = documentId.id; 
 

 
    return mergedBooking; 
 
} 
 

 
/** 
 
* @param labelledBooking 
 
*/ 
 
function createStorageDocument(labelledBooking) { 
 
    fetch(storageGatewayUrl, 
 
    { 
 
     method: 'POST', 
 
     body: { 
 
     document: labelledBooking, 
 
     }, 
 
     headers: { 
 
     ContentType: 'application/json', 
 
     'x-api-key': storageGatewayApiKey, 
 
     }, 
 
    }) 
 
    .then((response) => { 
 
     if (response.ok === false) { 
 
     throw new Error('Failed to create the document!'); 
 
     } else { 
 
     return response.json(); 
 
     } 
 
    }).catch((err) => { 
 
     throw err; 
 
    }); 
 
} 
 

 
/** 
 
* Save booking response and add the document id to the response. 
 
* 
 
* @param labelledBooking 
 
* @param debug 
 
* @param callback 
 
*/ 
 
export default function storeDocument(labelledBooking, debug = false, callback) { 
 
    if (debug) { 
 
    callback(
 
     null, 
 
     mergeDocumentId(labelledBooking, documentStorageResponseMock()) 
 
    ); 
 
    return; 
 
    } 
 

 
    callback(null, mergeDocumentId(labelledBooking, createStorageDocument(labelledBooking))); 
 
}

import storeDocument from '../../../lib/documents/storeDocument'; 
 

 
const chai = require('chai'); 
 
const expect = chai.expect; 
 
const sinon = require('sinon'); 
 

 
chai.use(require('dirty-chai')); 
 
chai.use(require('chai-fuzzy')); 
 

 
describe('merge document storage id', function() { 
 
    
 
    before(function(callback) { 
 
    sinon.stub(storeDocument, 'createStorageDocument', function (params, callback) { 
 
     return ({id: '1087449a-1248-4430-9bcb-5a61b2766020'}) 
 
    }); 
 
    }); 
 

 
    it('it creates and appends document id to booking when storage gateway is provided ', function(done) { 
 
    storeDocument({ 
 
     integrationId: 'testing', 
 
     successfulBooking: { 
 
      integrationServiceId: 'service-id', 
 
      bookingReference: '#ref', 
 
      shippingTaxInclusiveCharge: { amount: 10, currency: 'EUR' }, 
 
      pricedAt: '2016-05-20T15:00:00Z', 
 
      documentation: { 
 
      labelDocument: 'ero32ukj32hr3h' 
 
      } 
 
     } 
 
     }, 
 
     false, 
 
     (error, booking) => { 
 
     expect(booking.successfulBooking.bookingReference === '#ref').to.be.true; 
 
     expect(booking.successfulBooking.documentation !== undefined).to.be.true; 
 
     expect(booking.successfulBooking.documentId !== '').to.be.true; 
 
     done(); 
 
     }); 
 
    }); 
 
});

Answer 1

Ein Teil des Problems ist, dass createStorageDocument gibt ein Promise, kein skalaren Wert. Zuerst würde ich storeDocument umgestalten.

/** 
* Save booking response and add the document id to the response. 
* 
* @param   labelledBooking 
* @param {Function} createStorageDocument 
* @param {Function} callback 
*/ 
export default function storeDocument(labelledBooking, 
    createStorageDocument, 
    callback) { 
    createStorageDocument(labelledBooking) 
    .then(function (documentId) { 
     callback(null, mergeDocumentId(labelledBooking, documentId)); 
    }) 
    .catch(callback); 
} 

Ok, so was ist hier geschehen ist, wir Dependency Injection werden mit dem Objekt zu injizieren, die das Objekt gespeichert werden, und wir sind Umgang mit dem korrekt Versprechen.

Dann mögen Sie createStorageDocument beheben:

export function createStorageDocument(labelledBooking) { 
    return fetch(storageGatewayUrl, { 
     method: 'POST', 
     body: { 
     document: labelledBooking, 
     }, 
     headers: { 
     ContentType: 'application/json', 
     'x-api-key': storageGatewayApiKey, 
     }, 
    }) 
    .then((response) => { 
     if (response.ok === false) { 
     throw new Error('Failed to create the document!'); 
     } 

     return response.json(); 
    }); 
} 

Hier habe ich eingefügt return vor fetch, und Sie brauchen nicht den Fang mehr (es war sowieso nicht zur Arbeit gehen). Ich habe es exportiert, so dass Sie es in Ihrer tatsächlichen Implementierung verwenden müssen.

Ok, jetzt für den Test. Du brauchst Chai nicht - es hat nur Dinge kompliziert gemacht. Verwenden Sie Sinon sparsam und nur, wenn Sie Knoten besser kennen. Ihr Test kann so etwas wie dieses wird:

it('it creates and appends document id to booking when storage gateway is provided ', function(done) { 
     let createStorageDocumentStub = function (labelledBooking) { 
      return Promise.resolve('documentId???') 
     } 
    storeDocument({ 
     integrationId: 'testing', 
     successfulBooking: { 
      integrationServiceId: 'service-id', 
      bookingReference: '#ref', 
      shippingTaxInclusiveCharge: { amount: 10, currency: 'EUR' }, 
      pricedAt: '2016-05-20T15:00:00Z', 
      documentation: { 
      labelDocument: 'ero32ukj32hr3h' 
      } 
     } 
     }, 
     createStorageDocumentStub, 
     (error, booking) => { 
     if (error) { 
      return done(error); 
     } 
     assert(booking.successfulBooking.bookingReference === '#ref')); 
     assert(booking.successfulBooking.documentation !== void 0); 
     assert(booking.successfulBooking.documentId !== ''); 
     done(); 
     }); 
    }); 

Was ich getan habe, ist, erstellen Sie einen Stub (kein Mock, das ist eine andere Sache) für die Funktion, die angeblich um das Dokument zu speichern, und ich habe ersetzt Ihre Behauptungen mit nur einfach alt assert, die in Node enthalten ist. Und vergessen Sie nicht, Fehler in Ihren Tests zu behandeln (sie können Sie noch beißen).

Um ehrlich zu sein, wäre es jedoch besser, wenn storeDocument auch ein Versprechen zurückliefert, anstatt eine hässliche Callback-Funktion verwenden zu müssen.

Ich realisiere, dass es wahrscheinlich eine Menge zu übernehmen ist.