@opentermsarchive/engine 1.1.3 → 1.2.0

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

@@ -7,26 +7,28 @@ const { expect } = chai;
 
 describe('Service', () => {
   let subject;
-  const TERMS_TYPE = 'Terms of Service';
+  const TERMS_OF_SERVICE_TYPE = 'Terms of Service';
+  const PRIVACY_POLICY_TYPE = 'Privacy Policy';
+  const IMPRINT_TYPE = 'Imprint';
 
   describe('#addTerms', () => {
     let terms;
 
-    before(async () => {
+    before(() => {
+      subject = new Service({ id: 'serviceID', name: 'serviceName' });
       terms = new Terms({
-        type: TERMS_TYPE,
+        type: TERMS_OF_SERVICE_TYPE,
         service: subject,
       });
     });
 
     context('when terms have no validity date', () => {
-      before(async () => {
-        subject = new Service({ id: 'serviceID', name: 'serviceName' });
+      before(() => {
         subject.addTerms(terms);
       });
 
-      it('adds the terms as the last valid terms', async () => {
-        expect(subject.getTerms({ type: TERMS_TYPE })).to.deep.eql(terms);
+      it('adds the terms as the last valid terms', () => {
+        expect(subject.getTerms({ type: TERMS_OF_SERVICE_TYPE })).to.deep.eql(terms);
       });
     });
 
@@ -34,10 +36,9 @@ describe('Service', () => {
       let expiredTerms;
       const VALIDITY_DATE = new Date('2020-07-22T11:30:21.000Z');
 
-      before(async () => {
-        subject = new Service({ id: 'serviceID', name: 'serviceName' });
+      before(() => {
         expiredTerms = new Terms({
-          type: TERMS_TYPE,
+          type: TERMS_OF_SERVICE_TYPE,
           service: subject,
           validUntil: VALIDITY_DATE,
         });
@@ -45,8 +46,8 @@ describe('Service', () => {
         subject.addTerms(terms);
       });
 
-      it('adds the terms with the proper validity date', async () => {
-        expect(subject.getTerms({ type: TERMS_TYPE, date: VALIDITY_DATE })).to.deep.eql(expiredTerms);
+      it('adds the terms with the proper validity date', () => {
+        expect(subject.getTerms({ type: TERMS_OF_SERVICE_TYPE, date: VALIDITY_DATE })).to.deep.eql(expiredTerms);
       });
     });
   });
@@ -58,15 +59,15 @@ describe('Service', () => {
     const DATE = '2020-07-22T11:30:21.000Z';
     const LATEST_DATE = '2020-08-21T11:30:21.000Z';
 
-    const firstTermsOfService = new Terms({ type: TERMS_TYPE, validUntil: DATE });
+    const firstTermsOfService = new Terms({ type: TERMS_OF_SERVICE_TYPE, validUntil: DATE });
     const firstPrivacyPolicy = new Terms({ type: 'Privacy Policy', validUntil: DATE });
 
-    const latestTermsOfService = new Terms({ type: TERMS_TYPE });
+    const latestTermsOfService = new Terms({ type: TERMS_OF_SERVICE_TYPE });
     const latestPrivacyPolicy = new Terms({ type: 'Privacy Policy' });
 
     const latestDeveloperTerms = new Terms({ type: 'Developer Terms' });
 
-    before(async () => {
+    before(() => {
       subject = new Service({ id: 'serviceID', name: 'serviceName' });
       subject.addTerms(firstTermsOfService);
       subject.addTerms(firstPrivacyPolicy);
@@ -76,7 +77,7 @@ describe('Service', () => {
     });
 
     context('when no params are given', () => {
-      it('returns all latest terms', async () => {
+      it('returns all latest terms', () => {
         expect(subject.getTerms()).to.deep.eql([ latestTermsOfService, latestPrivacyPolicy, latestDeveloperTerms ]);
       });
     });
@@ -84,45 +85,45 @@ describe('Service', () => {
     context('when a terms type is given', () => {
       context('when a date is given', () => {
         context('when the terms has no history', () => {
-          it('returns the latest terms according to the given type', async () => {
+          it('returns the latest terms according to the given type', () => {
             expect(subject.getTerms({ type: 'Developer Terms', date: LATEST_DATE })).to.eql(latestDeveloperTerms);
           });
         });
 
         context('when the terms have a history', () => {
-          it('returns the terms according to the given type and date', async () => {
-            expect(subject.getTerms({ type: TERMS_TYPE, date: EARLIEST_DATE })).to.eql(firstTermsOfService);
+          it('returns the terms according to the given type and date', () => {
+            expect(subject.getTerms({ type: TERMS_OF_SERVICE_TYPE, date: EARLIEST_DATE })).to.eql(firstTermsOfService);
           });
 
           context('when the given date is strictly equal to a terms validity date', () => {
-            it('returns the terms according to the given type with the validity date equal to the given date', async () => {
-              expect(subject.getTerms({ type: TERMS_TYPE, date: DATE })).to.eql(firstTermsOfService);
+            it('returns the terms according to the given type with the validity date equal to the given date', () => {
+              expect(subject.getTerms({ type: TERMS_OF_SERVICE_TYPE, date: DATE })).to.eql(firstTermsOfService);
             });
           });
         });
       });
 
       context('without a given date', () => {
-        it('returns the latest terms of given type', async () => {
-          expect(subject.getTerms({ type: TERMS_TYPE })).to.eql(latestTermsOfService);
+        it('returns the latest terms of given type', () => {
+          expect(subject.getTerms({ type: TERMS_OF_SERVICE_TYPE })).to.eql(latestTermsOfService);
         });
       });
     });
 
     context('when only a date is given', () => {
       context('when there is no history', () => {
-        it('returns all latest terms', async () => {
+        it('returns all latest terms', () => {
           expect(subject.getTerms({ date: LATEST_DATE })).to.deep.eql([ latestTermsOfService, latestPrivacyPolicy, latestDeveloperTerms ]);
         });
       });
 
       context('when the terms have a history', () => {
-        it('returns all the terms according to the given date', async () => {
+        it('returns all the terms according to the given date', () => {
           expect(subject.getTerms({ date: EARLIEST_DATE })).to.deep.eql([ firstTermsOfService, firstPrivacyPolicy, latestDeveloperTerms ]);
         });
 
         context('when the given date is strictly equal to a terms validity date', () => {
-          it('returns all the terms with the validity date equal to the given date', async () => {
+          it('returns all the terms with the validity date equal to the given date', () => {
             expect(subject.getTerms({ date: DATE })).to.deep.eql([ firstTermsOfService, firstPrivacyPolicy, latestDeveloperTerms ]);
           });
         });
@@ -131,29 +132,49 @@ describe('Service', () => {
   });
 
   describe('#getTermsTypes', () => {
-    let subject;
     let termsOfService;
     let privacyPolicy;
 
-    before(async () => {
+    before(() => {
       subject = new Service({ id: 'serviceID', name: 'serviceName' });
 
-      termsOfService = new Terms({ type: TERMS_TYPE });
-
-      privacyPolicy = new Terms({
-        type: 'Privacy Policy',
-        validUntil: '2020-07-22T11:30:21.000Z',
-      });
+      termsOfService = new Terms({ type: TERMS_OF_SERVICE_TYPE });
+      privacyPolicy = new Terms({ type: PRIVACY_POLICY_TYPE, validUntil: '2020-07-22T11:30:21.000Z' });
 
       subject.addTerms(termsOfService);
       subject.addTerms(privacyPolicy);
     });
 
-    it('returns the service terms types', async () => {
-      expect(subject.getTermsTypes()).to.have.members([
-        termsOfService.type,
-        privacyPolicy.type,
-      ]);
+    context('without any filter', () => {
+      it('returns all service terms types', () => {
+        expect(subject.getTermsTypes()).to.have.members([ TERMS_OF_SERVICE_TYPE, PRIVACY_POLICY_TYPE ]);
+      });
+    });
+
+    context('with a filter', () => {
+      it('returns filtered terms types', () => {
+        expect(subject.getTermsTypes([ PRIVACY_POLICY_TYPE, IMPRINT_TYPE ])).to.deep.equal([PRIVACY_POLICY_TYPE]);
+      });
+    });
+  });
+
+  describe('#getNumberOfTerms', () => {
+    before(() => {
+      subject = new Service({ id: 'serviceID', name: 'serviceName' });
+      subject.addTerms(new Terms({ type: TERMS_OF_SERVICE_TYPE }));
+      subject.addTerms(new Terms({ type: PRIVACY_POLICY_TYPE }));
+    });
+
+    context('without any filter', () => {
+      it('returns the number of all terms types', () => {
+        expect(subject.getNumberOfTerms()).to.equal(2);
+      });
+    });
+
+    context('with a filter', () => {
+      it('returns the number of terms matching the provided terms types', () => {
+        expect(subject.getNumberOfTerms([ TERMS_OF_SERVICE_TYPE, IMPRINT_TYPE ])).to.equal(1);
+      });
     });
   });
 });

package/src/logger/index.js

@@ -30,7 +30,7 @@ const alignedWithColorsAndTime = combine(
   }),
 );
 
-const consoleTransport = new winston.transports.Console();
+const consoleTransport = new winston.transports.Console(({ silent: process.env.NODE_ENV === 'test' }));
 
 const transports = [consoleTransport];
 
@@ -129,11 +129,11 @@ logger.onTrackingCompleted = (numberOfServices, numberOfTerms, extractOnly) => {
 };
 
 logger.onInaccessibleContent = ({ message }, terms) => {
-  logger.warn({ message, serviceId: terms.serviceId, termsType: terms.type });
+  logger.warn({ message, serviceId: terms.service.id, termsType: terms.type });
 };
 
 logger.onError = (error, terms) => {
-  logger.error({ message: error.stack, serviceId: terms.serviceId, termsType: terms.type });
+  logger.error({ message: error.stack, serviceId: terms.service.id, termsType: terms.type });
 };
 
 logger.onPluginError = (error, pluginName) => {

package/src/reporter/index.js

@@ -22,6 +22,8 @@ const ERROR_MESSAGE_TO_ISSUE_LABEL_MAP = {
   'unable to verify the first certificate': 'first certificate',
   'certificate has expired': 'certificate expired',
   'maximum redirect reached': 'redirects',
+  'not a valid selector': 'invalid selector',
+  'empty content': 'empty content',
 };
 
 function getLabelNameFromError(error) {
@@ -43,7 +45,7 @@ export default class Reporter {
     this.repositories = repositories;
   }
 
-  async initialize() {
+  initialize() {
     return this.github.initialize();
   }
 
@@ -65,7 +67,7 @@ No changes were found in the last run, so no new version has been recorded.`,
     });
   }
 
-  async onFirstVersionRecorded(version) {
+  onFirstVersionRecorded(version) {
     return this.onVersionRecorded(version);
   }
 

package/src/reporter/labels.json

@@ -59,6 +59,11 @@
     "color": "0b08a0",
     "description": "Fetching fails with a timeout error"
   },
+  {
+    "name": "empty content",
+    "color": "0b08a0",
+    "description": "Fetching fails because the server returns an empty content"
+  },
   {
     "name": "to clarify",
     "color": "0496ff",
@@ -73,5 +78,10 @@
     "name": "location",
     "color": "FBCA04",
     "description": "Fetch location is outdated"
+  },
+  {
+    "name": "invalid selector",
+    "color": "FBCA04",
+    "description": "Some selectors cannot be understood by the engine"
   }
 ]