Add startsWith and endsWith for URLs.

README.md

@@ -31,6 +31,8 @@ Lead Maintainer - [Eran Hammer](https://github.com/hueniverse)
             - [`null()`](#null)
             - [`undefined()`](#undefined)
         - [`include(values)`](#includevalues)
+        - [`startWith(value)`](#startwithvalue)
+        - [`endWith(value)`](#startwithvalue)
         - [`exist()`](#exist)
         - [`empty()`](#empty)
         - [`length(size)`](#lengthsize)
@@ -352,6 +354,38 @@ expect({ a: 1, b: 2, c: 3 }).to.only.include({ a: 1, b: 2, c: 3 });
 expect({ a: [1], b: [2], c: [3] }).to.deep.include({ a: [1], c: [3] });
 ```
 
+#### `startWith(value)`
+
+Aliases: `startsWith()`,
+
+Asserts that the reference value (a string) starts with the provided value where:
+- `value` - a string.
+
+Note that this assertion is case sensitive.
+
+```js
+var Code = require('code');
+var expect = Code.expect;
+
+expect('https://example.org/secure').to.startWith('https://');
+```
+
+#### `endWith(value)`
+
+Aliases: `endsWith()`,
+
+Asserts that the reference value (a string) ends with the provided value where:
+- `value` - a string.
+
+Note that this assertion is case sensitive.
+
+```js
+var Code = require('code');
+var expect = Code.expect;
+
+expect('http://example.org/relative').to.endWith('/relative');
+```
+
 #### `exist()`
 
 Aliases: `exists`

lib/index.js

@@ -119,6 +119,22 @@ internals.addMethod(['include', 'includes', 'contain', 'contains'], function (va
     return this.assert(Hoek.contain(this._ref, value, this._flags), 'include ' + internals.display(value));
 });
 
+internals.addMethod(['endWith', 'endsWith'], function (value) {
+
+    internals.assert(this, typeof this._ref === 'string' && typeof value === 'string', 'Can only assert endsWith on a string, with a string');
+
+    var comparator = this._ref.slice(-value.length);
+    return this.assert(comparator === value, 'endWith ' + internals.display(value));
+});
+
+internals.addMethod(['startWith', 'startsWith'], function (value) {
+
+    internals.assert(this, typeof this._ref === 'string' && typeof value === 'string', 'Can only assert startsWith on a string, with a string');
+
+    var comparator = this._ref.slice(0, value.length);
+    return this.assert(comparator === value, 'startWith ' + internals.display(value));
+});
+
 
 internals.addMethod(['exist', 'exists'], function () {
 

test/index.js

@@ -711,6 +711,105 @@ describe('expect()', function () {
             });
         });
 
+        describe('endWith()', function () {
+
+            it('validates strings', function (done) {
+
+                var exception = false;
+                try {
+                    Code.expect('http://xyz.abc/def').to.endWith('abc/def');
+                    Code.expect('abcdefgh').not.to.endWith('abc');
+                    Code.expect('foobar').not.to.endWith('not-long-enough');
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(!exception, exception);
+                done();
+            });
+
+            it('does not validate arrays', function (done) {
+
+                var exception = false;
+                try {
+                    Code.expect(['a', 'b', 'c']).to.endWith('abcdef');
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(exception.message === 'Can only assert endsWith on a string, with a string', exception);
+                done();
+            });
+
+            it('does not validate using arrays', function (done) {
+
+                var exception = false;
+                try {
+                    Code.expect('abcdef').to.endWith(['a', 'b', 'c']);
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(exception.message === 'Can only assert endsWith on a string, with a string', exception);
+                done();
+            });
+
+        });
+
+        describe('startWith()', function () {
+
+            it('validates strings', function (done) {
+
+                var exception = false;
+                try {
+                    Code.expect('http://xyz.abc/def').to.startWith('http://');
+                    Code.expect('eeeaaaeee').to.startWith('eee');
+                    Code.expect('eeeaaaeee').not.to.startWith('aaa');
+                    Code.expect('http://xyz.abc/def').not.to.startWith('https://');
+                    Code.expect('abcdefgh').not.to.startWith('fgh');
+                    Code.expect('foobar').not.to.startWith('not-long-enough');
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(!exception, exception);
+                done();
+            });
+
+            it('does not validate arrays', function (done) {
+
+                var exception = false;
+                try {
+                    Code.expect(['a', 'b', 'c']).to.startWith('abcdef');
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(exception.message === 'Can only assert startsWith on a string, with a string', exception);
+                done();
+            });
+
+            it('does not validate using arrays', function (done) {
+
+                var exception = false;
+                try {
+                    Code.expect('abcdef').to.startWith(['a', 'b', 'c']);
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(exception.message === 'Can only assert startsWith on a string, with a string', exception);
+                done();
+            });
+
+        });
+
         describe('exist()', function () {
 
             it('validates assertion', function (done) {