From e180b8abd87a3a1cb405f5f04456eb3cede7ef43 Mon Sep 17 00:00:00 2001
From: Erik Kemperman <erikkemperman@gmail.com>
Date: Thu, 31 Aug 2017 15:51:24 +0200
Subject: [PATCH] Update: Export and test resolveConstant method separately

---
 README.md     |   4 ++
 index.js      |   1 +
 test/index.js | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 190 insertions(+)

diff --git a/README.md b/README.md
index 60efcb3..66c2f95 100644
--- a/README.md
+++ b/README.md
@@ -81,6 +81,10 @@ A `default` property may also be specified as a fallback if the option isn't ava
 
 Takes an `optionKey` string and any number of `arguments` to apply if an option is a function. Returns the resolved value for the `optionKey`.
 
+### `resolver.resolveConstant(optionKey)`
+
+Like `resolve`, but only returns a value if the option is constant (not a function).
+
 ## License
 
 MIT
diff --git a/index.js b/index.js
index 21ef429..7446600 100644
--- a/index.js
+++ b/index.js
@@ -11,6 +11,7 @@ function createResolver(config, options) {
 
   var resolver = {
     resolve: resolve,
+    resolveConstant: resolveConstant,
   };
 
 
diff --git a/test/index.js b/test/index.js
index 1233a1a..7b39567 100644
--- a/test/index.js
+++ b/test/index.js
@@ -22,6 +22,14 @@ describe('createResolver', function() {
     done();
   });
 
+  it('returns a resolver that contains a `resolveConstant` method', function(done) {
+    var resolver = createResolver();
+
+    expect(resolver.resolveConstant).toBeA('function');
+
+    done();
+  });
+
   it('accepts a config object', function(done) {
     var config = {
       myOpt: {
@@ -549,3 +557,180 @@ describe('resolver.resolve', function() {
     done();
   });
 });
+
+describe('resolver.resolveConstant', function() {
+
+  it('takes a string key and returns a resolved option', function(done) {
+    var config = {
+      myOpt: {
+        type: 'string',
+        default: 'hello world',
+      },
+    };
+
+    var resolver = createResolver(config);
+
+    var myOpt = resolver.resolveConstant('myOpt');
+
+    expect(myOpt).toEqual('hello world');
+
+    done();
+  });
+
+  it('returns undefined if a string key is not given', function(done) {
+    var resolver = createResolver();
+
+    var myOpt = resolver.resolveConstant({});
+
+    expect(myOpt).toEqual(undefined);
+
+    done();
+  });
+
+  it('returns undefined if the key is not defined in the config object', function(done) {
+    var resolver = createResolver();
+
+    var myOpt = resolver.resolveConstant('myOpt');
+
+    expect(myOpt).toEqual(undefined);
+
+    done();
+  });
+
+  it('resolves values against the defined type', function(done) {
+    var config = {
+      myOpt: {
+        type: 'string',
+        default: 'hello world',
+      },
+    };
+
+    var validOptions = {
+      myOpt: 'foo',
+    };
+
+    var validResolver = createResolver(config, validOptions);
+
+    var validOpt = validResolver.resolveConstant('myOpt');
+
+    expect(validOpt).toEqual('foo');
+
+    var invalidOptions = {
+      myOpt: 123,
+    };
+
+    var invalidResolver = createResolver(config, invalidOptions);
+
+    var invalidOpt = invalidResolver.resolve('myOpt');
+
+    expect(invalidOpt).toEqual('hello world');
+
+    done();
+  });
+
+  it('does not resolve options that are given as a function', function(done) {
+    var config = {
+      myOpt: {
+        type: 'string',
+        default: 'hello world',
+      },
+    };
+
+    var validOptions = {
+      myOpt: function() {
+        return 'foo';
+      },
+    };
+
+    var validResolver = createResolver(config, validOptions);
+
+    var validOpt = validResolver.resolveConstant('myOpt');
+
+    expect(validOpt).toEqual(null);
+
+    done();
+  });
+
+  it('supports custom type resolution with functions', function(done) {
+    var now = new Date();
+
+    var config = {
+      myOpt: {
+        type: function(value) {
+          return value.constructor === Date ? value : null;
+        },
+        default: 'hello world',
+      },
+    };
+
+    var options = {
+      myOpt: now,
+    };
+
+    var resolver = createResolver(config, options);
+
+    var myOpt = resolver.resolveConstant('myOpt');
+
+    expect(myOpt).toBe(now);
+
+    done();
+  });
+
+  it('supports arrays of types', function(done) {
+    var config = {
+      myOpt: {
+        type: ['string', 'boolean'],
+        default: false,
+      },
+    };
+
+    var strOptions = {
+      myOpt: 'foo',
+    };
+
+    var strResolver = createResolver(config, strOptions);
+
+    var strOpt = strResolver.resolveConstant('myOpt');
+
+    expect(strOpt).toEqual('foo');
+
+    var boolOptions = {
+      myOpt: true,
+    };
+
+    var boolResolver = createResolver(config, boolOptions);
+
+    var boolOpt = boolResolver.resolveConstant('myOpt');
+
+    expect(boolOpt).toEqual(true);
+
+    var invalidOptions = {
+      myOpt: 123,
+    };
+
+    var invalidResolver = createResolver(config, invalidOptions);
+
+    var invalidOpt = invalidResolver.resolveConstant('myOpt');
+
+    expect(invalidOpt).toEqual(false);
+
+    done();
+  });
+
+  it('does not verify your default matches the type', function(done) {
+    var config = {
+      myOpt: {
+        type: 'string',
+        default: 123,
+      },
+    };
+
+    var resolver = createResolver(config);
+
+    var myOpt = resolver.resolveConstant('myOpt');
+
+    expect(myOpt).toEqual(123);
+
+    done();
+  });
+});