extjs-mvc 0.4.0.j → 0.4.0.k

data/test/app/vendor/extjs-mvc/spec/model/ValidationErrors.spec.js

@@ -0,0 +1,64 @@
+Screw.Unit(function() {
+  describe("A Validation Errors object", function() {
+    var errors = new ExtMVC.Model.validation.Errors();
+    
+    before(function() {
+      //make sure we clear out any errors between each test
+      errors.clear();
+    });
+    
+    it("should contain an object of all errors", function() {
+      expect(errors.all).to(equal, {});
+    });
+    
+    it("should clear current errors out", function() {
+      //add some fake errors
+      errors.all = {'title': ['must be present'], 'text': ['is too short']};
+      
+      errors.clear();
+      expect(errors.all).to(equal, {});
+    });
+    
+    describe("when retrieving errors by field name or for a form", function() {
+      before(function() {
+        errors.add('title', 'must be present');
+        errors.add('title', 'is too short');
+        errors.add('title', 'is quite boring');
+        errors.add('text',  'is a hideous diatribe');
+      });
+      
+      it("should allow retrieval of errors per field via the forField method", function() {
+        expect(errors.forField('title')).to(equal, ['must be present', 'is too short', 'is quite boring']);
+      });
+
+      it("should return a human readable form for errors on a given field", function() {
+        expect(errors.forField('title', true)).to(equal, 'must be present, is too short and is quite boring');
+        expect(errors.forField('text', true)).to(equal, 'is a hideous diatribe');
+      });
+      
+      it("should return the errors in a format suitable for displaying on a FormPanel", function() {
+        var formErrors = {'title': 'must be present, is too short and is quite boring', 'text': 'is a hideous diatribe'};
+        expect(errors.forForm()).to(equal, formErrors);
+      });
+    });
+    
+    it("should allow addition of new errors", function() {
+      expect(errors.forField('title').length).to(equal, 0);
+      
+      errors.add('title', 'must be present');
+      expect(errors.forField('title').length).to(equal, 1);
+      
+      errors.add('title', 'is too short');
+      expect(errors.forField('title').length).to(equal, 2);
+    });
+    
+    it("should be valid if there are no errors", function() {
+      expect(errors.isValid()).to(equal, true);
+    });
+    
+    it("should not be valid if there are errors present", function() {
+      errors.add('title', 'has serious problems');
+      expect(errors.isValid()).to(equal, false);
+    });
+  });
+});

data/test/app/vendor/extjs-mvc/spec/model/Validations.spec.js

