@opentermsarchive/engine 0.26.1 → 0.27.1

package/src/archivist/recorder/snapshot.js

@@ -0,0 +1,5 @@
+import Record from './record.js';
+
+export default class Snapshot extends Record {
+  static REQUIRED_PARAMS = Object.freeze([ ...Record.REQUIRED_PARAMS, 'mimeType' ]);
+}

package/src/archivist/recorder/snapshot.test.js

@@ -0,0 +1,65 @@
+import chai from 'chai';
+
+import Snapshot from './snapshot.js';
+
+const { expect } = chai;
+
+describe('Snapshot', () => {
+  let subject;
+
+  describe('#validate', () => {
+    Snapshot.REQUIRED_PARAMS.forEach(requiredParam => {
+      const validParamsExceptTheOneTested = Snapshot.REQUIRED_PARAMS.filter(paramName => paramName != requiredParam).reduce(
+        (accumulator, currentValue) => {
+          accumulator[currentValue] = 'non null value';
+
+          return accumulator;
+        },
+        {},
+      );
+
+      describe(`"${requiredParam}"`, () => {
+        context('when missing', () => {
+          it('throws an error', async () => {
+            subject = new Snapshot({ ...validParamsExceptTheOneTested });
+            expect(subject.validate.bind(subject)).to.throw(RegExp(requiredParam));
+          });
+        });
+
+        context('when null', () => {
+          it('throws an error', async () => {
+            subject = new Snapshot({ ...validParamsExceptTheOneTested, [requiredParam]: null });
+            expect(subject.validate.bind(subject)).to.throw(RegExp(requiredParam));
+          });
+        });
+      });
+    });
+  });
+
+  describe('Content access', () => {
+    const recordParams = {
+      serviceId: 'ServiceA',
+      termsType: 'Terms of Service',
+      mimeType: 'text/html',
+      fetchDate: new Date('2000-01-01T12:00:00.000Z'),
+    };
+
+    before(async () => {
+      subject = new Snapshot(recordParams);
+    });
+
+    context('when it is neither defined nor loaded', () => {
+      it('throws an error explaining how to recover', async () => {
+        try {
+          console.log(subject.content);
+        } catch (e) {
+          expect(e).to.be.an('error');
+          expect(e.message).to.have.string('set the content or use Repository#loadRecordContent');
+
+          return;
+        }
+        expect.fail('No error was thrown');
+      });
+    });
+  });
+});

package/src/archivist/recorder/version.js

@@ -0,0 +1,14 @@
+import mime from 'mime';
+
+import Record from './record.js';
+
+export default class Version extends Record {
+  static REQUIRED_PARAMS = Object.freeze([ ...Record.REQUIRED_PARAMS, 'snapshotIds' ]);
+
+  static SOURCE_DOCUMENTS_SEPARATOR = '\n\n';
+
+  constructor(params) {
+    super(params);
+    this.mimeType = mime.getType('markdown');
+  }
+}

package/src/archivist/recorder/version.test.js

@@ -0,0 +1,65 @@
+import chai from 'chai';
+
+import Version from './version.js';
+
+const { expect } = chai;
+
+describe('Version', () => {
+  let subject;
+
+  describe('#validate', () => {
+    Version.REQUIRED_PARAMS.forEach(requiredParam => {
+      const validParamsExceptTheOneTested = Version.REQUIRED_PARAMS.filter(paramName => paramName != requiredParam).reduce(
+        (accumulator, currentValue) => {
+          accumulator[currentValue] = 'non null value';
+
+          return accumulator;
+        },
+        {},
+      );
+
+      describe(`"${requiredParam}"`, () => {
+        context('when missing', () => {
+          it('throws an error', async () => {
+            subject = new Version({ ...validParamsExceptTheOneTested });
+            expect(subject.validate.bind(subject)).to.throw(RegExp(requiredParam));
+          });
+        });
+
+        context('when null', () => {
+          it('throws an error', async () => {
+            subject = new Version({ ...validParamsExceptTheOneTested, [requiredParam]: null });
+            expect(subject.validate.bind(subject)).to.throw(RegExp(requiredParam));
+          });
+        });
+      });
+    });
+  });
+
+  describe('Content access', () => {
+    const recordParams = {
+      serviceId: 'ServiceA',
+      termsType: 'Terms of Service',
+      fetchDate: new Date('2000-01-01T12:00:00.000Z'),
+      snapshotIds: ['dd263f270b3065e1c18201b49ab898474b357566'],
+    };
+
+    before(async () => {
+      subject = new Version(recordParams);
+    });
+
+    context('when it is neither defined nor loaded', () => {
+      it('throws an error explaining how to recover', async () => {
+        try {
+          console.log(subject.content);
+        } catch (e) {
+          expect(e).to.be.an('error');
+          expect(e.message).to.have.string('set the content or use Repository#loadRecordContent');
+
+          return;
+        }
+        expect.fail('No error was thrown');
+      });
+    });
+  });
+});

