README.md

@@ -13,13 +13,13 @@ This package has been split in two for the purpose of keeping the documentation
 
 Use this for quick-and-easy, average-joe kind of stuff.
 
-- See <https://git.rootprojects.org/root/acme-http-01-test.js>
+See <https://git.rootprojects.org/root/acme-http-01-test.js.git>
 
 ## ACME dns-01
 
 Use this for wildcards, and private and local domains.
 
-- See <https://git.rootprojects.org/root/acme-dns-01-test.js>
+See <https://git.rootprojects.org/root/acme-dns-01-test.js.git>
 
 ## Reference Implementations
 

index.js

@@ -1,29 +1,6 @@
 'use strict';
 /*global Promise*/
-
-if (process.version.match(/^v(\d+)/)[1] > 6) {
-  console.warn();
-  console.warn('#########################');
-  console.warn('# Node v6 Compatibility #');
-  console.warn('#########################');
-  console.warn();
-  console.warn("You're using node " + process.version);
-  console.warn(
-    'Please write node-v6 compatible JavaScript (not Babel/ECMAScript) and test with node v6.'
-  );
-  console.warn();
-  console.warn(
-    '(ACME.js and Greenlock.js are widely deployed in enterprise node v6 environments. The few node v6 bugs in Buffer and Promise are hotfixed by ACME.js in just a few lines of code)'
-  );
-  console.warn();
-}
-require('./lib/node-v6-compat.js');
-
-// Load _after_ node v6 compat
 var crypto = require('crypto');
