pivotal-screw-unit-server 0.5.3

data/core/lib/screw.matchers.js

@@ -0,0 +1,244 @@
+Screw.Matchers = (function($) {
+  return matchers = {
+    expect: function(actual) {
+      var funcname = function(f) {
+          var s = f.toString().match(/function (\w*)/)[1];
+          if ((s == null) || (s.length == 0)) return "anonymous";
+          return s;
+      };
+
+      var stacktrace = function() {
+          var s = "";
+          for(var a = arguments.caller; a != null; a = a.caller) {
+              s += funcname(a.callee) + "\n";
+              if (a.caller == a) break;
+          }
+          return s;
+      };
+
+      return {
+        to: function(matcher, expected, not) {
+          var matched = matcher.match(expected, actual);
+          if (not ? matched : !matched) {
+            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 (!this.match(expected[key], actual[key])) return false;
+          for (var key in actual)
+            if (!this.match(actual[key], expected[key])) return false;
+          return true;
+        }
+        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)
+          return expected.exec(actual.toString());
+        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');
+      }
+    },
+
+    be_blank: {
+      match: function(expected, actual) {
+        if (actual == undefined) return true;
+        if (typeof(actual) == "string") actual = actual.replace(/^\s*(.*?)\s*$/, "$1");
+        return Screw.Matchers.be_empty.match(expected, actual);
+      },
+
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not be blank' : ' to be blank');
+      }
+    },
+
+    have_length: {
+      match: function(expected, actual) {
+        if (actual.length == undefined) throw(actual.toString() + " does not respond to length");
+
+        return actual.length == expected;
+      },
+
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not' : ' to') + ' have length ' + expected;
+      }
+    },
+
+    be_null: {
+      match: function(expected, actual) {
+        return actual == null;
+      },
+
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not be null' : ' to be null');
+      }
+    },
+
+    be_undefined: {
+      match: function(expected, actual) {
+        return actual == undefined;
+      },
+
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not be undefined' : ' to be undefined');
+      }
+    },
+
+    be_true: {
+      match: function(expected, actual) {
+        return actual;
+      },
+
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not be true' : ' to be true');
+      }
+    },
+
+    be_false: {
+      match: function(expected, actual) {
+        return !actual;
+      },
+
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not be false' : ' to be false');
+      }
+    },
+
+    match_html: {
+      munge: function(mungee) {
+        if (mungee instanceof jQuery) {
+          mungee = mungee.html();
+        } else if (typeof(mungee) == "string") {
+          var span = document.createElement("span");
+          span.innerHTML = mungee;
+          mungee = span.innerHTML;
+        }
+
+        var regEx = /\sjQuery\d+=['"]\d+['"]/g;
+        mungee = mungee.replace(regEx, "");
+
+        return mungee;
+      },
+
+      match: function(expected, actual) {
+        var trimmedExpected = this.munge(expected);
+        var trimmedActual = this.munge(actual);
+        return trimmedActual.indexOf(trimmedExpected) > -1;
+      },
+
+      failure_message: function(expected, actual, not) {
+        var trimmedExpected = this.munge(expected);
+        var trimmedActual = this.munge(actual);
+        return 'expected ' + $.print(trimmedActual, { max_string: 300 }) +
+               (not ? ' to not contain ' : ' to contain ') + $.print(trimmedExpected, { max_string: 300 });
+      }
+    },
+
+    match_selector: {
+      match: function(expected, actual) {
+        if (!(actual instanceof jQuery)) {
+          throw expected.toString() + " must be an instance of jQuery to match against a selector"
+        }
+
+        return actual.is(expected);
+      },
+
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not match selector ' : ' to match selector ') + expected;
+      }
+    },
+
+    contain_selector: {
+      match: function(expected, actual) {
+        if (!(actual instanceof jQuery)) {
+          throw expected.toString() + " must be an instance of jQuery to match against a selector"
+        }
+
+        return actual.find(expected).length > 0;
+      },
+
+      failure_message: function(expected, actual, not) {
+        return 'expected ' + $.print(actual) + (not ? ' to not contain selector ' : ' to contain selector ') + expected;
+      }
+    }
+  }
+})(jQuery);

data/core/spec/behaviors_spec.js