@@ -0,0 +1,166 @@
+/**
+ * Tests the validations framework and the built-in validations
+ */
+Screw.Unit(function() {
+  describe("Validation Classes", function() {
+    //keep track of the object to which models are currently assigned
+    var ns = ExtMVC.Model.modelNamespace;
+
+    ExtMVC.Model.define('SomeModel', {
+      fields: [
+        {name: 'title', type: 'string'},
+        {name: 'text',  type: 'string'},
+        {name: 'price', type: 'number'}
+      ]
+    });
+
+    var myInstance = new ns.SomeModel({});
+    var V = ExtMVC.Model.validation;
+
+    describe("Validates Presence Of", function() {
+      var v = new V.ValidatesPresenceOf(ns.SomeModel, 'title');
+
+      it("should not be valid if not present", function() {
+        expect(v.isValid(myInstance)).to(equal, false);
+      });
+
+      it("should not be valid if an empty string", function() {
+        myInstance.set('title', '');
+        expect(v.isValid(myInstance)).to(equal, false);
+      });
+
+      it("should be valid if any value is present", function() {
+        myInstance.set('title', 'My Title');
+        expect(v.isValid(myInstance)).to(equal, true);
+
+        myInstance.set('title', {'some': 'object'});
+        expect(v.isValid(myInstance)).to(equal, true);
+      });
+
+      it("should return a default message", function() {
+        expect(v.message).to(equal, 'must be present');
+      });
+
+      it("should allow specification of a customised message", function() {
+        var v = new V.ValidatesPresenceOf(ns.SomeModel, 'title', {message: 'My Message'});
+        expect(v.message).to(equal, 'My Message');
+      });
+    });
+
+    describe("Validates Numericality Of", function() {
+      var v = new V.ValidatesNumericalityOf(ns.SomeModel, 'price');
+
+      it("should pass if the field is a number", function() {
+        myInstance.set('price', 9.99);
+        expect(v.isValid(myInstance)).to(equal, true);
+      });
+
+      it("should fail if the field is not a number", function() {
+        myInstance.set('price', 'not a number!');
+        expect(v.isValid(myInstance)).to(equal, false);
+
+        expect(v.message).to(equal, 'must be a number');
+      });
+    });
+
+    describe("Validates Length Of", function() {
+      var v = new V.ValidatesLengthOf(ns.SomeModel, 'title', {minimum: 5, maximum: 9});
+
+      it("should fail if the field is too short", function() {
+        myInstance.set('title', 'a');
+        expect(v.isValid(myInstance)).to(equal, false);
+        expect(v.message).to(equal, 'is too short');
+      });
+
+      it("should fail if the field is too long", function() {
+        myInstance.set('title', 'a very long title');
+        expect(v.isValid(myInstance)).to(equal, false);
+        expect(v.message).to(equal, 'is too long');
+      });
+
+      it("should pass if the field is an acceptable length", function() {
+        //minimum
+        myInstance.set('title', 'Adama');
+        expect(v.isValid(myInstance)).to(equal, true);
+
+        //maximum
+        myInstance.set('title', 'President');
+        expect(v.isValid(myInstance)).to(equal, true);
+
+        //in between
+        myInstance.set('title', 'Colonel');
+        expect(v.isValid(myInstance)).to(equal, true);
+      });
+    });
+
+    describe("Validates Inclusion Of", function() {
+      var v = new V.ValidatesInclusionOf(ns.SomeModel, 'title', {allowed: ['test', 'title', 'another title']});
+
+      it("should pass if the field is one of the allowed values", function() {
+        Ext.each(['test', 'title', 'another title'], function(allowedTitle) {
+          myInstance.set('title', allowedTitle);
+          expect(v.isValid(myInstance)).to(equal, true);
+        }, this);
+      });
+
+      it("should fail if the field is not one of the allowed values", function() {
+        myInstance.set('title', 'not an allowed title ');
+        expect(v.isValid(myInstance)).to(equal, false);
+      });
+
+      it("should generate a meaningful message", function() {
+        expect(v.message).to(equal, 'must be one of test, title or another title');
+      });
+
+      it("should allow setting of a custom message", function() {
+        var v = new V.ValidatesInclusionOf(ns.SomeModel, 'title', {allowed: [], message: 'My Message'});
+        expect(v.message).to(equal, 'My Message');
+      });
+    });
+
+    describe("Validates Exclusion Of", function() {
+      var v = new V.ValidatesExclusionOf(ns.SomeModel, 'title', {disallowed: ['test', 'title', 'another title']});
+
+      it("should pass if the field is not one of the disallowed values", function() {
+        myInstance.set('title', 'This is allowed');
+        expect(v.isValid(myInstance)).to(equal, true);
+      });
+
+      it("should fail if the field is one of the disallowed values", function() {
+        Ext.each(['test', 'title', 'another title'], function(disallowedTitle) {
+          myInstance.set('title', disallowedTitle);
+          expect(v.isValid(myInstance)).to(equal, false);
+        }, this);
+      });
+
+      it("should generate a meaningful message", function() {
+        expect(v.message).to(equal, 'must not be test, title or another title');
+      });
+
+      it("should allow setting of a custom message", function() {
+        var v = new V.ValidatesExclusionOf(ns.SomeModel, 'title', {disallowed: [], message: 'My Message'});
+        expect(v.message).to(equal, 'My Message');
+      });
+    });
+
+    describe("Validates Format Of", function() {
+      var v = new V.ValidatesFormatOf(ns.SomeModel, 'title', {regex: /[A-Za-z]*\. [A-Za-z]/});
+
+      it("should pass if the regex matches", function() {
+        myInstance.set('title', 'Mr. Bean');
+
+        expect(v.isValid(myInstance)).to(equal, true);
+      });
+
+      it("should fail if the regex does not match", function() {
+        myInstance.set('title', 'Ed');
+
+        expect(v.isValid(myInstance)).to(equal, false);
+      });
+
+      it("should supply a default message", function() {
+        expect(v.message).to(equal, 'is invalid');
+      });
+    });
+  });
+});

