extjs-mvc 0.4.0.j → 0.4.0.k

data/lib/extjs-mvc/src/spec/Router.spec.js

@@ -0,0 +1,99 @@
+Screw.Unit(function() {
+  describe("The Router", function() {
+    var router;
+    
+    before(function() {
+      router = new ExtMVC.Router();
+    });
+    
+    describe("connect", function() {
+      // it("should create a new Route", function() {
+      //   var routeCreated = false;
+      //   ExtMVC.Route = function() {routeCreated = true;};
+      //   
+      //   router.connect(':controller/:action');
+      //   expect(routeCreated).to(equal, true);
+      // });
+    });
+    
+    describe("name", function() {
+      before(function() {
+        router.name("myRoute", "myNamespace/:controller/:action");
+      });
+      
+      // it("should create a new Route", function() {
+      //   var routeCreated = false;
+      //   
+      //   ExtMVC.Route = ExtMVC.Route.prototype.constructor.createInterceptor(function() {
+      //     routeCreated = true; 
+      //     
+      //     return arguments;
+      //   }, this);
+      //   
+      //   router.connect(':controller/:action');
+      //   expect(routeCreated).to(equal, true);
+      // });
+      
+      it("should make the route accessible as a named route", function() {
+        expect(typeof router.namedRoutes['myRoute']).to_not(equal, "undefined");
+      });
+    });
+    
+    describe("root", function() {
+      before(function() {
+        router.root({controller: 'index', action: 'index'});
+      });
+      
+      
+    });
+    
+    describe("recognising url strings", function() {
+      before(function() {
+        router.connect(":controller/:action/:id");
+        router.connect(":controller/:action");
+      });
+      
+      it("should recognise :controller/:action/:id", function() {
+        expect(router.recognise("index/index")).to_not(equal, false);
+      });
+      
+      it("should return the correct controller", function() {
+        expect(router.recognise("cont/act").controller).to(equal, "cont");
+      });
+      
+      it("should return the correct action", function() {
+        expect(router.recognise("cont/act").action).to(equal, "act");
+      });
+      
+      it("should return the correct id", function() {
+        expect(router.recognise("cont/act/100").id).to(equal, "100");
+      });
+      
+      describe("more complex URLs", function() {
+        before(function() {
+          router.connect("myNamespace/:controller/anotherSegment/:action");
+        });
+        
+        it("should recognise URLS with arbitrary text in the matcher", function() {
+          var url = "myNamespace/cont/anotherSegment/act";
+          expect(router.recognise(url).controller).to(equal, "cont");
+          expect(router.recognise(url).action).to(equal, "act");
+        });
+        
+        describe("with match conditions", function() {
+          before(function() {
+            router.connect("myNamespace/:controller/:action/:id", {conditions: {':id': "[0-9]+"}});
+          });
+          
+          it("should not recognise if the conditions are not met", function() {
+            expect(router.recognise("myNamespace/cont/act/notanumber")).to(equal, false);
+          });
+          
+          it("should recognise if the conditions are met", function() {
+            expect(router.recognise("myNamespace/cont/act/150").id).to(equal, 150);
+          });
+        });
+      });
+    });
+  });
+});

data/lib/extjs-mvc/src/spec/SpecHelper.js

@@ -0,0 +1,106 @@
+Ext.ns('MVCTest', 'MVCTest.models');
+
+ExtMVC.model.modelNamespace = MVCTest.models;
+
+/**
+ * @class MVCTest.models.User
+ * @extends ExtMVC.model
+ */
+ExtMVC.model.define("User", {
+  fields:    [
+    {name: 'id',         type: 'int'},
+    {name: 'first_name', type: 'string'},
+    {name: 'last_name',  type: 'string'},
+    {name: 'email',      type: 'string'}
+  ],
+  hasMany: "BlogPost",
+  
+  displayName: function() {
+    return String.format("{0} {1}", this.data.first_name, this.data.last_name);
+  },
+  
+  //this is used to test instance method inheritance in Model.spec.js
+  earlyJoiner: function() {
+    return this.data.id < 100;
+  },
+  
+  classMethods: {
+    testClassMethod: function() {
+      return "A Class Method";
+    },
+    
+    //simple class method to test class method overwrites
+    methodToOverwrite: function() {
+      return true;
+    }
+  }
+});
+
+/**
+ * @class MVCTest.models.AdminUser
+ * @extends MVCTest.models.User
+ * A subclass of User, defining additional fields
+ */
+ExtMVC.model.define("AdminUser", {
+  extend: "User",
+  fields: [
+    {name: 'is_admin', type: 'bool'},
+    {name: 'password', type: 'string'}
+  ]
+});
+
+/**
+ * @class MVCTest.models.BlogPost
+ * @extends ExtMVC.model
+ */
+ExtMVC.model.define("BlogPost", {
+  fields:    [
+    {name: 'id',      type: 'int'},
+    {name: 'title',   type: 'string'},
+    {name: 'content', type: 'string'},
+    {name: 'user_id', type: 'int'}
+  ],
+  belongsTo: "User",
+  hasMany:   "Comment",
+  
+  instanceMethods: {
+    testInstanceMethod: Ext.emptyFn
+  }
+});
+
+/**
+ * @class MVCTest.models.Comment
+ * @extends ExtMVC.model
+ */
+ExtMVC.model.define("Comment", {
+  fields:    [
+    {name: 'id',           type: 'int'},
+    {name: 'blog_post_id', type: 'int'},
+    {name: 'content',      type: 'string'}
+  ],
+  belongsTo: "BlogPost"
+});
+
+MVCTest.OS = new ExtMVC.OS({
+  name: "MVCTest"
+});
+
+MVCTest.controllers = {};
+
+/**
+ * @class MVCTest.controllers.IndexController
+ * @extends ExtMVC.Controller
+ * Fake controller for use in OS.spec.js, Controller.spec.js and CrudController.spec.js
+ */
+MVCTest.controllers.IndexController = Ext.extend(ExtMVC.Controller, {
+  constructor: function() {
+    //super
+    MVCTest.controllers.IndexController.superclass.constructor.call(this, {
+      viewsPackage: MVCTest.views.index
+    });
+    
+    // this.actsAsCrudController(MVCTest.models.User);
+  }
+});
+
+Ext.ns('MVCTest.views.index');

