appel ramda composer dans la classe nodejs

Question

J'ai la méthode suivante skipLoggingThisRequest dans une classe node js que j'essaie de tester. La méthode est supposée renvoyer true ou false, en fonction du chemin demandé, en utilisant ramda compose pour obtenir cette valeur. Cependant, dans mes tests, quel que soit le chemin que j'ai défini dans l'objet de requête, mon skipLoggingThisRequest retourne toujours vrai.

Qu'est-ce qui me manque ici?

ma classe:

import { compose, filter, join, toPairs, map, prop, flip, contains, test, append } from 'ramda' 
import { create, env } from 'sanctuary' 
import { isEmpty, flattenDeep } from 'lodash' 
import chalk from 'chalk' 
import log from 'menna' 

class MyClass { 

    constructor (headerList) { 
     this.headerWhiteList = flattenDeep(append(headerList, [])); 
    } 

    static getBody (req) { 
     return (!isEmpty(req.body) ? JSON.stringify(req.body) : ''); 
    } 

    static S() { 
     return create({ checkTypes: false, env }); 
    } 

    static isInList() { 
     return flip(contains); 
    } 

    static isInWhitelist() { 
     return compose(this.isInList(this.headerWhiteList), this.S.maybeToNullable, this.S.head); 
    } 

    static parseHeaders() { 
     return (req) => compose(join(','), map(join(':')), filter(this.isInWhitelist), toPairs, prop('headers')); 
    } 

    skipLoggingThisRequest() { 
     return (req) => compose(test(/^.*(swagger|docs|health).*$/), prop('path')) 
    } 

    logger (req, res, next) { 
     if (this.skipLoggingThisRequest(req)) { 
      console.log('Skipping') 
      return next(); 
     } 

     const primaryText = chalk.inverse(`${req.ip} ${req.method} ${req.originalUrl}`); 
     const secondaryText = chalk.gray(`${this.parseHeaders(req)} ${this.getBody(req)}`); 
     log.info(`${primaryText} ${secondaryText}`); 

     return next(); 
    } 
} 

export default MyClass 

Mes tests:

import sinon from 'sinon'; 
import MyClass from '../lib/MyClass'; 

describe('MyClass',() => { 
    const headerList = ['request-header-1', 'request-header-2']; 

    const request = { 
     'headers': { 
      'request-header-1': 'yabadaba', 
      'request-header-2': 'dooooooo' 
     }, 
     'ip': 'shalalam', 
     'method': 'GET', 
     'originalUrl': 'http://myOriginalUrl.com', 
     'body': '' 
    }; 
    const response = {}; 

    const nextStub = sinon.stub(); 

    describe('Logs request',() => { 
     const myInstance = new MyClass(headerList); 
     const skipLogSpy = sinon.spy(myInstance, 'skipLoggingThisRequest'); 
     request.path = '/my/special/path'; 
     myInstance.logger(request, response, nextStub); 
     sinon.assert.called(nextStub); 
    }); 
}); 

Answer 1

this.skipLoggingThisRequest(req) retourne une fonction ((req) => compose(test(/^.*(swagger|docs|health).*$/), prop('path'))).

Il ne renvoie pas de valeur booléenne. Cependant, puisque les fonctions sont vraies, votre instruction if est toujours exécutée.

Ce que vous voulez probablement faire est this.skipLoggingThisRequest()(req). Vous obtenez la fonction, puis vous lui appliquez une requête.

Démonstration de ce qui se passe:

const testFunction =() => (test) => test === "Hello!"; 
 
console.log(testFunction); 
 
console.log(testFunction()); 
 
console.log(testFunction()("Hello!")); 
 
console.log(testFunction()("Goodbye!")); 
 

 
if (testFunction) { 
 
    console.log("testFunction is truthy."); 
 
} 
 

 
if (testFunction()) { 
 
    console.log("testFunction() is truthy."); 
 
} 
 

 
if (testFunction()("Hello!")) { 
 
    console.log('testFunction()("Hello!") is truthy.'); 
 
} 
 

 
if (!testFunction()("Goodbye!")) { 
 
    console.log('testFunction()("Goodbye!") is falsey.'); 
 
}