Use live dates to better integration test expiration logic.

Author: aljones15

test/10-verify.spec.js

@@ -12,7 +12,7 @@ import {
 } from './testDocumentLoader.js';
 import {assertionController} from './mocks/assertionController.js';
 import chai from 'chai';
-import {createTimeStamp} from './helpers.js';
+import {createSkewedTimeStamp} from './helpers.js';
 import {CredentialIssuancePurpose} from '../lib/CredentialIssuancePurpose.js';
 import {DataIntegrityProof} from '@digitalbazaar/data-integrity';
 import {Ed25519Signature2018} from '@digitalbazaar/ed25519-signature-2018';
@@ -155,11 +155,8 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should issue "validUntil" in the future', async () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          const validUntil = new Date();
           // set validUntil one year in the future
-          validUntil.setFullYear(validUntil.getFullYear() + 1);
-          // turn it into an ISO Time Stamp
-          credential.validUntil = createTimeStamp({date: validUntil});
+          credential.validUntil = createSkewedTimeStamp({skewYear: 1});
           let error;
           let verifiableCredential;
           try {
@@ -186,11 +183,8 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should issue "validUntil" in the past', async () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          const validUntil = new Date();
           // set validUntil one year in the past
-          validUntil.setFullYear(validUntil.getFullYear() - 1);
-          // turn it into an ISO Time Stamp
-          credential.validUntil = createTimeStamp({date: validUntil});
+          credential.validUntil = createSkewedTimeStamp({skewYear: -1});
           let error;
           let verifiableCredential;
           try {
@@ -217,9 +211,7 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should issue "validFrom" in the past', async () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          const validFrom = new Date();
-          validFrom.setFullYear(validFrom.getFullYear() - 1);
-          credential.validFrom = createTimeStamp({date: validFrom});
+          credential.validFrom = createSkewedTimeStamp({skewYear: -1});
           let error;
           let verifiableCredential;
           try {
@@ -246,9 +238,7 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should issue "validFrom" in the future', async () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          const validFrom = new Date();
-          validFrom.setFullYear(validFrom.getFullYear() + 1);
-          credential.validFrom = createTimeStamp({date: validFrom});
+          credential.validFrom = createSkewedTimeStamp({skewYear: 1});
           let error;
           let verifiableCredential;
           try {
@@ -275,12 +265,8 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should issue both "validFrom" and "validUntil"', async () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          const validFrom = new Date();
-          validFrom.setFullYear(validFrom.getFullYear() - 1);
-          credential.validFrom = createTimeStamp({date: validFrom});
-          const validUntil = new Date();
-          validUntil.setFullYear(validFrom.getFullYear() + 1);
-          credential.validUntil = createTimeStamp({date: validUntil});
+          credential.validFrom = createSkewedTimeStamp({skewYear: -1});
+          credential.validUntil = createSkewedTimeStamp({skewYear: 1});
           let error;
           let verifiableCredential;
           try {
@@ -792,11 +778,14 @@ for(const [version, mockCredential] of versionedCredentials) {
           .contain('Credential has expired.');
       });
       if(version === 1.0) {
+        // we submit with second precission,
+        // but throw with millisecond precision
+        const getISOString = stamp => new Date(stamp).toISOString();
         it('should reject if "now" is before "issuanceDate"', () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          credential.issuanceDate = '2022-10-31T19:21:25Z';
-          const now = '2022-06-30T19:21:25Z';
+          credential.issuanceDate = createSkewedTimeStamp({skewYear: 1});
+          const now = createSkewedTimeStamp({skewYear: 0});
           let error;
           try {
             vc._checkCredential({credential, now});
@@ -806,19 +795,18 @@ for(const [version, mockCredential] of versionedCredentials) {
           should.exist(error,
             'Should throw error when "now" is before "issuanceDate"');
           error.message.should.contain(
-            'The current date time (2022-06-30T19:21:25.000Z) is before the ' +
-            '"issuanceDate" (2022-10-31T19:21:25.000Z).');
+            `The current date time (${getISOString(now)}) is before the ` +
+            `"issuanceDate" (${getISOString(credential.issuanceDate)}).`);
         });
       }
       if(version === 2.0) {
         it('should reject "validFrom" in the future', () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          credential.validFrom = '2022-10-30T19:21:25Z';
-          const now = '2022-06-30T19:21:25Z';
+          credential.validFrom = createSkewedTimeStamp({skewYear: 1});
           let error;
           try {
-            vc._checkCredential({credential, now});
+            vc._checkCredential({credential});
           } catch(e) {
             error = e;
           }
@@ -828,11 +816,10 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should accept "validFrom" in the past', () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          credential.validFrom = '2022-06-30T19:21:25Z';
-          const now = '2022-10-30T19:21:25Z';
+          credential.validFrom = createSkewedTimeStamp({skewYear: -1});
           let error;
           try {
-            vc._checkCredential({credential, now});
+            vc._checkCredential({credential});
           } catch(e) {
             error = e;
           }
@@ -842,11 +829,10 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should reject "validUntil" in the past', () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          credential.validUntil = '2022-06-31T19:21:25Z';
-          const now = '2025-10-30T19:21:25Z';
+          credential.validUntil = createSkewedTimeStamp({skewYear: -1});
           let error;
           try {
-            vc._checkCredential({credential, now});
+            vc._checkCredential({credential});
           } catch(e) {
             error = e;
           }
@@ -856,11 +842,10 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should accept "validUntil" in the future', () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          credential.validUntil = '2025-10-31T19:21:25Z';
-          const now = '2022-06-30T19:21:25Z';
+          credential.validUntil = createSkewedTimeStamp({skewYear: 1});
           let error;
           try {
-            vc._checkCredential({credential, now});
+            vc._checkCredential({credential});
           } catch(e) {
             error = e;
           }
@@ -870,12 +855,11 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should accept if now is between "validFrom" & "validUntil"', () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          credential.validFrom = '2022-05-30T19:21:25Z';
-          credential.validUntil = '2025-05-30T19:21:25Z';
-          const now = '2022-06-30T19:21:25Z';
+          credential.validFrom = createSkewedTimeStamp({skewYear: -1});
+          credential.validUntil = createSkewedTimeStamp({skewYear: 1});
           let error;
           try {
-            vc._checkCredential({credential, now});
+            vc._checkCredential({credential});
           } catch(e) {
             error = e;
           }
@@ -886,7 +870,7 @@ for(const [version, mockCredential] of versionedCredentials) {
           () => {
             const credential = jsonld.clone(mockCredential);
             credential.issuer = 'did:example:12345';
-            const now = '2022-06-30T19:21:25Z';
+            const now = createSkewedTimeStamp({skewYear: 0});
             credential.validFrom = now;
             credential.validUntil = now;
             let error;
@@ -901,12 +885,11 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should reject if now is after "validFrom" & "validUntil"', () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          credential.validFrom = '2022-05-30T19:21:25Z';
-          credential.validUntil = '2023-05-30T19:21:25Z';
-          const now = '2024-06-30T19:21:25Z';
+          credential.validFrom = createSkewedTimeStamp({skewYear: -2});
+          credential.validUntil = createSkewedTimeStamp({skewYear: -1});
           let error;
           try {
-            vc._checkCredential({credential, now});
+            vc._checkCredential({credential});
           } catch(e) {
             error = e;
           }
@@ -916,12 +899,11 @@ for(const [version, mockCredential] of versionedCredentials) {
         it('should reject if now is before "validFrom" & "validUntil"', () => {
           const credential = jsonld.clone(mockCredential);
           credential.issuer = 'did:example:12345';
-          credential.validFrom = '2024-05-30T19:21:25Z';
-          credential.validUntil = '2025-05-30T19:21:25Z';
-          const now = '2023-06-30T19:21:25Z';
+          credential.validFrom = createSkewedTimeStamp({skewYear: 1});
+          credential.validUntil = createSkewedTimeStamp({skewYear: 2});
           let error;
           try {
-            vc._checkCredential({credential, now});
+            vc._checkCredential({credential});
           } catch(e) {
             error = e;
           }

test/helpers.js

@@ -3,3 +3,8 @@ export function createTimeStamp({date}) {
   // remove the milliseconds from the iso time stamp
   return isoString.substr(0, isoString.length - 5) + 'Z';
 }
+
+export function createSkewedTimeStamp({date = new Date(), skewYear}) {
+  date.setFullYear(date.getFullYear() + skewYear);
+  return createTimeStamp({date});
+}