data/test/app/vendor/extjs-mvc/spec/model/ValidationsPlugin.spec.js

@@ -0,0 +1,108 @@
+Screw.Unit(function() {
+  describe("The Validations Plugin", function() {
+    var ns = ExtMVC.Model.modelNamespace;
+    
+    delete ns.ValidatedModel;
+    ExtMVC.Model.define("ValidatedModel", {
+      fields: [
+        {name: 'title', type: 'string'},
+        {name: 'text',  type: 'string'},
+        {name: 'price', type: 'number'}
+      ],
+      validatesPresenceOf:     ['title', 'text'],
+      validatesNumericalityOf: 'price',
+      validatesLengthOf:       {field: 'title', minimum: 5, maximum: 10}
+    });
+    
+    var validations = ns.ValidatedModel.prototype.validations;
+    
+    it("should add a validations array to each model prototype", function() {
+      expect(Ext.isArray(validations)).to(equal, true);
+    });
+    
+    it("should populate the validations array with the correct validations", function() {
+      expect(validations.length).to(equal, 4);
+    });
+    
+    it("should create each validation with a reference to the parent model", function() {
+      Ext.each(validations, function(validation) {
+        expect(validation.ownerClass).to(equal, ns.ValidatedModel);
+      }, this);
+    });
+    
+    it("should add an errors object to each model instance", function() {
+      //make sure it goes on the instance, not the prototype
+      expect(typeof ns.ValidatedModel.prototype.errors == 'undefined').to(equal, true);
+      
+      var myInstance = new ns.ValidatedModel({});
+      expect(myInstance.errors instanceof ExtMVC.Model.validation.Errors).to(equal, true);
+    });
+    
+    describe("the isValid method", function() {
+      /**
+       * Not sure if this is the best place to test this code.  The isValid method is defined
+       * in ExtMVC.Model.validation.Plugin and applied to Ext.data.Record's prototype.  As this
+       * means each Model instance has it available, that's how it's being tested here...
+       */
+      var validInstance = new ns.ValidatedModel({
+        title: 'Title',
+        text:  'My Text',
+        price: 9.99
+      });
+      
+      it("should clear any existing errors", function() {
+        //add a fake error to make sure it gets cleared
+        validInstance.errors.add('title', 'fake error');
+        expect(validInstance.errors.all).to_not(equal, {});
+        
+        validInstance.isValid();
+        expect(validInstance.errors.all).to(equal, {});
+      });
+      
+      it("should return true if there were no errors", function() {
+        expect(validInstance.isValid()).to(equal, true);
+      });
+      
+      describe("if there were any errors", function() {
+        var invalidInstance = new ns.ValidatedModel({
+          price: 'test'
+        });
+        
+        it("should return false", function() {
+          expect(invalidInstance.isValid()).to(equal, false);
+        });
+        
+        it("should add the errors to the errors object", function() {
+          invalidInstance.isValid();
+          
+          //we're expecting an error on title, text and price here
+          Ext.each(['title', 'text', 'price'], function(field) {
+            expect(invalidInstance.errors.forField(field).length).to(equal, 1);
+          }, this);
+        });
+      });
+    });
+    
+    describe("the buildValidation method", function() {
+      var constructor = ExtMVC.Model.validation.ValidatesPresenceOf,
+          validation  = ExtMVC.Model.validation.Plugin.buildValidation(constructor, 'somefield'),
+          validation2 = ExtMVC.Model.validation.Plugin.buildValidation(constructor, {field: 'anotherfield', message: 'test'});
+          
+      it("should return an instance of the correct type", function() {
+        expect(validation instanceof constructor).to(equal, true);
+      });
+      
+      it("should assign the field correctly if passed as a string", function() {
+        expect(validation.field).to(equal, 'somefield');
+      });
+      
+      it("should assign the field correctly if passed inside a config object", function() {
+        expect(validation2.field).to(equal, 'anotherfield');
+      });
+      
+      it("should pass config options except field to the validation's constructor", function() {
+        expect(validation2.message).to(equal, 'test');
+      });
+    });
+  });
+});

