demande de back-end GET moquée pas visée par la méthode de service

Question

Je construis un test pour un nom de contrôleur GeneController qui utilise un service appelé Gene pour faire un tas d'API requêtes GET. Je suis moqué de la principale requête GET comme ça et je suis assez sûr qu'il fonctionne correctement:

$httpBackend.expectGET '/api/knowledge/genes/param1' 
     .respond(200, JSON.stringify({ 
     data: { 
     mutationsUrl: 'http://localhost:3000/api/knowledge/genes/param1/mutations', 
     frequenciesUrl: 'http://localhost:3000/api/knowledge/genes/param1/frequencies', 
     annotationUrl: 'http://localhost:3000/api/knowledge/genes/param1/annotation', 
     sections: { 
     description: { 
      data: 'holder' 
      } 
     } 
     } 
     })) 

Controller: GeneController

.controller 'GeneController', Array '$scope', '$routeParams', '$http', 'Gene', ($scope, $routeParams, $http, Gene) -> 

    $scope.entity = Gene.get($routeParams 
     (entity) -> 
     $scope.description = entity.data.sections.description.data 

     entity.getUrl entity.data.mutationsUrl, {limit: 10}, (err, mutationsData) -> 
      if ! err? 
      for m in mutationsData.data 
       m.selected = true 
      $scope.mutations = mutationsData 

     entity.getUrl entity.data.frequenciesUrl, {}, (err, frequenciesData) -> 
      if ! err? 
      $scope.frequencies = frequenciesData 

     entity.getUrl entity.data.annotationUrl, {}, (err, annotationData) -> 
      if ! err? 
      $scope.annotation = annotationData 

     (error) -> 
     console.log error 
    ) 

Service: Gene

.factory 'Gene', Array '$resource', '$http', ($resource, $http) -> 
     Gene = $resource '/api/knowledge/genes/:gene', {}, 
     query: 
      method: 'GET' 

     Gene.prototype.getUrl = (url, options, callback) -> 
     $http {method: 'GET', url: url, params: options} 
      .then (res) -> # Success callback 
      callback null, res.data 
      ,(res) -> # Error callback 
      callback res.status, res.data 

     Gene 

Le problème que j'ai est avec les demandes GET "secondaires" qui sont facilitées par le Gene.pr Méthode ototype.getUrl Je pense que la méthode elle-même fonctionne bien parce que le contenu approprié (des mutations, des fréquences et des annotations) est affiché sur la page Web. Cependant, ces requêtes GET échouent et j'obtiens l'erreur suivante de mocha: "undefined n'est pas un objet (évaluant 'mutationsData.data')".

J'ai raillé les réponses à ces demandes GET en vain. Voici mon test pour le contrôleur.

test

... 

describe 'GeneController',() -> 

    Gene = undefined 

    beforeEach inject (_$controller_, $rootScope, _Gene_, _$httpBackend_) -> 
     scope = $rootScope.$new() 
     controller = _$controller_ 'GeneController', { 
     $scope: scope 
     $routeParams: { gene: 'param1' } 
     } 
     Gene: _Gene_ 
     $httpBackend = _$httpBackend_ 

    describe 'valid response',() -> 

     beforeEach() -> 
     $httpBackend.whenGET 'http://localhost:3000/api/knowledge/genes/param1/mutations' 
      .respond(200, JSON.stringify({ 
      data: "something" 
      })) 

     $httpBackend.whenGET 'http://localhost:3000/api/knowledge/genes/param1/frequencies' 
      .respond(200, JSON.stringify({ 
      data: 'somethingelse' 
     })) 

     $httpBackend.whenGET 'http://localhost:3000/api/kowledge/gene/param1/annotation' 
      .respond(200, JSON.stringify({ 
      data: 'somethingelser' 
     })) 

     $httpBackend.expectGET '/api/knowledge/genes/param1' 
      .respond(200, JSON.stringify({ 
      data: { 
      mutationsUrl: 'http://localhost:3000/api/knowledge/genes/param1/mutations', 
      frequenciesUrl: 'http://localhost:3000/api/knowledge/genes/param1/frequencies', 
      annotationUrl: 'http://localhost:3000/api/knowledge/genes/param1/annotation', 
      sections: { 
       description: { 
       data: 'holder' 
       } 
      } 
      } 
     })) 

     $httpBackend.flush() 

     it "should set $scope.description when the Gene is called",() -> 
     expect(scope.description).to.equal "holder" 

Toute aide à ce problème serait très apprécié. Je suis complètement coincé là-dessus. Merci d'avance :)

Answer 1

Le contrôleur faisait des appels à notre API de repos d'une manière non-reposante. J'ai divisé chaque demande GET dans son propre bloc de code, en utilisant restangular pour implémenter les promesses:

.controller 'GeneController', Array '$scope', '$routeParams', 'Gene', 'Restangular', ($scope, $routeParams, Gene, Restangular) -> 

    _genes_ = Restangular.all('knowledge').all('genes') 

    _genes_.get($routeParams.gene).then (results) -> 
     $scope.entity = results.data 
     $scope.description = $scope.entity.data.sections.description.data 
    .catch (error) -> 
     console.log 'Unable to load genes data' 

    _genes_.all($routeParams.gene).get('mutations').then (results) -> 
     for m in results.data.data 
     m.selected = true 
     $scope.mutations = results.data 
    .catch (error) -> 
     console.log 'Unable to load mutations data' 

    _genes_.all($routeParams.gene).get('frequencies').then (results) -> 
     $scope.frequencies = results.data 
    .catch (error) -> 
     console.log 'Unable to load frequencies data' 

    _genes_.all($routeParams.gene).get('annotation').then (results) -> 
     $scope.annotation = results.data 
    .catch (error) -> 
     console.log 'Unable to load annotation data'