screw-unit-server 0.3.0 → 0.5.3

data/core/spec/behaviors_spec.js

@@ -2,9 +2,19 @@ Screw.Unit(function() {
   var global_before_invoked = false, global_after_invoked = false;
   before(function() { global_before_invoked = true });
   after(function() { global_after_invoked = true });
-  
+
   describe('Behaviors', function() {
     describe('#run', function() {
+      describe("elapsed time", function() {
+        it("displays the elapsed time after the Suite finishes", function() {
+          var status = $(".status");
+          status.fn("display");
+          var time_elapsed_matches = /([0-9]+\.[0-9]+) seconds/.exec(status.html());
+          var time_elapsed = parseFloat(time_elapsed_matches[1]);
+          expect(time_elapsed > 0.0).to(be_true);
+        });
+      });
+
       describe("a simple [describe]", function() {
         it("invokes the global [before] before an [it]", function() {
           expect(global_before_invoked).to(equal, true);

data/core/spec/matchers_spec.js

@@ -6,15 +6,41 @@ Screw.Unit(function() {
         expect(true).to_not(equal, false);
       });
       
-      describe('when given an object', function() {
-        it("matches Objects with the same keys and values", function() {
-          expect({a: 'b', c: 'd'}).to(equal, {a: 'b', c: 'd'});
-          expect({a: 'b', c: 'd', e: 'f'}).to_not(equal, {a: 'b', c: 'd', e: 'G'});
+      describe('when actual is an object', function() {
+        describe("when expected has the same keys and values", function() {
+          it("matches successfully", function() {
+            expect({a: 'b', c: 'd'}).to(equal, {a: 'b', c: 'd'});
+          });
         });
         
+        describe("when expected has different keys and values", function() {
+          it("does not match", function() {
+            expect({a: 'b', c: 'd', e: 'f'}).to_not(equal, {a: 'b', c: 'd', e: 'G'});
+          });
+        });
+        
+        describe("when expected is undefined", function() {
+          it("does not match", function() {
+            expect({}).to_not(equal, undefined);
+          });
+        });
+      });
+      
+      describe("when actual is undefined", function() {
+        describe("when expected is undefined", function() {
+          it("matches successfully", function() {
+            expect(undefined).to(equal, undefined);
+          });
+        });
+        
+        describe("when expected is an empty object", function() {
+          it("does not match", function() {
+            expect(undefined).to_not(equal, {});
+          });
+        });
       });
       
-      describe('when given an array', function() {
+      describe('when actual is an array', function() {
         it("matches Arrays with the same elements", function() {
           expect([1, 2, 4]).to(equal, [1, 2, 4]);
           expect([1, 2, 3]).to_not(equal, [3, 2, 1]);
@@ -25,7 +51,21 @@ Screw.Unit(function() {
           expect([{a: 'b'}, {c: 'd'}]).to_not(equal, [{a: 'b'}, {c: 'E'}]);
         });
       });
-      
+
+      describe("when actual is a hash", function() {
+        it("matches hashes with the same key-value pairs", function() {
+          expect({"a":"b", "c":"d"}).to(equal, {"a":"b", "c":"d"});
+          expect({"a":"b", "c":"e"}).to_not(equal, {"a":"b", "c":"d"});
+          expect({"a":"b", "d":"d"}).to_not(equal, {"a":"b", "c":"d"});
+        });
+
+        it("recursively applies equality to complex hashes", function() {
+          expect({"a":"b", "c": {"e":"f", "g":"h"}}).to(equal, {"a":"b", "c": {"e":"f", "g":"h"}});
+          expect({"a":"b", "c": {"e":"f", "g":"i"}}).to_not(equal, {"a":"b", "c": {"e":"f", "g":"h"}});
+          expect({"a":"b", "c": {"e":"f", "h":"h"}}).to_not(equal, {"a":"b", "c": {"e":"f", "g":"h"}});
+        });
+      });
+
       describe(".failure_message", function() {
         it('prints "expected [expected] to (not) be equal [actual]"', function() {
           var message = null;
@@ -39,21 +79,21 @@ Screw.Unit(function() {
     });
     
     describe('#match', function() {
-      describe('when given a regular expression', function() {
+      describe('when actual is a regular expression', function() {
         it("matches Strings produced by the grammar", function() {
           expect("The wheels of the bus").to(match, /bus/);
           expect("The wheels of the bus").to_not(match, /boat/);
         });
       });
       
-      describe('when given a string', function() {
+      describe('when actual is a string', function() {
         it("matches [expected]s containing [actual]s", function() {
           expect("The wheels of the bus").to(match, "wheels");
           expect("The wheels of the bus").to_not(match, "oars");
         });
       });
 
-      describe('when given an integer', function() {
+      describe('when actual is an integer', function() {
         it("matches [expected]s containing [actual]s", function() {
           expect("1 time").to(match, 1);
           expect("2 times").to_not(match, 3);
@@ -89,5 +129,244 @@ Screw.Unit(function() {
         });
       });
     });
+
+    describe('#have_length', function() {
+      it("matches Arrays of the expected length", function() {
+        expect([]).to(have_length, 0);
+        expect([1]).to(have_length, 1);
+        expect([1, 2, 3]).to_not(have_length, 4);
+      });
+
+      describe(".failure_message", function() {
+        it("prints 'expected [actual] to (not) have length [expected]", function() {
+          var message = null;
+          try { expect([1, 2]).to(have_length, 4) } catch(e) { message = e }
+          expect(message).to(equal, 'expected [ 1, 2 ] to have length 4');
+          
+          try { expect([1]).to_not(have_length, 1) } catch(e) { message = e }
+          expect(message).to(equal, 'expected [ 1 ] to not have length 1');
+        });
+      });
+    });
+
+    describe('#be_null', function() {
+      it("matches null", function() {
+        expect(null).to(be_null);
+        expect(1).to_not(be_null);
+      });
+
+      describe(".failure_message", function() {
+        it("prints 'expected [actual] to (not) be null", function() {
+          var message = null;
+          try { expect(1).to(be_null) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 1 to be null');
+
+          try { expect(null).to_not(be_null) } catch(e) { message = e }
+          expect(message).to(equal, 'expected null to not be null');
+        });
+      });
+    });
+
+    describe('#be_undefined', function() {
+      it("matches undefined", function() {
+        expect(undefined).to(be_undefined);
+        expect(1).to_not(be_undefined);
+      });
+
+      describe(".failure_message", function() {
+        it("prints 'expected [actual] to (not) be undefined", function() {
+          var message = undefined;
+          try { expect(1).to(be_undefined) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 1 to be undefined');
+
+          try { expect(undefined).to_not(be_undefined) } catch(e) { message = e }
+          expect(message).to(equal, 'expected undefined to not be undefined');
+        });
+      });
+    });
+
+    describe('#be_true', function() {
+      it("matches values that are considered true conditions", function() {
+        expect(true).to(be_true);
+        expect(1).to(be_true);
+        expect(false).to_not(be_true);
+        expect(undefined).to_not(be_true);
+        expect(null).to_not(be_true);
+      });
+
+      describe(".failure_message", function() {
+        it("prints 'expected [actual] to (not) be true", function() {
+          var message = true;
+          try { expect(false).to(be_true) } catch(e) { message = e }
+          expect(message).to(equal, 'expected false to be true');
+
+          try { expect(true).to_not(be_true) } catch(e) { message = e }
+          expect(message).to(equal, 'expected true to not be true');
+        });
+      });
+    });
+
+    describe('#be_false', function() {
+      it("matches values that are considered false conditions", function() {
+        expect(false).to(be_false);
+        expect(undefined).to(be_false);
+        expect(null).to(be_false);
+        expect(true).to_not(be_false);
+        expect(1).to_not(be_false);
+      });
+
+      describe(".failure_message", function() {
+        it("prints 'expected [actual] to (not) be false", function() {
+          var message = false;
+          try { expect(true).to(be_false) } catch(e) { message = e }
+          expect(message).to(equal, 'expected true to be false');
+
+          try { expect(false).to_not(be_false) } catch(e) { message = e }
+          expect(message).to(equal, 'expected false to not be false');
+        });
+      });
+    });
+
+    describe('#match_selector', function() {
+      var elt;
+      before(function() {
+        elt = $("<div class='foo'></div>");
+      });
+
+      it("matches a jQuery element against the expected selector", function() {
+        expect(elt).to(match_selector, 'div.foo');
+        expect(elt).to_not(match_selector, 'div.bar');
+      });
+
+      describe(".failure_message", function() {
+        it("prints 'expected [actual] to (not) match selector [expected]", function() {
+          var message = false;
+          try { expect(elt).to(match_selector, 'div.bar') } catch(e) { message = e }
+          expect(message).to(equal, 'expected $([ <div class="foo"> ]) to match selector div.bar');
+          
+          try { expect(elt).to_not(match_selector, 'div.foo') } catch(e) { message = e }
+          expect(message).to(equal, 'expected $([ <div class="foo"> ]) to not match selector div.foo');
+        });
+      });
+    });
+
+    describe('#contain_selector', function() {
+      var elt;
+      before(function() {
+        elt = $("<div><div class='foo'></div></div>");
+      });
+
+      it("matches a jQuery element against the expected selector", function() {
+        expect(elt).to(contain_selector, 'div.foo');
+        expect(elt).to_not(contain_selector, 'div.bar');
+      });
+
+      describe(".failure_message", function() {
+        it("prints 'expected [actual] to (not) match selector [expected]", function() {
+          var message = false;
+          try { expect(elt).to(contain_selector, 'div.bar') } catch(e) { message = e }
+          expect(message).to(equal, 'expected $([ <div> ]) to contain selector div.bar');
+
+          try { expect(elt).to_not(contain_selector, 'div.foo') } catch(e) { message = e }
+          expect(message).to(equal, 'expected $([ <div> ]) to not contain selector div.foo');
+        });
+      });
+    });
+
+    describe('#be_gt', function() {
+      it('matches integers greater than the expected value', function() {
+        expect(2).to(be_gt, 1);
+        expect(1).to(be_gt, 0);
+        expect(0).to(be_gt, -1);
+        expect(0).to_not(be_gt, 0);
+        expect(-1).to_not(be_gt, 0);
+        expect(0).to_not(be_gt, 1);
+        expect(1).to_not(be_gt, 5);
+      });
+
+      describe(".failure_message", function() {
+        it('prints "expected [expected] to (not) be greater than [actual]"', function() {
+          var message = null;
+          try { expect(1).to(be_gt, 2) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 1 to be greater than 2');
+          
+          try { expect(2).to_not(be_gt, 1) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 2 to not be greater than 1');
+        });
+      });
+    });
+
+    describe('#be_gte', function() {
+      it('matches integers greater than or equal to the expected value', function() {
+        expect(2).to(be_gte, 1);
+        expect(1).to(be_gte, 0);
+        expect(0).to(be_gte, -1);
+        expect(-1).to(be_gte, -1);
+        expect(0).to(be_gte, 0);
+        expect(1).to(be_gte, 1);
+        expect(-1).to_not(be_gte, 0);
+        expect(0).to_not(be_gte, 1);
+        expect(1).to_not(be_gte, 5);
+      });
+
+      describe(".failure_message", function() {
+        it('prints "expected [expected] to (not) be greater than or equal to [actual]"', function() {
+          var message = null;
+          try { expect(1).to(be_gte, 2) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 1 to be greater than or equal to 2');
+          
+          try { expect(2).to_not(be_gte, 1) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 2 to not be greater than or equal to 1');
+        });
+      });
+    });
+
+    describe('#be_lt', function() {
+      it('matches integers less than the expected value', function() {
+        expect(1).to(be_lt, 2);
+        expect(0).to(be_lt, 1);
+        expect(-1).to(be_lt, 0);
+        expect(0).to_not(be_lt, 0);
+        expect(0).to_not(be_lt, -1);
+        expect(1).to_not(be_lt, 0);
+        expect(5).to_not(be_lt, 1);
+      });
+
+      describe(".failure_message", function() {
+        it('prints "expected [expected] to (not) be less than [actual]"', function() {
+          var message = null;
+          try { expect(2).to(be_lt, 1) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 2 to be less than 1');
+          
+          try { expect(1).to_not(be_lt, 2) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 1 to not be less than 2');
+        });
+      });
+    });
+
+    describe('#be_lte', function() {
+      it('matches integers less than or equal to the expected value', function() {
+        expect(1).to(be_lte, 2);
+        expect(0).to(be_lte, 1);
+        expect(-1).to(be_lte, 0);
+        expect(-1).to(be_lte, -1);
+        expect(0).to(be_lte, 0);
+        expect(1).to(be_lte, 1);
+        expect(0).to_not(be_lte, -1);
+        expect(1).to_not(be_lte, 0);
+        expect(5).to_not(be_lte, 1);
+      });
+
+      describe(".failure_message", function() {
+        it('prints "expected [expected] to (not) be less than or equal to [actual]"', function() {
+          var message = null;
+          try { expect(2).to(be_lte, 1) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 2 to be less than or equal to 1');
+          
+          try { expect(1).to_not(be_lte, 2) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 1 to not be less than or equal to 2');
+        });
+      });
+    });
   });
 });

data/core/spec/print_spec.js

@@ -48,16 +48,41 @@ Screw.Unit(function() {
     
     describe('when given a function', function() {
       it("returns the function's signature", function() {
-        expect($.print(function() {})).to(equal, 'function ()');
-        expect($.print(function foo() {})).to(equal, 'function foo()');
-        expect($.print(function foo(bar) {})).to(equal, 'function foo(bar)');
+        expect($.print(function() {})).to(match, /function\s*\(\)/);
+        expect($.print(function foo() {})).to(match, /function\s*foo\(\)/);
+        expect($.print(function foo(bar) {})).to(match, /function\s*foo\(bar\)/);
       });        
     });
 
+    describe('when given a RegExp', function() {
+      it('should print the regexp', function() {
+        expect($.print(/abc/i)).to(equal, '/abc/i');
+      });
+    });
+
+    describe('when given NaN', function() {
+      it('should print the string "NaN"', function() {
+        expect($.print(NaN)).to(equal, 'NaN');
+      });
+    });
+
+    describe('when given 0', function() {
+      it('should print the string "0"', function() {
+        expect($.print(0)).to(equal, '0');
+      });
+    });
+    
     describe('when given an element', function() {
       it("returns the string representation of the element", function() {
-        expect($.print($('<div>').get(0))).to(equal, '<div>');
-        expect($.print($('<div foo="bar">').get(0))).to(equal, '<div>');
+        expect($.print($('<div></div>').get(0))).to(equal, '<div>');
+        expect($.print($('<div foo="bar"></div>').get(0))).to(equal, '<div>');
+        expect($.print($('<div class="foo" id="bar"></div>').get(0))).to(equal, '<div class="foo" id="bar">');
+      });
+
+      describe('when the element is an img', function() {
+        it('prints out the img src attribute', function() {
+          expect($.print($('<img src="test.png"/>'))).to(match, /<img src=".+?test.png">/);
+        })
       });
     });
 
@@ -89,12 +114,26 @@ Screw.Unit(function() {
       });
     });
 
+    describe('when given arguments', function() {
+      it("returns the printed array of elements ", function() {
+        var args = null;
+        (function(){ args = arguments })(1,2,3);
+        expect($.print(args)).to(equal, '[ 1, 2, 3 ]');
+      });
+    });
+
     describe('when given a jQuery', function() {
-      it("returns the printed array of elements engirthed in '$()' ", function() {
-        expect($.print($('<div>'))).to(equal, '$([ <div> ])');
+      it("returns the printed array of elements engirthed in '$()'", function() {
+        expect($.print($('<div></div>'))).to(equal, '$([ <div> ])');
       });
     });
     
+    describe('when given a NodeList', function() {
+      it("returns the printed array of elements in the list", function() {
+        expect($.print(document.getElementsByTagName('body'))).to(equal, '[ <body> ]');
+      });
+    });
+
     describe('when given an object', function() {
       it("returns the keys and values of the object, enraptured with curly braces", function() {
         expect($.print({})).to(equal, '{}');
@@ -110,7 +149,7 @@ Screw.Unit(function() {
           it("returns elipses for circularities", function() {
             var circular = {};
             circular[0] = circular;
-            expect($.print(circular)).to(equal, '{ 0: { 0: ... } }');
+            expect($.print(circular)).to(equal, '{ 0: ... }');
           });
         });
       });

data/core/spec/suite.html

@@ -1,6 +1,6 @@
 <html>
   <head>
-    <script src="../lib/jquery-1.2.3.js"></script>
+    <script src="../lib/jquery-1.3.2.js"></script>
     <script src="../lib/jquery.fn.js"></script>
     <script src="../lib/jquery.print.js"></script>
     <script src="../lib/screw.builder.js"></script>
@@ -11,6 +11,7 @@
     <script src="behaviors_spec.js"></script>
     <script src="matchers_spec.js"></script>
     <script src="print_spec.js"></script>
+    <script src="with_screw_context_spec.js"></script>
 
     <link rel="stylesheet" href="../lib/screw.css">
   </head>