@@ -0,0 +1,188 @@
+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);
+          global_before_invoked = false;
+        });
+
+        it("invokes the global [before] before each [it]", function() {
+          expect(global_before_invoked).to(equal, true);
+          global_after_invoked = false;
+        });
+
+        it("invokes the global [after] after an [it]", function() {
+          expect(global_after_invoked).to(equal, true);
+        });
+      });
+      
+      describe("a [describe] with a [before] and [after] block", function() {
+        var before_invoked = false, after_invoked = false;
+        before(function() { before_invoked = true });
+        after(function() { after_invoked = true });
+      
+        describe('[after] blocks', function() {
+          it("does not invoke the [after] until after the first [it]", function() {
+            expect(after_invoked).to(equal, false);
+          });
+          
+          it("invokes the [after] after the first [it]", function() {
+            expect(after_invoked).to(equal, true);
+            after_invoked = false;
+          });
+          
+          it("invokes the [after] after each [it]", function() {
+            expect(after_invoked).to(equal, true);
+          });
+        });
+      
+        describe('[before] blocks', function() {
+          it("invokes the [before] before an it", function() {
+            expect(before_invoked).to(equal, true);
+            before_invoked = false;
+          });
+      
+          it("invokes the [before] before each it", function() {
+            expect(before_invoked).to(equal, true);
+          });
+        });
+      });
+
+      describe("A [describe] with two [before] and two [after] blocks", function() {
+        var before_invocations = [], after_invocations = [];
+        before(function() { before_invocations.push('before 1') });
+        before(function() { before_invocations.push('before 2') });
+        
+        after(function() { after_invocations.push('after 1') });
+        after(function() { after_invocations.push('after 2') });
+        
+        it("invokes the [before]s in lexical order before each [it]", function() {
+          expect(before_invocations).to(equal, ['before 1', 'before 2']);
+        });
+
+        it("invokes the [afters]s in lexical order after each [it]", function() {
+          expect(after_invocations).to(equal, ['after 1', 'after 2']);
+        });
+      });
+
+      describe("A describe with a nested describe", function() {
+        var before_invocations = [], after_invocations = [];
+        before(function() {
+          before_invocations = [];
+          before_invocations.push("outermost before");
+        });
+
+        after(function() {
+          after_invocations = [];
+          after_invocations.push("outermost after");
+        });
+      
+        it("outside a nested [describe], does not invoke any of the nested's [before]s", function() {
+          expect(before_invocations).to(equal, ["outermost before"]);
+        });
+        
+        it("outside a nested [describe], does not invoke any of the nested's [after]s", function() {
+          expect(after_invocations).to(equal, ["outermost after"]);
+        });
+        
+        describe("a nested [describe]", function() {
+          before(function() {
+            before_invocations.push("inner before");
+          });
+
+          after(function() {
+            after_invocations.push("inner after");
+          });
+
+          it("runs [before]s in the parent [describe] before each [it]", function() {
+            expect(before_invocations).to(equal, ["outermost before", "inner before"]);
+          });
+
+          it("runs [after]s in the parent [describe] after each [it]", function() {
+            expect(after_invocations).to(equal, ["outermost after", "inner after"]);
+          });
+          
+          describe("a doubly nested [describe]", function() {
+            before(function() {
+              before_invocations.push('innermost before');
+            });
+
+            after(function() {
+              after_invocations.push('innermost after');
+            });
+  
+            describe('[before] blocks', function() {
+              it("runs [before]s in all ancestors before an [it]", function() {
+                expect(before_invocations).to(equal, ["outermost before", "inner before", "innermost before"]);
+              });
+  
+              it("runs [before]s in all ancestors before each [it]", function() {
+                expect(before_invocations).to(equal, ["outermost before", "inner before", "innermost before"]);
+              });
+            });
+            
+            describe('[after] blocks', function() {
+              it("runs [after]s in all ancestors after an [it]", function() {
+                expect(after_invocations).to(equal, ["outermost after", "inner after", "innermost after"]);
+              });
+  
+              it("runs [after]s in all ancestors after each [it]", function() {
+                expect(after_invocations).to(equal, ["outermost after", "inner after", "innermost after"]);
+              });
+            });
+          });
+        });
+      });
+
+      describe("A describe block with exceptions", function() {
+        var after_invoked = false;
+        after(function() {
+          after_invoked = true;
+        });
+        
+        describe("an exception in a test", function() {
+          it("fails because it throws an exception", function() {
+            throw('an exception');
+          });
+          
+          it("invokes [after]s even if the previous [it] raised an exception", function() {
+            expect(after_invoked).to(equal, true);
+          });
+        });
+      });
+    });
+
+    describe("#selector", function() {
+      describe('a [describe]', function() {
+        it('manufactures a CSS selector that uniquely locates the [describe]', function() {
+          $('.describe').each(function() {
+            expect($($(this).fn('selector')).get(0)).to(equal, $(this).get(0))
+          });
+        });
+      });
+
+      describe('an [it]', function() {
+        it('manufactures a CSS selector that uniquely locates the [it]', function() {
+          $('.it').each(function() {
+            expect($($(this).fn('selector')).get(0)).to(equal, $(this).get(0))
+          });
+        });
+      });
+    });
+  });
+});

data/core/spec/matchers_spec.js

@@ -0,0 +1,372 @@
+Screw.Unit(function() {
+  describe("Matchers", function() {
+    describe('#equal', function() {
+      it("invokes the provided matcher on a call to expect", function() {
+        expect(true).to(equal, true);
+        expect(true).to_not(equal, false);
+      });
+      
+      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 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]);
+        });
+        
+        it("recursively applies equality to complex elements", function() {
+          expect([{a: 'b'}, {c: 'd'}]).to(equal, [{a: 'b'}, {c: 'd'}]);
+          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;
+          try { expect(1).to(equal, 2) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 1 to equal 2');
+          
+          try { expect(1).to_not(equal, 1) } catch(e) { message = e }
+          expect(message).to(equal, 'expected 1 to not equal 1');
+        });
+      });
+    });
+    
+    describe('#match', 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 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 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);
+        });
+      });
+      
+      describe(".failure_message", function() {
+        it('prints "expected [actual] to (not) match [expected]', function() {
+          var message = null;
+          try { expect("hello").to(match, "schmello") } catch(e) { message = e }
+          expect(message).to(equal, 'expected "hello" to match "schmello"');
+          
+          try { expect("hello").to_not(match, "ello") } catch(e) { message = e }
+          expect(message).to(equal, 'expected "hello" to not match "ello"');
+        });
+      });
+    });
+    
+    describe('#be_empty', function() {
+      it("matches Arrays with no elements", function() {
+        expect([]).to(be_empty);
+        expect([1]).to_not(be_empty);
+      });
+      
+      describe(".failure_message", function() {
+        it("prints 'expected [actual] to (not) be empty", function() {
+          var message = null;
+          try { expect([1]).to(be_empty) } catch(e) { message = e }
+          expect(message).to(equal, 'expected [ 1 ] to be empty');
+          
+          try { expect([]).to_not(be_empty) } catch(e) { message = e }
+          expect(message).to(equal, 'expected [] to not be empty');
+        });
+      });
+    });
+
+    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');
+        });
+      });
+    });
+  });
+});