जैस्मीन

Question

onSaveEvent: function (event) { 
       if (this.model !== null) { 
        var that = this; 

        this.model.save(this.model.toJSON(), { 
         success: function (model) { 
          that.model = model; 
          that.model.attributes.isDirty = false; 
         }, 

         error: function (model, xhr) { 
          that.model.attributes.isDirty = true; 
         } 
        }); 
       } 
      } 
     } 

का उपयोग करके सहेजने पर रीढ़ की हड्डी की सफलता और त्रुटि प्रतिक्रिया का परीक्षण करने के लिए यूनिट कैसे करें मॉडल की बचत 'सफलता और जैस्मीन में त्रुटि प्रतिक्रियाओं का परीक्षण कैसे करें?

Answer 1

आप अपने परीक्षणों के लिए नकली सर्वर बनाने के लिए Sinon.js का उपयोग कर सकते हैं।

http://sinonjs.org/

उदाहरण कोड:

describe("when saving a user model", function() { 

    beforeEach(function() { 
     this.server = sinon.fakeServer.create(); 
     this.responseBody = '{"name":"test user","id":1,"title":"tester"}'; 
     this.server.respondWith(
     "POST", 
     "/user", 
     [ 
      200, 
      {"Content-Type": "application/json"}, 
      this.responseBody 
     ] 
    ); 
     this.eventSpy = sinon.spy(); 
    }); 

    afterEach(function() { 
     this.server.restore(); 
    }); 

    it("should not save when name is blank", function() { 
     this.user.bind("error", this.eventSpy); 
     this.user.save({"name": ""}); 

     expect(this.eventSpy).toHaveBeenCalledOnce();  
     expect(this.eventSpy).toHaveBeenCalledWith(this.user, "cannot have a blank name"); 
    }); 

    it("should call the server", function() { 
     this.user.save(); 
     expect(this.server.requests[0].method).toEqual("POST"); 
     expect(this.server.requests[0].url).toEqual("/user"); 
     expect(JSON.parse(this.server.requests[0].requestBody)).toEqual(this.user.attributes); 
    }); 

    }); 

Answer 2

आप सर्वर प्रतिक्रियाओं का अनुकरण करने सिनोन की जरूरत है। इस पुस्तकालय इस तरह उपयोगिताओं है:

this.server.respondWith("GET", "/episode/123", 
     [200, {"Content-Type": "application/json"}, 
     '{"id":123,"title":"Hollywood - Part 2"}']); 

तो जब भी आप जड़ प्रकरण और आईडी 123 के साथ एक मॉडल है, सिनोन लाए जाने फोन पर इस वापस आ जाएगी।

इस पढ़ें: http://tinnedfruit.com/2011/03/03/testing-backbone-apps-with-jasmine-sinon.html

अद्यतन: प्रश्नकर्ता अनुरोध के रूप में एक दूसरे वैकल्पिक हल जोड़ा जा रहा है। सहेजने की विधि का मज़ाक उड़ाओ।

// उपयोग इस Backbone.js मॉडल

var ExtendedModel = Backbone.Model.extend({ 
    //mocked save: 
    save : function(data, options){ 
     if(data){ 
      this.set(data); 
     } 
     var mocked = this.toJSON(); 
     if(!mocked.id){ 
      mocked.id = new Date().getTime(); 
     } 
     mocked = this.parse(mocked); 
     if(options.success){ 
      options.success(this); 
     } 
     if(options.error){ 
      options.error(this); 
     } 
    } 
}); 

var MyModel = ExtendedModel.extend({ 
}); 

हालांकि मैं अभी भी कर रहा हूँ करने के बजाय अपने परीक्षणों में आप सिनोन उपयोग करने के लिए सुझाव देते हैं। Backbone.js का मजाक करना सुरुचिपूर्ण नहीं है और हेडर प्रतिक्रिया कोड का भी समर्थन करता है और अन्य सामान भी अधिक जटिल और पहिया को फिर से शुरू करने का एक प्रकार है। जबकि साइनऑन के साथ आपको लाइब्रेरी को एक सर्वर सर्वर प्रतिक्रिया जोड़ने की आवश्यकता है।

Answer 3

नकली सर्वर के बिना इसका परीक्षण करने के लिए आप परीक्षण कर सकते हैं कि फ़ंक्शन को मॉडल से बांध दिया गया था और उसके बाद बाध्यकारी फ़ंक्शन को कॉल किया गया था। दूसरे शब्दों में मॉडल से बाहर AJAX बचाओ।

var view = new YourView() 
jasmine.spyOne(view.model, 'save') 
view. onSaveEvent() 
var args = view.model.save.mostRecentCall.args 

args[1].success() 
expect(view.model.attributes.isDirty).toBeFalsy() 

args[1].error() 
expect(view.model.attributes.isDirty). toBeTruthy() 

Answer 4

मुझे यकीन है कि मैं यहाँ सिनोन से गुजर रही पसंद, afterall ajax कॉल रीढ़ द्वारा किया जाता है, इकाई परीक्षण किए जाने से नहीं नहीं कर रहा हूँ, यहाँ मेरी समाधान

var Model = Backbone.Model.extend({ 
     success_callback : function (model){ 
     this.model = model; 
     this.model.attributes.isDirty = false; 

     }, 
     error_callback: function (model, xhr){ 

     }, 
     onSaveEvent: function (event) { 

     this.save([], { 
      success: _.bind(this.save_success, this), 
      error: _.bind(this.error_callback, this); 
     }); 
    }); 


    var callback_invoker = function(type_str, which_argument) { 
     this.which_argument = which_argument || 0; 
     this.type_str = type_str; 
     var func = function() { 
     var options = arguments[this.which_argument] || {}; 
     if (this.type_str == 'success') { 
      var run = options.success || function() {}; 

     }else if (this.type_str == 'error') { 
      var run = options.error || function() {}; 
     } 
     run(); 
     }; 
     this.function = _.bind(func, this); 
    }; 

    it('save success calls callback', function() { 
     instance = new Model(); 
     spyOn(instance, 'save_success'); 
     spyOn(_,'bind').andCallThrough(); 
     var invoker = new callback_invoker('success', 1); 
     spyOn(instance, 'save').andCallFake(invoker.function); 
     instance.onSaveEvent(); 
     expect(_.bind).toHaveBeenCalledWith(instance.save_success, instance); 
     expect(instance.save_success).toHaveBeenCalled(); 
    });