-var promisify = require('util').promisify;
-var request = require('@root/request');
-request = promisify(request);
 
 module.exports.create = function() {
 	throw new Error(
@@ -33,12 +10,13 @@ module.exports.create = function() {
 
 // ignore all of this, it's just to normalize Promise vs node-style callback thunk vs synchronous
 function promiseCheckAndCatch(obj, name) {
+	var promisify = require('util').promisify;
 	// don't loose this-ness, just in case that's important
 	var fn = obj[name].bind(obj);
 	var promiser;
 
 	// function signature must match, or an error will be thrown
-  if (fn.length <= 1) {
+	if (1 === fn.length) {
 		// wrap so that synchronous errors are caught (alsa handles synchronous results)
 		promiser = function(opts) {
 			return Promise.resolve().then(function() {
@@ -49,11 +27,13 @@ function promiseCheckAndCatch(obj, name) {
 		// wrap as a promise
 		promiser = promisify(fn);
 	} else {
-    throw new Error(
+		return Promise.reject(
+			new Error(
 				"'challenge." +
 					name +
 					"' should accept either one argument, the options," +
 					' and return a Promise or accept two arguments, the options and a node-style callback thunk'
+			)
 		);
 	}
 
@@ -62,7 +42,7 @@ function promiseCheckAndCatch(obj, name) {
 			throw new Error(
 				"'challenge.'" +
 					name +
-          "' should never return `undefined`. Please explicitly `return null`" +
+					"' should never return `undefined`. Please explicitly return null" +
 					" (or fix the place where a value should have been returned but wasn't)."
 			);
 		}
@@ -99,7 +79,6 @@ function newZoneRegExp(zonename) {
 	//  fooexample.com
 	return new RegExp('(^|\\.)' + zonename.replace(/\./g, '\\.') + '$');
 }
-
 function pluckZone(zones, dnsHost) {
 	return zones
 		.filter(function(zonename) {
@@ -116,75 +95,25 @@ function pluckZone(zones, dnsHost) {
 // Here's the meat, where the tests are happening:
 function testEach(type, domains, challenger) {
 	var chr = wrapChallenger(type, challenger);
-  // We want the same rnd for all domains so that we catch errors like removing
+	var all = domains.map(function(d) {
-  // the apex (bare) domain TXT record to when creating the wildcard record
+		return { domain: d };
+	});
 	var rnd = crypto.randomBytes(2).toString('hex');
 
-  console.info("Testing each of '%s'", domains.join(', '));
+	return chr.zones({ dnsHosts: domains }).then(function(zones) {
-
-  //
-  // Zones
-  //
-  // Get ALL zones for all records on the certificate
-  //
-  return chr
-    .init({ request: request })
-    .then(function() {
-      return chr.zones({ request: request, dnsHosts: domains });
-    })
-    .then(function(zones) {
-      var all = domains.map(function(domain) {
-        var zone = pluckZone(zones, domain);
-        return {
-          domain: domain,
-          challenge: fakeChallenge(type, zone, domain, rnd),
-          request: request
-        };
-      });
-
-      // resolving for the sake of same indentation / scope
-      return Promise.resolve()
-        .then(function() {
 		return mapAsync(all, function(opts) {
-            return set(chr, opts);
+			console.info("TEST '%s'", opts.domain);
-          });
+			var zone = pluckZone(zones, opts.domain);
-        })
+			opts.challenge = fakeChallenge(type, zone, opts.domain, rnd);
-        .then(function() {
-          return mapAsync(all, function(opts) {
-            return check(chr, opts);
-          });
-        })
-        .then(function() {
-          return mapAsync(all, function(opts) {
-            return remove(chr, opts).then(function() {
-              console.info("PASS '%s'", opts.domain);
-            });
-          });
-        })
-        .then(function() {
-          console.info();
-          console.info('It looks like the soft tests all passed.');
-          console.log('It is highly likely that your plugin is correct.');
-          console.log(
-            'Now go test with Greenlock.js and/or ACME.js to be sure.'
-          );
-          console.info();
-        });
-    });
-}
-
-function set(chr, opts) {
 			var ch = opts.challenge;
 			if ('http-01' === ch.type && ch.wildname) {
 				throw new Error('http-01 cannot be used for wildcard domains');
 			}
 
-  //
+			// The first time we just check it against itself
-  // Set
+			// this will cause the prompt to appear
-  //
-  // Add (not replace) a TXT for the domain
-  //
 			return chr.set(opts).then(function() {
+				// this will cause the final completion message to appear
 				// _test is used by the manual cli reference implementations
 				var query = { type: ch.type, /*debug*/ status: ch.status, _test: true };
 				if ('http-01' === ch.type) {
@@ -200,8 +129,6 @@ function set(chr, opts) {
 					// one for the bare domain, and the other if and only if there's a wildcard
 					query.wildcard = ch.wildcard;
 					query.dnsAuthorization = ch.dnsAuthorization;
-      query.dnsZone = ch.dnsZone;
-      query.dnsPrefix = ch.dnsPrefix;
 				} else {
 					query = JSON.parse(JSON.stringify(ch));
 					query.comment = 'unknown challenge type, supplying everything';
@@ -209,24 +136,11 @@ function set(chr, opts) {
 				opts.query = query;
 				return opts;
 			});
-}
+		})
-
+			.then(function(all) {
-function check(chr, opts) {
+				return mapAsync(all, function(opts) {
 					var ch = opts.challenge;
-
+					return chr.get({ challenge: opts.query }).then(function(secret) {
-  //
-  // Get
-  //
-  // Check that ONE of the relevant TXT records matches
-  //
-  return chr
-    .get({ request: request, challenge: opts.query })
-    .then(function(secret) {
-      if (!secret) {
-        throw new Error(
-          '`secret` should be an object containing `keyAuthorization` or `dnsAuthorization`'
-        );
-      }
 						if ('string' === typeof secret) {
 							console.info(
 								'secret was passed as a string, which works historically, but should be an object instead:'
@@ -289,14 +203,10 @@ function check(chr, opts) {
 							}
 						}
 					});
-}
+				});
-
+			})
-function remove(chr, opts) {
+			.then(function() {
-  //
+				return mapAsync(all, function(opts) {
-  // Remove
-  //
-  // Delete ONLY the SINGLE relevant TXT record
-  //
 					return chr.remove(opts).then(function() {
 						return chr.get(opts).then(function(result) {
 							if (result) {
@@ -309,8 +219,29 @@ function remove(chr, opts) {
 									'challenge.get() should return null when the value is not set'
 								);
 							}
+							console.info("PASS '%s'", opts.domain);
 						});
 					});
+				});
+			})
+			.then(function() {
+				console.info('All soft tests: PASS');
+				console.warn(
+					'Hard tests (actually checking http URLs and dns records) is implemented in acme-v2.'
+				);
+				console.warn(
+					"We'll copy them over here as well, but that's a TODO for next week."
+				);
+			});
+	});
+}
+
+function testZone(type, zone, challenger) {
+	var domains = [zone, 'foo.' + zone];
+	if ('dns-01' === type) {
+		domains.push('*.foo.' + zone);
+	}
+	return testEach(type, domains, challenger);
 }
 
 function wrapChallenger(type, challenger) {
@@ -345,14 +276,7 @@ function wrapChallenger(type, challenger) {
 		return;
 	}
 
-  var init = challenger.init;
-  if ('function' !== typeof init) {
-    init = function(opts) {
-      return null;
-    };
-  }
 	return {
-    init: promiseCheckAndCatch(challenger, 'init'),
 		zones: zones,
 		set: promiseCheckAndCatch(challenger, 'set'),
 		get: promiseCheckAndCatch(challenger, 'get'),
@@ -383,12 +307,18 @@ function fakeChallenge(type, zone, altname, rnd) {
 		thumbprint: thumb,
 		keyAuthorization: keyAuth,
 		url: null, // completed below
-    // we create a random record to prevent self cache-poisoning
+		dnsZone: zone,
 		dnsHost: '_' + rnd.slice(0, 2) + '-acme-challenge-' + rnd.slice(2) + '.', // completed below
 		dnsAuthorization: dnsAuth,
 		altname: altname,
 		_test: true // used by CLI referenced implementations
 	};
+	if (zone) {
+		challenge.dnsZone = zone;
+		challenge.dnsPrefix = challenge.dnsHost
+			.replace(newZoneRegExp(zone), '')
+			.replace(/\.$/, '');
+	}
 	if ('*.' === altname.slice(0, 2)) {
 		challenge.wildcard = true;
 		altname = altname.slice(2);
@@ -397,24 +327,10 @@ function fakeChallenge(type, zone, altname, rnd) {
 	challenge.url =
 		'http://' + altname + '/.well-known/acme-challenge/' + challenge.token;
 	challenge.dnsHost += altname;
-  if (zone) {
-    challenge.dnsZone = zone;
-    challenge.dnsPrefix = challenge.dnsHost
-      .replace(newZoneRegExp(zone), '')
-      .replace(/\.$/, '');
-  }
 
 	return challenge;
 }
 
-function testZone(type, zone, challenger) {
-  var domains = [zone, 'foo.' + zone];
-  if ('dns-01' === type) {
-    domains.push('*.foo.' + zone);
-  }
-  return testEach(type, domains, challenger);
-}
-
 function testRecord(type, altname, challenger) {
 	return testEach(type, [altname], challenger);
 }

lib/node-v6-compat.js

@@ -1,25 +0,0 @@
-"use strict";
-
-function requireBluebird() {
-	try {
-		return require("bluebird");
-	} catch (e) {
-		console.error("");
-		console.error("DON'T PANIC. You're running an old version of node with incomplete Promise support.");
-		console.error("EASY FIX: `npm install --save bluebird`");
-		console.error("");
-		throw e;
-	}
-}
-
-if ("undefined" === typeof Promise) {
-	global.Promise = requireBluebird();
-}
-
-if ("function" !== typeof require("util").promisify) {
-	require("util").promisify = requireBluebird().promisify;
-}
-
-if (!console.debug) {
-	console.debug = console.log;
-}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "acme-challenge-test",
-  "version": "3.3.2",
+  "version": "3.2.0",
   "description": "ACME challenge test harness for Let's Encrypt integrations. Any `acme-http-01-` or `acme-dns-01-` challenge strategy or Greenlock plugin should be able to pass these tests.",
   "main": "index.js",
   "homepage": "https://git.rootprojects.org/root/acme-challenge-test.js",
@@ -8,9 +8,7 @@
     "example.js",
     "lib"
   ],
-  "dependencies": {
+  "dependencies": {},
-    "@root/request": "^1.3.11"
-  },
   "devDependencies": {},
   "scripts": {
     "test": "node example.js"