data/test/app/vendor/extjs-mvc/spec/suite.html

@@ -0,0 +1,60 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html>
+  <head>
+    <link type="text/css" rel="stylesheet" href="../vendor/screw-unit/lib/screw.css" />
+    <title>Ext MVC Spec Suite</title>
+  </head>
+  <body>
+    <div id="dom_test" style="position: absolute; left: -9999"></div>
+    
+    <!-- Library code (not directly part of the app) -->
+    <div id="libs">
+      <!-- Screw Unit -->
+      <script type="text/javascript" src="../vendor/screw-unit/lib/jquery-1.2.3.js"></script>
+      <script type="text/javascript" src="../vendor/screw-unit/lib/jquery.fn.js"></script>
+      <script type="text/javascript" src="../vendor/screw-unit/lib/jquery.print.js"></script>
+      <script type="text/javascript" src="../vendor/screw-unit/lib/screw.builder.js"></script>
+      <script type="text/javascript" src="../vendor/screw-unit/lib/screw.matchers.js"></script>
+      <script type="text/javascript" src="../vendor/screw-unit/lib/screw.events.js"></script>
+      <script type="text/javascript" src="../vendor/screw-unit/lib/screw.behaviors.js"></script>
+      
+      <!-- ExtJS -->
+      <!-- <script type="text/javascript" src="http://extjs.cachefly.net/builds/ext-cdn-8.js"></script> -->
+      <script type="text/javascript" src="../vendor/ext-base.js"></script>
+      <script type="text/javascript" src="../vendor/ext-all-debug.js"></script>
+      
+      <!-- Ext MVC -->
+      <script type="text/javascript" src="../ext-mvc-all.js"></script>
+    </div>
+    
+    <!-- Specs -->
+    <div id="specs">
+      <script type="text/javascript" src="SpecHelper.js"></script>
+      
+      <!-- General MVC specs -->
+      <script type="text/javascript" src="ExtMVC.spec.js"></script>
+      <script type="text/javascript" src="OS.spec.js"></script>
+       
+      <!-- Model specs -->
+      <script type="text/javascript" src="Model.spec.js"></script>
+      <script type="text/javascript" src="model/Validations.spec.js"></script>
+      <script type="text/javascript" src="model/ValidationErrors.spec.js"></script>
+      <script type="text/javascript" src="model/ValidationsPlugin.spec.js"></script>
+      
+      <script type="text/javascript" src="model/Associations.spec.js"></script>
+      
+      <script type="text/javascript" src="model/AbstractAdapter.spec.js"></script>
+      <script type="text/javascript" src="model/RESTAdapter.spec.js"></script>
+      
+      <!-- Router specs -->
+      <script type="text/javascript" src="Router.spec.js"></script>
+      
+      <!-- Augmentation specs -->
+      <script type="text/javascript" src="String.spec.js"></script>
+      <script type="text/javascript" src="Array.spec.js"></script>
+    </div>
+
+  </body>
+</html>

data/test/app/vendor/extjs-mvc/specs-old/JSSpec.css

