screw-unit 0.3.1 → 0.3.3

data/CHANGES

@@ -1,3 +1,9 @@
+0.3.3
+- Fixed for latest version of Selenium, Rack, and Thin
+
+0.3.2
+- Upgrading to ScrewUnit 0.3.2
+
 0.3.1
 - Client accepts selenium_server_start_command parameter, which allows the user to parameterize the selenium_server_start_command
 - Added support for running specs in Internet Explorer via POST /runners/iexplore
@@ -8,4 +14,4 @@
 - Uses ScrewUnit 0.3.0
 
 0.1.0
-- Initial Release
+- Initial Release

data/core/CHANGES

@@ -0,0 +1,10 @@
+0.3.3
+- Fixed for latest version of Selenium, Rack, and Thin
+
+0.3.2
+- Adding IE support
+- Fix printing of 0 as 'NaN'
+
+0.2.0
+- Added elapsed time information in test suite run.
+- Equal matchers works with complex hash structures

data/core/example/models/man.js

@@ -8,8 +8,8 @@ function Man(options) {
     return luck;
   };
   this.render = function() {
-    return $('<ul class="man">')
-      .append('<li class="hair">')
+    return $('<ul class="man"></ul>')
+      .append('<li class="hair"></li>')
       .click(function() {
         $(this).children('.hair').remove();
       });

data/core/lib/jquery.print.js

@@ -82,8 +82,8 @@
       return "undefined";
     else if (typeof obj == 'boolean')
       return obj.toString();
-    else if (!obj && typeof obj == 'number')
-      return 'NaN';
+    else if (typeof obj == 'number')
+      return obj.toString();
     else if (!obj)
       return "null";
     else if (typeof obj == 'string')

data/core/lib/screw.behaviors.js

@@ -2,8 +2,9 @@
   $(Screw).bind('loaded', function() {
     $('.status').fn({
       display: function() {
-        $(this).text(
-          $('.passed').length + $('.failed').length + ' test(s), ' + $('.failed').length + ' failure(s)'
+        $(this).html(
+          $('.passed').length + $('.failed').length + ' test(s), ' + $('.failed').length + ' failure(s)<br />' +
+          ((new Date() - Screw.suite_start_time)/1000.0).toString() + " seconds elapsed"
         );
       }
     });

data/core/lib/screw.builder.js

@@ -18,12 +18,12 @@ var Screw = (function($) {
       context: [],
 
       describe: function(name, fn) {
-        var describe = $('<li class="describe">')
-          .append($('<h1>').text(name))
-          .append('<ol class="befores">')
-          .append('<ul class="its">')
-          .append('<ul class="describes">')
-          .append('<ol class="afters">');
+        var describe = $('<li class="describe"></li>')
+          .append($('<h1></h1>').text(name))
+          .append('<ol class="befores"></ol>')
+          .append('<ul class="its"></ul>')
+          .append('<ul class="describes"></ul>')
+          .append('<ol class="afters"></ol>');
 
         this.context.push(describe);
         fn.call();
@@ -35,8 +35,8 @@ var Screw = (function($) {
       },
 
       it: function(name, fn) {
-        var it = $('<li class="it">')
-          .append($('<h2>').text(name))
+        var it = $('<li class="it"></li>')
+          .append($('<h2></h2>').text(name))
           .data('screwunit.run', fn);
 
         this.context[this.context.length-1]
@@ -45,7 +45,7 @@ var Screw = (function($) {
       },
 
       before: function(fn) {
-        var before = $('<li class="before">')
+        var before = $('<li class="before"></li>')
           .data('screwunit.run', fn);
 
         this.context[this.context.length-1]
@@ -54,7 +54,7 @@ var Screw = (function($) {
       },
 
       after: function(fn) {
-        var after = $('<li class="after">')
+        var after = $('<li class="after"></li>')
           .data('screwunit.run', fn);
 
         this.context[this.context.length-1]
@@ -66,11 +66,11 @@ var Screw = (function($) {
 
   $(screw).queue(function() { $(screw).trigger('loading') });
   $(function() {
-    $('<div class="describe">')
-      .append('<h3 class="status">')
-      .append('<ol class="befores">')
-      .append('<ul class="describes">')
-      .append('<ol class="afters">')
+    $('<div class="describe"></div>')
+      .append('<h3 class="status"></h3>')
+      .append('<ol class="befores"></ol>')
+      .append('<ul class="describes"></ul>')
+      .append('<ol class="afters"></ol>')
       .appendTo('body');
 
     $(screw).dequeue();

data/core/lib/screw.css

@@ -42,7 +42,7 @@ html {
     .describes .describe {
       margin-left: 0.6em;
       padding-left: 0.6em;
-      border: 1px dashed grey;
+      border: 1px dashed #999;
     }
 
       .describes .describe .its {}
@@ -87,4 +87,4 @@ html {
             cursor: pointer;
             color: #000 !important;
             border-bottom: 1px solid #9A8E51;
-          }
+          }

data/core/lib/screw.events.js

@@ -26,16 +26,17 @@
         .bind('failed', function(e, reason) {
           $(this)
             .addClass('failed')
-            .append($('<p class="error">').text(reason.toString()))
+            .append($('<p class="error"></p>').text(reason.toString()));
 
           var file = reason.fileName || reason.sourceURL;
           var line = reason.lineNumber || reason.line;          
           if (file || line) {
-            $(this).append($('<p class="error">').text('line ' + line + ', ' + file));
+            $(this).append($('<p class="error"></p>').text('line ' + line + ', ' + file));
           }
         })
     })
     .bind('before', function() {
+      Screw.suite_start_time = new Date();
       $('.status').text('Running...');
     })
     .bind('after', function() {

data/core/lib/screw.matchers.js

@@ -8,35 +8,77 @@ Screw.Matchers = (function($) {
             throw(matcher.failure_message(expected, actual, not));
           }
         },
-        
+
         to_not: function(matcher, expected) {
           this.to(matcher, expected, true);
         }
       }
     },
-    
+
     equal: {
       match: function(expected, actual) {
+        if(expected == actual) return true;
+        if(actual == undefined) return false;
+
         if (expected instanceof Array) {
           for (var i = 0; i < actual.length; i++)
             if (!Screw.Matchers.equal.match(expected[i], actual[i])) return false;
           return actual.length == expected.length;
         } else if (expected instanceof Object) {
           for (var key in expected)
-            if (expected[key] != actual[key]) return false;
+            if (!this.match(expected[key], actual[key])) return false;
           for (var key in actual)
-            if (actual[key] != expected[key]) return false;
+            if (!this.match(actual[key], expected[key])) return false;
           return true;
-        } else {
-          return expected == actual;
         }
+        return false;
       },
-      
+
       failure_message: function(expected, actual, not) {
         return 'expected ' + $.print(actual) + (not ? ' to not equal ' : ' to equal ') + $.print(expected);
       }
     },
     
+    be_gt: {
+      match: function(expected, actual) {
+        return actual > expected;
+      },
+      
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not ' : ' to ') + 'be greater than ' + $.print(expected);
+      }
+    },
+
+    be_gte: {
+      match: function(expected, actual) {
+        return actual >= expected;
+      },
+      
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not ' : ' to ') + 'be greater than or equal to ' + $.print(expected);
+      }
+    },
+
+    be_lt: {
+      match: function(expected, actual) {
+        return actual < expected;
+      },
+      
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not ' : ' to ') + 'be less than ' + $.print(expected);
+      }
+    },
+
+    be_lte: {
+      match: function(expected, actual) {
+        return actual <= expected;
+      },
+      
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not ' : ' to ') + 'be less than or equal to ' + $.print(expected);
+      }
+    },
+
     match: {
       match: function(expected, actual) {
         if (expected.constructor == RegExp)
@@ -44,19 +86,19 @@ Screw.Matchers = (function($) {
         else
           return actual.indexOf(expected) > -1;
       },
-      
+
       failure_message: function(expected, actual, not) {
         return 'expected ' + $.print(actual) + (not ? ' to not match ' : ' to match ') + $.print(expected);
       }
     },
-    
+
     be_empty: {
       match: function(expected, actual) {
         if (actual.length == undefined) throw(actual.toString() + " does not respond to length");
-        
+
         return actual.length == 0;
       },
-      
+
       failure_message: function(expected, actual, not) {
         return 'expected ' + $.print(actual) + (not ? ' to not be empty' : ' to be empty');
       }

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 given an array', function() {
+      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 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);
@@ -233,5 +273,100 @@ Screw.Unit(function() {
       });
     });
 
+    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');
+        });
+      });
+    });
   });
 });