package/src/archivist/services/index.js

@@ -2,18 +2,15 @@ import fsApi from 'fs';
 import path from 'path';
 import { pathToFileURL } from 'url';
 
-import TERMS_TYPES from '@opentermsarchive/terms-types';
 import config from 'config';
 
-import DocumentDeclaration from './documentDeclaration.js';
-import PageDeclaration from './pageDeclaration.js';
 import Service from './service.js';
+import SourceDocument from './sourceDocument.js';
+import Terms from './terms.js';
 
 const fs = fsApi.promises;
 const declarationsPath = path.resolve(process.cwd(), config.get('services.declarationsPath'));
 
-export const DOCUMENT_TYPES = TERMS_TYPES;
-
 export async function load(servicesIdsToLoad = []) {
   let servicesIds = await getDeclaredServicesIds();
 
@@ -24,11 +21,11 @@ export async function load(servicesIdsToLoad = []) {
   const services = {};
 
   await Promise.all(servicesIds.map(async serviceId => {
-    const { name, documents: documentsDeclaration } = await loadServiceDeclaration(serviceId);
+    const { name, documents: terms } = await loadServiceDeclaration(serviceId);
 
     const service = new Service({ id: serviceId, name });
 
-    await Promise.all(Object.keys(documentsDeclaration).map(documentType => loadServiceDocument(service, documentType, documentsDeclaration[documentType])));
+    await Promise.all(Object.keys(terms).map(termsType => loadServiceDocument(service, termsType, terms[termsType])));
 
     services[serviceId] = service;
   }));
@@ -58,32 +55,38 @@ async function loadServiceFilters(serviceId, filterNames) {
   return filterNames.map(filterName => serviceFilters[filterName]);
 }
 
-async function loadServiceDocument(service, documentType, documentTypeDeclaration) {
-  const { filter: filterNames, fetch: location, executeClientScripts, select: contentSelectors, remove: noiseSelectors, combine } = documentTypeDeclaration;
+async function loadServiceDocument(service, termsType, termsTypeDeclaration) {
+  const { filter: filterNames, fetch: location, executeClientScripts, select: contentSelectors, remove: insignificantContentSelectors, combine } = termsTypeDeclaration;
 
-  const pages = [];
+  const sourceDocuments = [];
 
   const filters = await loadServiceFilters(service.id, filterNames);
 
   if (!combine) {
-    pages.push(new PageDeclaration({ location, executeClientScripts, contentSelectors, noiseSelectors, filters }));
+    sourceDocuments.push(new SourceDocument({ location, executeClientScripts, contentSelectors, insignificantContentSelectors, filters }));
   } else {
-    for (const pageDeclaration of combine) {
-      const { filter: pageFilterNames, fetch: pageLocation, executeClientScripts: pageExecuteClientScripts, select: pageContentSelectors, remove: pageNoiseSelectors } = pageDeclaration;
-
-      const pageFilters = await loadServiceFilters(service.id, pageFilterNames); // eslint-disable-line no-await-in-loop
-
-      pages.push(new PageDeclaration({
-        location: pageLocation || location,
-        executeClientScripts: (pageExecuteClientScripts === undefined || pageExecuteClientScripts === null ? executeClientScripts : pageExecuteClientScripts),
-        contentSelectors: pageContentSelectors || contentSelectors,
-        noiseSelectors: pageNoiseSelectors || noiseSelectors,
-        filters: pageFilters || filters,
+    for (const sourceDocument of combine) {
+      const {
+        filter: sourceDocumentFilterNames,
+        fetch: sourceDocumentLocation,
+        executeClientScripts: sourceDocumentExecuteClientScripts,
+        select: sourceDocumentContentSelectors,
+        remove: sourceDocumentInsignificantContentSelectors,
+      } = sourceDocument;
+
+      const sourceDocumentFilters = await loadServiceFilters(service.id, sourceDocumentFilterNames); // eslint-disable-line no-await-in-loop
+
+      sourceDocuments.push(new SourceDocument({
+        location: sourceDocumentLocation || location,
+        executeClientScripts: (sourceDocumentExecuteClientScripts === undefined || sourceDocumentExecuteClientScripts === null ? executeClientScripts : sourceDocumentExecuteClientScripts),
+        contentSelectors: sourceDocumentContentSelectors || contentSelectors,
+        insignificantContentSelectors: sourceDocumentInsignificantContentSelectors || insignificantContentSelectors,
+        filters: sourceDocumentFilters || filters,
       }));
     }
   }
 
-  service.addDocumentDeclaration(new DocumentDeclaration({ service, type: documentType, pages }));
+  service.addTerms(new Terms({ service, type: termsType, sourceDocuments }));
 }
 
 async function getDeclaredServicesIds() {
@@ -100,18 +103,18 @@ export async function loadWithHistory(servicesIds = []) {
   for (const serviceId of Object.keys(services)) {
     const { declarations, filters } = await loadServiceHistoryFiles(serviceId); // eslint-disable-line no-await-in-loop
 
-    for (const documentType of Object.keys(declarations)) {
-      const documentTypeDeclarationEntries = declarations[documentType];
-      const filterNames = [...new Set(documentTypeDeclarationEntries.flatMap(declaration => declaration.filter))].filter(Boolean);
-      const allHistoryDates = extractHistoryDates({ documentTypeDeclarationEntries, filters, filterNames });
+    for (const termsType of Object.keys(declarations)) {
+      const termsTypeDeclarationEntries = declarations[termsType];
+      const filterNames = [...new Set(termsTypeDeclarationEntries.flatMap(declaration => declaration.filter))].filter(Boolean);
+      const allHistoryDates = extractHistoryDates({ termsTypeDeclarationEntries, filters, filterNames });
 
-      const latestValidDocumentDeclaration = documentTypeDeclarationEntries.find(entry => !entry.validUntil);
+      const latestValidTerms = termsTypeDeclarationEntries.find(entry => !entry.validUntil);
 
       allHistoryDates.forEach(async date => {
-        const declarationForThisDate = documentTypeDeclarationEntries.find(entry => new Date(date) <= new Date(entry.validUntil)) || latestValidDocumentDeclaration;
+        const declarationForThisDate = termsTypeDeclarationEntries.find(entry => new Date(date) <= new Date(entry.validUntil)) || latestValidTerms;
         const { filter: declarationForThisDateFilterNames, combine } = declarationForThisDate;
 
-        const pages = [];
+        const sourceDocuments = [];
         let actualFilters;
 
         if (declarationForThisDateFilterNames) {
@@ -125,33 +128,39 @@ export async function loadWithHistory(servicesIds = []) {
         }
 
         if (!combine) {
-          pages.push(new PageDeclaration({
+          sourceDocuments.push(new SourceDocument({
             location: declarationForThisDate.fetch,
             executeClientScripts: declarationForThisDate.executeClientScripts,
             contentSelectors: declarationForThisDate.select,
-            noiseSelectors: declarationForThisDate.remove,
+            insignificantContentSelectors: declarationForThisDate.remove,
             filters: actualFilters,
           }));
         } else {
-          for (const pageDeclaration of combine) {
-            const { filter: pageFilterNames, fetch: pageLocation, executeClientScripts: pageExecuteClientScripts, select: pageContentSelectors, remove: pageNoiseSelectors } = pageDeclaration;
-
-            const pageFilters = await loadServiceFilters(serviceId, pageFilterNames); // eslint-disable-line no-await-in-loop
-
-            pages.push(new PageDeclaration({
-              location: pageLocation || declarationForThisDate.fetch,
-              executeClientScripts: (pageExecuteClientScripts === undefined || pageExecuteClientScripts === null ? declarationForThisDate.executeClientScripts : pageExecuteClientScripts),
-              contentSelectors: pageContentSelectors || declarationForThisDate.select,
-              noiseSelectors: pageNoiseSelectors || declarationForThisDate.remove,
-              filters: pageFilters || actualFilters,
+          for (const sourceDocument of combine) {
+            const {
+              filter: sourceDocumentFilterNames,
+              fetch: sourceDocumentLocation,
+              executeClientScripts: sourceDocumentExecuteClientScripts,
+              select: sourceDocumentContentSelectors,
+              remove: sourceDocumentInsignificantContentSelectors,
+            } = sourceDocument;
+
+            const sourceDocumentFilters = await loadServiceFilters(serviceId, sourceDocumentFilterNames); // eslint-disable-line no-await-in-loop
+
+            sourceDocuments.push(new SourceDocument({
+              location: sourceDocumentLocation || declarationForThisDate.fetch,
+              executeClientScripts: (sourceDocumentExecuteClientScripts === undefined || sourceDocumentExecuteClientScripts === null ? declarationForThisDate.executeClientScripts : sourceDocumentExecuteClientScripts),
+              contentSelectors: sourceDocumentContentSelectors || declarationForThisDate.select,
+              insignificantContentSelectors: sourceDocumentInsignificantContentSelectors || declarationForThisDate.remove,
+              filters: sourceDocumentFilters || actualFilters,
             }));
           }
         }
 
-        services[serviceId].addDocumentDeclaration(new DocumentDeclaration({
+        services[serviceId].addTerms(new Terms({
           service: services[serviceId],
-          type: documentType,
-          pages,
+          type: termsType,
+          sourceDocuments,
           validUntil: date,
         }));
       });
@@ -161,7 +170,7 @@ export async function loadWithHistory(servicesIds = []) {
   return services;
 }
 
-function extractHistoryDates({ filters, filterNames, documentTypeDeclarationEntries }) {
+function extractHistoryDates({ filters, filterNames, termsTypeDeclarationEntries }) {
   const allHistoryDates = [];
 
   Object.keys(filters).forEach(filterName => {
@@ -170,7 +179,7 @@ function extractHistoryDates({ filters, filterNames, documentTypeDeclarationEntr
     }
   });
 
-  documentTypeDeclarationEntries.forEach(({ validUntil }) => allHistoryDates.push(validUntil));
+  termsTypeDeclarationEntries.forEach(({ validUntil }) => allHistoryDates.push(validUntil));
 
   const sortedDates = allHistoryDates.sort((a, b) => new Date(a) - new Date(b));
   const uniqSortedDates = [...new Set(sortedDates)];
@@ -211,9 +220,9 @@ async function loadServiceHistoryFiles(serviceId) {
     }
   }
 
-  Object.keys(serviceDeclaration.documents).forEach(documentType => {
-    serviceHistory[documentType] = serviceHistory[documentType] || [];
-    serviceHistory[documentType].push(serviceDeclaration.documents[documentType]);
+  Object.keys(serviceDeclaration.documents).forEach(termsType => {
+    serviceHistory[termsType] = serviceHistory[termsType] || [];
+    serviceHistory[termsType].push(serviceDeclaration.documents[termsType]);
   });
 
   sortHistory(serviceHistory);

package/src/archivist/services/index.test.js

@@ -14,57 +14,57 @@ describe('Services', () => {
 
     async function validateServiceWithoutHistory(serviceId, expected) {
       /* eslint-disable no-loop-func */
-      for (const documentType of expected.getDocumentTypes()) {
-        context(`${documentType}`, () => {
-          let actualDocumentDeclaration;
+      for (const termsType of expected.getTermsTypes()) {
+        context(`${termsType}`, () => {
+          let actualTerms;
           let actualFilters;
           let actualContentSelectors;
-          let actualNoiseSelectors;
+          let actualInsignificantContentSelectors;
           let actualExecuteClientScripts;
 
-          const expectedDocumentDeclaration = expected.getDocumentDeclaration(documentType);
+          const expectedTerms = expected.getTerms(termsType);
 
-          const { pages } = expectedDocumentDeclaration;
+          const { sourceDocuments } = expectedTerms;
 
-          pages.forEach((page, index) => {
+          sourceDocuments.forEach((sourceDocument, index) => {
             const {
               filters: expectedFilters,
               contentSelectors: expectedContentSelectors,
-              noiseSelectors: expectedNoiseSelectors,
+              insignificantContentSelectors: expectedInsignificantContentSelectors,
               executeClientScripts: expectedExecuteClientScripts,
-            } = page;
+            } = sourceDocument;
 
-            context(`Page: ${page.id}`, () => {
+            context(`source document: ${sourceDocument.id}`, () => {
               before(() => {
-                actualDocumentDeclaration = result[serviceId].getDocumentDeclaration(documentType);
-                const { pages: actualPages } = actualDocumentDeclaration;
+                actualTerms = result[serviceId].getTerms(termsType);
+                const { sourceDocuments: actualDocuments } = actualTerms;
 
                 ({
                   filters: actualFilters,
                   contentSelectors: actualContentSelectors,
-                  noiseSelectors: actualNoiseSelectors,
+                  insignificantContentSelectors: actualInsignificantContentSelectors,
                   executeClientScripts: actualExecuteClientScripts,
-                } = actualPages[index]);
+                } = actualDocuments[index]);
               });
 
               it('has the proper service name', () => {
-                expect(actualDocumentDeclaration.service.name).to.eql(expectedDocumentDeclaration.service.name);
+                expect(actualTerms.service.name).to.eql(expectedTerms.service.name);
               });
 
               it('has the proper terms type', () => {
-                expect(actualDocumentDeclaration.type).to.eql(expectedDocumentDeclaration.type);
+                expect(actualTerms.type).to.eql(expectedTerms.type);
               });
 
               it('has no validity date', () => {
-                expect(actualDocumentDeclaration.validUntil).to.be.undefined;
+                expect(actualTerms.validUntil).to.be.undefined;
               });
 
               it('has the proper content selectors', async () => {
                 expect(actualContentSelectors).to.equal(expectedContentSelectors);
               });
 
-              it('has the proper noise selectors', async () => {
-                expect(actualNoiseSelectors).to.equal(expectedNoiseSelectors);
+              it('has the proper insignificant content selectors', async () => {
+                expect(actualInsignificantContentSelectors).to.equal(expectedInsignificantContentSelectors);
               });
 
               it('has the proper executeClientScripts option', async () => {
@@ -105,34 +105,24 @@ describe('Services', () => {
       await validateServiceWithoutHistory('service_B', expectedServices.service_B);
     });
 
-    context('when a service has no history', async () => {
-      describe('Service without history', async () => {
-        await validateServiceWithoutHistory('service_without_history', expectedServices.service_without_history);
-      });
+    describe('Service without history', async () => {
+      await validateServiceWithoutHistory('service_without_history', expectedServices.service_without_history);
     });
 
-    context('when a service has only history for declarations', async () => {
-      describe('Service with declaration history', async () => {
-        await validateServiceWithoutHistory('service_with_declaration_history', expectedServices.service_with_declaration_history);
-      });
+    describe('Service with declaration history only', async () => {
+      await validateServiceWithoutHistory('service_with_declaration_history', expectedServices.service_with_declaration_history);
     });
 
-    context('when a service has only history for filters', async () => {
-      describe('Service with filters history', async () => {
-        await validateServiceWithoutHistory('service_with_filters_history', expectedServices.service_with_filters_history);
-      });
+    describe('Service with filters history only', async () => {
+      await validateServiceWithoutHistory('service_with_filters_history', expectedServices.service_with_filters_history);
     });
 
-    context('when a service has histories both for filters and for declarations', async () => {
-      describe('Service with history', async () => {
-        await validateServiceWithoutHistory('service_with_history', expectedServices.service_with_history);
-      });
+    describe('Service with both filters and declarations histories', async () => {
+      await validateServiceWithoutHistory('service_with_history', expectedServices.service_with_history);
     });
 
-    context('when a service has a multipage document', async () => {
-      describe('Service with a multipage document', async () => {
-        await validateServiceWithoutHistory('service_with_multipage_document', expectedServices.service_with_multipage_document);
-      });
+    describe('Service with terms with multiple source documents', async () => {
+      await validateServiceWithoutHistory('service_with_multiple_source_documents_terms', expectedServices.service_with_multiple_source_documents_terms);
     });
 
     context('when specifying services to load', async () => {
@@ -151,37 +141,37 @@ describe('Services', () => {
 
     async function validateServiceWithHistory(serviceId, expected) {
       /* eslint-disable no-loop-func */
-      for (const documentType of expected.getDocumentTypes()) {
-        context(`${documentType}`, () => {
-          const { history: expectedHistory } = expected.documents[documentType];
+      for (const termsType of expected.getTermsTypes()) {
+        context(`${termsType}`, () => {
+          const { history: expectedHistory } = expected.terms[termsType];
           const expectedHistoryDates = expectedHistory && [ ...expectedHistory.map(entry => entry.validUntil), null ]; // add `null` entry to simulate the still current valid declaration
 
-          let actualDocumentDeclaration;
+          let actualTerms;
           let actualFilters;
-          const expectedDocumentDeclaration = expected.getDocumentDeclaration(documentType);
+          const expectedTerms = expected.getTerms(termsType);
 
-          const { pages } = expectedDocumentDeclaration;
+          const { sourceDocuments } = expectedTerms;
 
           before(() => {
-            actualDocumentDeclaration = result[serviceId].getDocumentDeclaration(documentType);
+            actualTerms = result[serviceId].getTerms(termsType);
           });
 
           it('has the proper service name', () => {
-            expect(actualDocumentDeclaration.service.name).to.eql(expectedDocumentDeclaration.service.name);
+            expect(actualTerms.service.name).to.eql(expectedTerms.service.name);
           });
 
           it('has the proper terms type', () => {
-            expect(actualDocumentDeclaration.type).to.eql(expectedDocumentDeclaration.type);
+            expect(actualTerms.type).to.eql(expectedTerms.type);
           });
 
-          pages.forEach((page, index) => {
-            const { filters: expectedFilters } = page;
+          sourceDocuments.forEach((sourceDocument, index) => {
+            const { filters: expectedFilters } = sourceDocument;
 
-            context(`${page.id} page`, () => {
+            context(`${sourceDocument.id} sourceDocument`, () => {
               before(() => {
-                const { pages: actualPages } = actualDocumentDeclaration;
+                const { sourceDocuments: actualDocuments } = actualTerms;
 
-                ({ filters: actualFilters } = actualPages[index]);
+                ({ filters: actualFilters } = actualDocuments[index]);
               });
 
               if (expectedHistoryDates) {
@@ -189,34 +179,34 @@ describe('Services', () => {
                   context(`${date || 'Current'}`, () => {
                     let actualFiltersForThisDate;
                     let contentSelectorsForThisDate;
-                    let noiseSelectorsForThisDate;
+                    let insignificantContentSelectorsForThisDate;
                     let actualExecuteClientScriptsForThisDate;
 
-                    const { pages: pagesForThisDate } = expected.getDocumentDeclaration(documentType, date);
+                    const { sourceDocuments: documentsForThisDate } = expected.getTerms(termsType, date);
                     const {
                       filters: expectedFiltersForThisDate,
                       contentSelectors: expectedContentSelectors,
-                      noiseSelectors: expectedNoiseSelectors,
+                      insignificantContentSelectors: expectedInsignificantContentSelectors,
                       expectedExecuteClientScripts: expectedExecuteClientScriptsForThisDate,
-                    } = pagesForThisDate[index];
+                    } = documentsForThisDate[index];
 
                     before(() => {
-                      const { pages: actualPagesForThisDate } = result[serviceId].getDocumentDeclaration(documentType, date);
+                      const { sourceDocuments: actualDocumentsForThisDate } = result[serviceId].getTerms(termsType, date);
 
                       ({
                         filters: actualFiltersForThisDate,
                         contentSelectors: contentSelectorsForThisDate,
-                        noiseSelectors: noiseSelectorsForThisDate,
+                        insignificantContentSelectors: insignificantContentSelectorsForThisDate,
                         expectedExecuteClientScripts: actualExecuteClientScriptsForThisDate,
-                      } = actualPagesForThisDate[index]);
+                      } = actualDocumentsForThisDate[index]);
                     });
 
                     it('has the proper content selectors', async () => {
                       expect(contentSelectorsForThisDate).to.equal(expectedContentSelectors);
                     });
 
-                    it('has the proper noise selectors', async () => {
-                      expect(noiseSelectorsForThisDate).to.equal(expectedNoiseSelectors);
+                    it('has the proper insignificant content selectors', async () => {
+                      expect(insignificantContentSelectorsForThisDate).to.equal(expectedInsignificantContentSelectors);
                     });
 
                     it('has the proper executeClientScripts option', async () => {
@@ -242,7 +232,7 @@ describe('Services', () => {
                 }
               } else {
                 it('has no history', async () => {
-                  expect(actualDocumentDeclaration.validUntil).to.be.undefined;
+                  expect(actualTerms.validUntil).to.be.undefined;
                 });
 
                 if (expectedFilters) {
@@ -284,34 +274,24 @@ describe('Services', () => {
       await validateServiceWithHistory('service_B', expectedServices.service_B);
     });
 
-    context('when a service has no history', async () => {
-      describe('Service without history', async () => {
-        await validateServiceWithHistory('service_without_history', expectedServices.service_without_history);
-      });
+    describe('Service without history', async () => {
+      await validateServiceWithHistory('service_without_history', expectedServices.service_without_history);
     });
 
-    context('when a service has only declarations history', async () => {
-      describe('Service with declaration history', async () => {
-        await validateServiceWithHistory('service_with_declaration_history', expectedServices.service_with_declaration_history);
-      });
+    describe('Service with declaration history only', async () => {
+      await validateServiceWithHistory('service_with_declaration_history', expectedServices.service_with_declaration_history);
     });
 
-    context('when a service has only filters history', async () => {
-      describe('Service with filters history', async () => {
-        await validateServiceWithHistory('service_with_filters_history', expectedServices.service_with_filters_history);
-      });
+    describe('Service with filters history only', async () => {
+      await validateServiceWithHistory('service_with_filters_history', expectedServices.service_with_filters_history);
     });
 
-    context('when a service has both filters and declarations histories', async () => {
-      describe('Service with history', async () => {
-        await validateServiceWithHistory('service_with_history', expectedServices.service_with_history);
-      });
+    describe('Service with both filters and declarations histories', async () => {
+      await validateServiceWithHistory('service_with_history', expectedServices.service_with_history);
     });
 
-    context('when a service has a multipage document', async () => {
-      describe('Service with a multipage document', async () => {
-        await validateServiceWithHistory('service_with_multipage_document', expectedServices.service_with_multipage_document);
-      });
+    describe('Service with terms with multiple source documents', async () => {
+      await validateServiceWithHistory('service_with_multiple_source_documents_terms', expectedServices.service_with_multiple_source_documents_terms);
     });
 
     context('when specifying services to load', async () => {