@@ -0,0 +1,216 @@
+@CHARSET "UTF-8";
+
+/* --------------------
+ * @Layout
+ */
+
+html {
+  overflow: hidden;
+}
+
+body, #jsspec_container {
+  overflow: hidden;
+  padding: 0;
+  margin: 0;
+  width: 100%;
+  height: 100%;
+}
+
+#title {
+  padding: 0;
+  margin: 0;
+  position: absolute;
+  top: 0px;    
+  left: 0px;
+  width: 100%;
+  height: 40px;
+  overflow: hidden;
+}
+
+#list {
+  padding: 0;
+  margin: 0;
+  position: absolute;    
+  top: 40px;
+  left: 0px;
+  bottom: 0px;
+  overflow: auto;    
+  width: 250px;    
+  _height:expression(document.body.clientHeight-40);
+}
+
+#log {
+  padding: 0;
+  margin: 0;
+  position: absolute;    
+  top: 40px;
+  left: 250px;
+  right: 0px;
+  bottom: 0px;
+  overflow: auto;
+  _height:expression(document.body.clientHeight-40);
+  _width:expression(document.body.clientWidth-250);
+}
+
+
+
+/* --------------------
+ * @Decorations and colors
+ */
+* {
+	padding: 0;
+	margin: 0;
+	font-family: "Lucida Grande", Helvetica, sans-serif;
+}
+
+li {
+	list-style: none;
+}
+
+/* hiding subtitles */
+h2 {
+	display: none;
+}
+
+/* title section */
+div#title {
+	padding: 0em 0.5em;
+}
+
+div#title h1 {
+	font-size: 1.5em;
+	float: left;
+}
+
+div#title ul li {
+	float: left;
+	padding: 0.5em 0em 0.5em 0.75em;
+}
+
+div#title p {
+	float:right;
+	margin-right:1em;
+	font-size: 0.75em;
+}
+
+/* spec container */
+ul.specs {
+	margin: 0.5em;
+}
+ul.specs li {
+	margin-bottom: 0.1em;
+}
+
+/* spec title */
+ul.specs li h3 {
+	font-weight: bold;
+	font-size: 0.75em;
+	padding: 0.2em 1em;
+	cursor: pointer;
+	_cursor: hand;
+}
+
+/* example container */
+ul.examples li {
+	border-style: solid;
+	border-width: 0px 0px 1px 5px;
+	margin: 0.2em 0em 0.2em 1em;
+}
+
+/* example title */
+ul.examples li h4 {
+	font-weight: normal;
+	font-size: 0.75em;
+	margin-left: 1em;
+}
+
+/* example explaination */
+ul.examples li div {
+	padding: 1em 2em;
+	font-size: 0.75em;
+}
+
+/* styles for ongoing, success, failure, error */
+div.success, div.success a {
+	color: #FFFFFF;
+	background-color: #65C400;
+}
+
+ul.specs li.success h3, ul.specs li.success h3 a {
+	color: #FFFFFF;
+	background-color: #65C400;
+}
+
+ul.examples li.success, ul.examples li.success a {
+	color: #3D7700;
+	background-color: #DBFFB4;
+	border-color: #65C400;
+}
+
+div.exception, div.exception a {
+	color: #FFFFFF;
+	background-color: #C20000;
+}
+
+ul.specs li.exception h3, ul.specs li.exception h3 a {
+	color: #FFFFFF;
+	background-color: #C20000;
+}
+
+ul.examples li.exception, ul.examples li.exception a {
+	color: #C20000;
+	background-color: #FFFBD3;
+	border-color: #C20000;
+}
+
+div.ongoing, div.ongoing a {
+	color: #000000;
+	background-color: #FFFF80;
+}
+
+ul.specs li.ongoing h3, ul.specs li.ongoing h3 a {
+	color: #000000;
+	background-color: #FFFF80;
+}
+
+ul.examples li.ongoing, ul.examples li.ongoing a {
+	color: #000000;
+	background-color: #FFFF80;
+	border-color: #DDDD00;
+}
+
+
+
+/* --------------------
+ * values
+ */
+.number_value, .string_value, .regexp_value, .boolean_value, .dom_value {
+	font-family: monospace;
+	color: blue;
+}
+.object_value, .array_value {
+	line-height: 2em;
+	padding: 0.1em 0.2em;
+	margin: 0.1em 0;
+}
+.date_value {
+	font-family: monospace;
+	color: olive;
+}
+.undefined_value, .null_value {
+	font-style: italic;
+	color: blue;
+}
+.dom_attr_name {
+}
+.dom_attr_value {
+	color: red;
+}
+.dom_path {
+	font-size: 0.75em;
+	color: gray;
+}
+strong {
+	font-weight: normal;
+	background-color: #FFC6C6;
+}