data/lib/extjs-mvc/src/spec/String.spec.js

@@ -0,0 +1,83 @@
+Screw.Unit(function() {
+  describe("String Functions", function() {
+    it('should capitalize a string', function() {
+      expect("user".capitalize()).to(equal, "User");
+    });
+    
+    it("should titleize a string", function() {
+      expect("a test sentence".titleize()).to(equal, "A Test Sentence");
+    });
+    
+    it("should camelize a string", function() {
+      expect("an_underscored_string".camelize()).to(equal, "AnUnderscoredString");
+    });
+    
+    it("should underscore a string", function() {
+      expect("A string with whitespaces".underscore()).to(equal, "a_string_with_whitespaces");
+    });
+    
+    it("should underscore a camelized string", function() {
+      expect("ALongTableName".underscore()).to(equal, "a_long_table_name");
+    });
+    
+    it("should delegate singularize to Inflector", function() {
+      //stub
+      var singularize_was_called = false;
+      ExtMVC.Inflector.singularize = function() {
+        singularize_was_called = true;
+      };
+      
+      "users".singularize();
+      expect(singularize_was_called).to(equal, true);
+    });
+    
+    it("should delegate pluralize to Inflector", function() {
+      //stub
+      var pluralize_was_called = false;
+      ExtMVC.Inflector.pluralize = function() {
+        pluralize_was_called = true;
+      };
+      
+      "users".pluralize();
+      expect(pluralize_was_called).to(equal, true);
+    });
+    
+    describe("toCurrency", function() {
+      var amount = "1234567.89";
+      
+      it("should add commas as appropriate", function() {
+        expect(amount.toCurrency("£")).to(equal, "£1,234,567.89");
+      });
+      
+      it("should use dollars by default", function() {
+        expect(amount.toCurrency()).to(equal, "$1,234,567.89");
+      });
+    });
+    
+    describe("escaping HTML", function() {
+      var html = '<span>"fish & chips"</span>';
+      var escaped = html.escapeHTML();
+      
+      it("should escape left angle brackets", function() {
+        expect(escaped).to_not(match, /</);
+      });
+      
+      it("should escape right angle brackets", function() {
+        expect(escaped).to_not(match, />/);
+      });
+      
+      it("should escape double-quotes", function() {
+        expect(escaped).to_not(match, /\"/);
+      });
+
+      it("should escape ampersands", function() {
+        expect(escaped).to(match, /(&[^a]|&[^a][^m]|&[^a][^m][^p]|&[^a][^m][^p][^;])/);
+      });      
+      
+      it("should escape a string correctly", function() {
+        expect(escaped).to(equal, "&lt;span&gt;&quot;fish &amp; chips&quot;&lt;/span&gt;");
+      });
+    });
+
+  });
+});

data/lib/extjs-mvc/src/spec/model/AbstractAdapter.spec.js

@@ -0,0 +1,49 @@
+Screw.Unit(function() {
+  describe("The Abstract Adapter", function() {
+    var ns = ExtMVC.Model.modelNamespace;
+    
+    describe("instance methods", function() {
+      it("should add instance methods to Ext.data.Record's prototype", function() {
+        var p = Ext.data.Record.prototype;
+        
+        Ext.each(['save', 'destroy', 'update'], function(methodName) {
+          expect(typeof p[methodName]).to(equal, 'function');
+        }, this);
+      });
+      
+      describe("the save method", function() {
+        
+      });
+    });
+    
+    describe("class methods", function() {
+      it("should add class methods to each model class", function() {
+        Ext.each(['create', 'build', 'find', 'destroy'], function(methodName) {
+          for (var model in ns) {
+            expect(typeof ns[model][methodName]).to(equal, 'function');
+          }
+        }, this);
+      });
+    });
+    
+    describe("hasMany association methods", function() {
+      it("should add the correct methods to the hasMany prototype", function() {
+        var p = ExtMVC.Model.plugin.association.HasMany.prototype;
+        
+        Ext.each(['create', 'build', 'find', 'destroy'], function(methodName) {
+          expect(typeof p[methodName]).to(equal, 'function');
+        }, this);
+      });
+    });
+    
+    describe("belongsTo association methods", function() {
+      it("should add the correct methods to the hasMany prototype", function() {
+        var p = ExtMVC.Model.plugin.association.HasMany.prototype;
+        
+        Ext.each(['find', 'destroy'], function(methodName) {
+          expect(typeof p[methodName]).to(equal, 'function');
+        }, this);
+      });
+    });
+  });
+});

data/lib/extjs-mvc/src/spec/model/Associations.spec.js

@@ -0,0 +1,99 @@
+Screw.Unit(function() {
+  //keep track of the object to which models are currently assigned
+  var ns = ExtMVC.Model.modelNamespace;
+  
+  describe("Associations", function() {
+    ExtMVC.Model.define("AssocUser", {
+      fields:  [],
+      hasMany: "AssocPost"
+    });
+
+    ExtMVC.Model.define("AssocPost", {
+      fields:    [],
+      hasMany:   "AssocComment",
+      belongsTo: "AssocUser"
+    });
+
+    ExtMVC.Model.define("AssocComment", {
+      fields:    [],
+      belongsTo: {
+        associatedClass: "AssocPost",
+        associationName: 'posts',
+        extend: {
+          myMethod: function() {}
+        }
+      }
+    });
+    
+    describe("The Associations plugin", function() {
+      var associations = ExtMVC.Model.plugin.association,
+          model        = ns.AssocPost,
+          commentModel = ns.AssocComment;
+      
+      it("should add a hasMany relationship where defined", function() {
+        expect(model.prototype.AssocComments instanceof associations.HasMany).to(equal, true);
+      });
+      
+      it("should add a belongsTo relationship where defined", function() {
+        expect(model.prototype.AssocUser instanceof associations.BelongsTo).to(equal, true);
+      });
+      
+      it("should allow customisation of association names", function() {
+        expect(commentModel.prototype.posts instanceof associations.BelongsTo).to(equal, true);
+      });
+    });
+    
+    describe("A Base association", function() {
+      /**
+       * Create an association between BlogPost and User.
+       * In practice we never actually instantiate Base associations as they don't
+       * do very much, instead use a subclass such as HasMany or BelongsTo
+       */
+      var assoc = new ExtMVC.Model.plugin.association.Base(ns.BlogPost, ns.User, {
+        extend: {
+          myProperty: 'property',
+          myFunction: function() { return 'result'; }
+        }
+      });
+
+      it("should maintain a reference to its owner class", function() {
+        expect(assoc.ownerClass).to(equal, ns.BlogPost);
+      });
+
+      it("should maintain a reference to its associated class", function() {
+        expect(assoc.associatedClass).to(equal, ns.User);
+      });
+
+      it("should add extension properties to the association", function() {
+        expect(assoc.myProperty).to(equal, 'property');
+        expect(assoc.myFunction()).to(equal, 'result');
+      });
+    });
+
+    describe("A BelongsTo association", function() {
+      //blog post belongs to user
+      var assoc = new ExtMVC.Model.plugin.association.BelongsTo(ns.BlogPost, ns.User);
+
+      it("should set a default association name", function() {
+        expect(assoc.name).to(equal, 'user');
+      });
+
+      it("should set a default foreign key", function() {
+        expect(assoc.foreignKey).to(equal, 'user_id');
+      });
+    });
+
+    describe("A HasMany association", function() {
+      //user has many blog posts
+      var assoc = new ExtMVC.Model.plugin.association.HasMany(ns.User, ns.BlogPost);
+
+      it("should set a default association name", function() {
+        expect(assoc.name).to(equal, 'blog_posts');
+      });
+
+      it("should set a default foreign key", function() {
+        expect(assoc.foreignKey).to(equal, 'user_id');
+      });
+    });
+  });
+});

data/lib/extjs-mvc/src/spec/model/Cache.spec.js

@@ -0,0 +1,5 @@
+Screw.Unit(function() {
+  describe("The Model Cache", function() {
+    
+  });
+});

data/lib/extjs-mvc/src/spec/model/RESTAdapter.spec.js

@@ -0,0 +1,19 @@
+Screw.Unit(function() {
+  describe("The REST adapter", function() {
+    var ns = ExtMVC.Model.modelNamespace;
+    
+    var rest      = new ExtMVC.Model.plugin.adapter.RESTAdapter(),
+        savedInst = new ns.User({title: 'Ed', id: 100}),
+        newInst   = new ns.User({title: 'Nick'});
+        
+    describe("the instanceUrl method", function() {
+      it("should return a url including the ID if the primary key is set", function() {
+        expect(rest.instanceUrl(savedInst)).to(equal, '/users/100');
+      });
+      
+      it("should return a generic url for this model if the primary key is not set", function() {
+        expect(rest.instanceUrl(newInst)).to(equal, '/users');
+      });
+    });
+  });
+});