@opentermsarchive/engine 0.26.1 → 0.27.1

package/src/archivist/recorder/repositories/git/index.test.js

@@ -6,9 +6,10 @@ import chai from 'chai';
 import config from 'config';
 import mime from 'mime';
 
-import Record from '../../record.js';
+import Snapshot from '../../snapshot.js';
+import Version from '../../version.js';
 
-import { DOCUMENT_TYPE_AND_PAGE_ID_SEPARATOR, SNAPSHOT_ID_MARKER } from './dataMapper.js';
+import { TERMS_TYPE_AND_DOCUMENT_ID_SEPARATOR, SNAPSHOT_ID_MARKER, COMMIT_MESSAGE_PREFIXES } from './dataMapper.js';
 import Git from './git.js';
 
 import GitRepository from './index.js';
@@ -16,700 +17,1294 @@ import GitRepository from './index.js';
 const { expect } = chai;
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const RECORDER_PATH = path.resolve(__dirname, '../../../', config.get('recorder.versions.storage.git.path'));
+
+const RECORDER_PATH = path.resolve(__dirname, '../../../../..', config.get('recorder.versions.storage.git.path'));
 
 const SERVICE_PROVIDER_ID = 'test_service';
-const DOCUMENT_TYPE = 'Terms of Service';
-const PAGE_ID = 'community-standards-hate-speech';
+const TERMS_TYPE = 'Terms of Service';
+const DOCUMENT_ID = '126382350847838';
 const CONTENT = 'ToS fixture data with UTF-8 çhãràčtęrs';
-const EXPECTED_FILE_PATH = `${RECORDER_PATH}/${SERVICE_PROVIDER_ID}/${DOCUMENT_TYPE}.html`;
-const EXPECTED_FILE_PATH_WITH_PAGE_ID = `${RECORDER_PATH}/${SERVICE_PROVIDER_ID}/${DOCUMENT_TYPE}${DOCUMENT_TYPE_AND_PAGE_ID_SEPARATOR}${PAGE_ID}.html`;
-const EXPECTED_PDF_FILE_PATH = EXPECTED_FILE_PATH.replace('html', 'pdf');
+
+const BASE_PATH = `${RECORDER_PATH}/${SERVICE_PROVIDER_ID}/${TERMS_TYPE}`;
+const EXPECTED_VERSION_FILE_PATH = `${BASE_PATH}.md`;
+const EXPECTED_SNAPSHOT_FILE_PATH = `${BASE_PATH}.html`;
+const EXPECTED_SNAPSHOT_FILE_PATH_WITH_DOCUMENT_ID = `${BASE_PATH}${TERMS_TYPE_AND_DOCUMENT_ID_SEPARATOR}${DOCUMENT_ID}.html`;
+const EXPECTED_PDF_SNAPSHOT_FILE_PATH = `${BASE_PATH}.pdf`;
+
 const FETCH_DATE = new Date('2000-01-01T12:00:00.000Z');
 const FETCH_DATE_LATER = new Date('2000-01-02T12:00:00.000Z');
 const FETCH_DATE_EARLIER = new Date('2000-01-01T06:00:00.000Z');
+
 const SNAPSHOT_ID = '513fadb2ae415c87747047e33287805d59e2dd55';
-const MIME_TYPE = 'text/html';
-const PDF_CONTENT = fs.readFileSync(path.resolve(__dirname, '../../../../../test/fixtures/terms.pdf'), { encoding: 'utf8' });
-const PDF_MIME_TYPE = 'application/pdf';
+const HTML_MIME_TYPE = mime.getType('html');
 
-let git;
+const PDF_MIME_TYPE = mime.getType('pdf');
+const PDF_CONTENT = fs.readFileSync(path.resolve(__dirname, '../../../../../test/fixtures/terms.pdf'), { encoding: 'utf8' });
 
 describe('GitRepository', () => {
+  let git;
   let subject;
 
-  before(async function () {
-    this.timeout(5000);
-    git = new Git({
-      path: RECORDER_PATH,
-      author: {
-        name: config.get('recorder.versions.storage.git.author.name'),
-        email: config.get('recorder.versions.storage.git.author.email'),
-      },
-    });
+  context('Version', () => {
+    before(async function () {
+      this.timeout(5000);
+
+      git = new Git({
+        path: RECORDER_PATH,
+        author: {
+          name: config.get('recorder.versions.storage.git.author.name'),
+          email: config.get('recorder.versions.storage.git.author.email'),
+        },
+      });
 
-    await git.initialize();
+      await git.initialize();
 
-    subject = new GitRepository({
-      ...config.get('recorder.versions.storage.git'),
-      path: RECORDER_PATH,
+      subject = new GitRepository({
+        ...config.get('recorder.versions.storage.git'),
+        path: RECORDER_PATH,
+      });
+
+      return subject.initialize();
     });
 
-    return subject.initialize();
-  });
+    describe('#save', () => {
+      let id;
+      let commit;
+      let isFirstRecord;
+      let numberOfRecordsBefore;
+      let numberOfRecordsAfter;
 
-  describe('#save', () => {
-    let id;
-    let commit;
-    let isFirstRecord;
-    let numberOfRecordsBefore;
-    let numberOfRecordsAfter;
+      context('when it is the first record', () => {
+        before(async () => {
+          numberOfRecordsBefore = (await git.log()).length;
 
-    context('when it is the first record', () => {
-      before(async () => {
-        numberOfRecordsBefore = (await git.log()).length;
+          ({ id, isFirstRecord } = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds: [SNAPSHOT_ID],
+          })));
+
+          numberOfRecordsAfter = (await git.log()).length;
+
+          ([commit] = await git.log());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(commit.hash).to.include(id);
+        });
+
+        it('states that it is the first record', () => {
+          expect(isFirstRecord).to.be.true;
+        });
+
+        it('stores the service ID', () => {
+          expect(commit.message).to.include(SERVICE_PROVIDER_ID);
+        });
+
+        it('stores the terms type', () => {
+          expect(commit.message).to.include(TERMS_TYPE);
+        });
+
+        it('stores information that it is the first record for these specific terms', () => {
+          expect(commit.message).to.include(COMMIT_MESSAGE_PREFIXES.startTracking);
+        });
+
+        it('stores the proper content', () => {
+          expect(fs.readFileSync(EXPECTED_VERSION_FILE_PATH, { encoding: 'utf8' })).to.equal(CONTENT);
+        });
+
+        it('stores the fetch date', () => {
+          expect(new Date(commit.date).getTime()).to.equal(FETCH_DATE.getTime());
+        });
+
+        it('stores the snapshot ID', () => {
+          expect(commit.body).to.include(SNAPSHOT_ID);
+        });
+      });
+
+      context('when it is not the first record', () => {
+        const UPDATED_CONTENT = `${CONTENT} updated`;
+
+        before(async () => {
+          await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            mimeType: HTML_MIME_TYPE,
+            fetchDate: FETCH_DATE,
+          }));
+
+          numberOfRecordsBefore = (await git.log()).length;
+
+          ({ id, isFirstRecord } = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: UPDATED_CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds: [SNAPSHOT_ID],
+            mimeType: HTML_MIME_TYPE,
+          })));
+
+          numberOfRecordsAfter = (await git.log()).length;
 
-        ({ id, isFirstRecord } = await subject.save(new Record({
+          ([commit] = await git.log());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(commit.hash).to.include(id);
+        });
+
+        it('states that it is not the first record', () => {
+          expect(isFirstRecord).to.be.false;
+        });
+      });
+
+      context('when the content has not changed', () => {
+        before(async () => {
+          await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+          }));
+
+          numberOfRecordsBefore = (await git.log()).length;
+
+          ({ id, isFirstRecord } = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+          })));
+
+          numberOfRecordsAfter = (await git.log()).length;
+        });
+
+        after(async () => subject.removeAll());
+
+        it('does not save the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore);
+        });
+
+        it('returns no id', () => {
+          expect(id).to.equal(undefined);
+        });
+      });
+
+      context('when it is an extracted only version', () => {
+        const EXTRACTED_ONLY_CONTENT = `${CONTENT} extracted only`;
+
+        before(async () => {
+          await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE_EARLIER,
+          })); // An extracted only version cannot be the first record
+
+          numberOfRecordsBefore = (await git.log()).length;
+
+          ({ id, isFirstRecord } = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: EXTRACTED_ONLY_CONTENT,
+            fetchDate: FETCH_DATE,
+            isExtractOnly: true,
+            snapshotIds: [SNAPSHOT_ID],
+          })));
+
+          numberOfRecordsAfter = (await git.log()).length;
+
+          ([commit] = await git.log());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(commit.hash).to.include(id);
+        });
+
+        it('stores information that it is an extracted only version', () => {
+          expect(commit.message).to.include(COMMIT_MESSAGE_PREFIXES.extractOnly);
+        });
+      });
+
+      context('when one snapshot ID is specified', () => {
+        const SNAPSHOT_ID = 'c01533c0e546ef430eea84d23c1b18a2b8420dfb';
+        const snapshotIds = [SNAPSHOT_ID];
+
+        before(async () => {
+          ({ id, isFirstRecord } = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds,
+          })));
+
+          ([commit] = await git.log());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('stores snapshot ID', () => {
+          expect(commit.body).to.include(config.get('recorder.versions.storage.git.snapshotIdentiferTemplate').replace(SNAPSHOT_ID_MARKER, SNAPSHOT_ID));
+        });
+
+        it('stores the service ID', () => {
+          expect(commit.message).to.include(SERVICE_PROVIDER_ID);
+        });
+
+        it('stores the terms type', () => {
+          expect(commit.message).to.include(TERMS_TYPE);
+        });
+      });
+
+      context('when there are many snapshots IDs specified', () => {
+        const SNAPSHOT_ID_1 = 'c01533c0e546ef430eea84d23c1b18a2b8420dfb';
+        const SNAPSHOT_ID_2 = '0fd16cca9e1a86a2267bd587107c485f06099d7d';
+        const snapshotIds = [ SNAPSHOT_ID_1, SNAPSHOT_ID_2 ];
+
+        before(async () => {
+          ({ id, isFirstRecord } = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds,
+          })));
+
+          ([commit] = await git.log());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('stores snapshots IDs', () => {
+          expect(commit.body).to.include(config.get('recorder.versions.storage.git.snapshotIdentiferTemplate').replace(SNAPSHOT_ID_MARKER, SNAPSHOT_ID_1));
+          expect(commit.body).to.include(config.get('recorder.versions.storage.git.snapshotIdentiferTemplate').replace(SNAPSHOT_ID_MARKER, SNAPSHOT_ID_2));
+        });
+
+        it('stores the number of source documents', () => {
+          expect(commit.body).to.include(`${snapshotIds.length} source documents`);
+        });
+
+        it('stores the service ID', () => {
+          expect(commit.message).to.include(SERVICE_PROVIDER_ID);
+        });
+
+        it('stores the terms type', () => {
+          expect(commit.message).to.include(TERMS_TYPE);
+        });
+      });
+    });
+
+    describe('#findById', () => {
+      let record;
+      let id;
+
+      before(async () => {
+        ({ id } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          pageId: PAGE_ID,
+          termsType: TERMS_TYPE,
           content: CONTENT,
           fetchDate: FETCH_DATE,
           snapshotIds: [SNAPSHOT_ID],
-          mimeType: MIME_TYPE,
+          mimeType: HTML_MIME_TYPE,
         })));
 
-        numberOfRecordsAfter = (await git.log()).length;
-
-        ([commit] = await git.log());
+        (record = await subject.findById(id));
       });
 
       after(async () => subject.removeAll());
 
-      it('saves the record', () => {
-        expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+      it('returns a Version object', () => {
+        expect(record).to.be.an.instanceof(Version);
       });
 
       it('returns the record id', () => {
-        expect(commit.hash).to.include(id);
+        expect(record.id).to.include(id);
       });
 
-      it('returns a boolean to know if it is the first record', () => {
-        expect(isFirstRecord).to.be.true;
+      it('states that it is the first record', () => {
+        expect(record.isFirstRecord).to.be.true;
       });
 
-      it('stores the service ID', () => {
-        expect(commit.message).to.include(SERVICE_PROVIDER_ID);
+      it('returns the service ID', () => {
+        expect(record.serviceId).to.equal(SERVICE_PROVIDER_ID);
       });
 
-      it('stores the terms type', () => {
-        expect(commit.message).to.include(DOCUMENT_TYPE);
+      it('returns the terms type', () => {
+        expect(record.termsType).to.equal(TERMS_TYPE);
       });
 
-      it('stores information that it is the first record for this specific document', () => {
-        expect(commit.message).to.include('Start tracking');
+      it('returns the content', async () => {
+        expect(record.content).to.equal(CONTENT);
       });
 
-      it('stores the proper content', () => {
-        expect(fs.readFileSync(EXPECTED_FILE_PATH_WITH_PAGE_ID, { encoding: 'utf8' })).to.equal(CONTENT);
+      it('returns the fetch date', () => {
+        expect(new Date(record.fetchDate).getTime()).to.equal(FETCH_DATE.getTime());
       });
 
-      context('when provided', () => {
-        it('stores the fetch date', () => {
-          expect(new Date(commit.date).getTime()).to.equal(FETCH_DATE.getTime());
-        });
-
-        it('stores the MIME type', () => {
-          expect(mime.getType(EXPECTED_FILE_PATH_WITH_PAGE_ID)).to.equal(MIME_TYPE);
-        });
-
-        it('stores the snapshot ID', () => {
-          expect(commit.body).to.include(SNAPSHOT_ID);
-        });
+      it('returns the snapshot ID', () => {
+        expect(record.snapshotIds).to.deep.equal([SNAPSHOT_ID]);
+      });
 
-        it('stores the page ID', () => {
-          expect(commit.body).to.include(PAGE_ID);
+      context('when requested record does not exist', () => {
+        it('returns null', async () => {
+          expect(await subject.findById('inexistantID')).to.equal(null);
         });
       });
     });
 
-    context('when it is not the first record', () => {
-      const UPDATED_CONTENT = `${CONTENT} updated`;
+    describe('#findAll', () => {
+      let records;
+      const expectedIds = [];
 
-      before(async () => {
-        await subject.save(new Record({
+      before(async function () {
+        this.timeout(5000);
+
+        const { id: id1 } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
+          termsType: TERMS_TYPE,
           content: CONTENT,
-          mimeType: MIME_TYPE,
           fetchDate: FETCH_DATE,
+          snapshotIds: [SNAPSHOT_ID],
         }));
 
-        numberOfRecordsBefore = (await git.log()).length;
+        expectedIds.push(id1);
 
-        ({ id, isFirstRecord } = await subject.save(new Record({
+        const { id: id2 } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: UPDATED_CONTENT,
-          fetchDate: FETCH_DATE,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated`,
+          fetchDate: FETCH_DATE_LATER,
           snapshotIds: [SNAPSHOT_ID],
-          mimeType: MIME_TYPE,
-        })));
+        }));
 
-        numberOfRecordsAfter = (await git.log()).length;
+        expectedIds.push(id2);
 
-        ([commit] = await git.log());
+        const { id: id3 } = await subject.save(new Version({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated 2`,
+          isExtractOnly: true,
+          fetchDate: FETCH_DATE_EARLIER,
+          snapshotIds: [SNAPSHOT_ID],
+        }));
+
+        expectedIds.push(id3);
+
+        (records = await subject.findAll());
       });
 
       after(async () => subject.removeAll());
 
-      it('saves the record', () => {
-        expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+      it('returns all records', () => {
+        expect(records.length).to.equal(3);
       });
 
-      it('returns the record id', () => {
-        expect(commit.hash).to.include(id);
+      it('returns Version objects', () => {
+        for (const record of records) {
+          expect(record).to.be.an.instanceof(Version);
+        }
       });
 
-      it('returns a boolean to know if it is the first record', () => {
-        expect(isFirstRecord).to.be.false;
+      it('returns records in ascending order', async () => {
+        expect(records.map(record => record.fetchDate)).to.deep.equal([ FETCH_DATE_EARLIER, FETCH_DATE, FETCH_DATE_LATER ]);
       });
     });
 
-    context('when the content has not changed', () => {
-      before(async () => {
-        await subject.save(new Record({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: CONTENT,
-          mimeType: MIME_TYPE,
-          fetchDate: FETCH_DATE,
-        }));
+    describe('#count', () => {
+      let count;
 
-        numberOfRecordsBefore = (await git.log()).length;
+      before(async function () {
+        this.timeout(5000);
 
-        ({ id, isFirstRecord } = await subject.save(new Record({
+        await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
+          termsType: TERMS_TYPE,
           content: CONTENT,
-          mimeType: MIME_TYPE,
           fetchDate: FETCH_DATE,
-        })));
+          snapshotIds: [SNAPSHOT_ID],
+        }));
+        await subject.save(new Version({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated`,
+          fetchDate: FETCH_DATE_LATER,
+          snapshotIds: [SNAPSHOT_ID],
+        }));
+        await subject.save(new Version({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated 2`,
+          isExtractOnly: true,
+          fetchDate: FETCH_DATE_EARLIER,
+          snapshotIds: [SNAPSHOT_ID],
+        }));
 
-        numberOfRecordsAfter = (await git.log()).length;
+        (count = await subject.count());
       });
 
       after(async () => subject.removeAll());
 
-      it('does not save the record', () => {
-        expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore);
+      it('returns the proper count', async () => {
+        expect(count).to.equal(3);
       });
+    });
 
-      it('returns no id', () => {
-        expect(id).to.equal(undefined);
+    describe('#findLatest', () => {
+      context('when there are records for the given service', () => {
+        let lastSnapshotId;
+        let latestRecord;
+
+        context('with HTML document', () => {
+          const UPDATED_FILE_CONTENT = `${CONTENT} (with additional content to trigger a record)`;
+
+          before(async () => {
+            await subject.save(new Version({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              content: CONTENT,
+              fetchDate: FETCH_DATE_EARLIER,
+              snapshotIds: [SNAPSHOT_ID],
+            }));
+
+            ({ id: lastSnapshotId } = await subject.save(new Version({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              content: UPDATED_FILE_CONTENT,
+              fetchDate: FETCH_DATE,
+              snapshotIds: [SNAPSHOT_ID],
+            })));
+
+            latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, TERMS_TYPE);
+          });
+
+          after(async () => subject.removeAll());
+
+          it('returns a Version object', () => {
+            expect(latestRecord).to.be.an.instanceof(Version);
+          });
+
+          it('returns the latest record id', () => {
+            expect(latestRecord.id).to.include(lastSnapshotId);
+          });
+
+          it('returns the latest record content', async () => {
+            expect(latestRecord.content.toString('utf8')).to.equal(UPDATED_FILE_CONTENT);
+          });
+        });
+      });
+
+      context('when there are no records for the given service', () => {
+        let latestRecord;
+
+        before(async () => {
+          latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, TERMS_TYPE);
+        });
+
+        it('returns null', async () => {
+          expect(latestRecord).to.equal(null);
+        });
       });
     });
 
-    context('when it is a refilter', () => {
-      const REFILTERED_CONTENT = `${CONTENT} refiltered`;
+    describe('#iterate', () => {
+      const expectedIds = [];
+      const ids = [];
+      const fetchDates = [];
 
       before(async () => {
-        await subject.save(new Record({
+        const { id: id1 } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
+          termsType: TERMS_TYPE,
           content: CONTENT,
-          mimeType: MIME_TYPE,
-          fetchDate: FETCH_DATE_EARLIER,
-        })); // A refilter cannot be the first record
+          fetchDate: FETCH_DATE,
+          snapshotIds: [SNAPSHOT_ID],
+          mimeType: HTML_MIME_TYPE,
+        }));
 
-        numberOfRecordsBefore = (await git.log()).length;
+        expectedIds.push(id1);
 
-        ({ id, isFirstRecord } = await subject.save(new Record({
+        const { id: id2 } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: REFILTERED_CONTENT,
-          fetchDate: FETCH_DATE,
-          isRefilter: true,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated`,
+          fetchDate: FETCH_DATE_LATER,
           snapshotIds: [SNAPSHOT_ID],
-          mimeType: MIME_TYPE,
-        })));
+          mimeType: HTML_MIME_TYPE,
+        }));
 
-        numberOfRecordsAfter = (await git.log()).length;
+        expectedIds.push(id2);
 
-        ([commit] = await git.log());
+        const { id: id3 } = await subject.save(new Version({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated 2`,
+          isExtractOnly: true,
+          fetchDate: FETCH_DATE_EARLIER,
+          snapshotIds: [SNAPSHOT_ID],
+          mimeType: HTML_MIME_TYPE,
+        }));
+
+        expectedIds.push(id3);
+
+        for await (const record of subject.iterate()) {
+          ids.push(record.id);
+          fetchDates.push(record.fetchDate);
+        }
       });
 
       after(async () => subject.removeAll());
 
-      it('saves the record', () => {
-        expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+      it('iterates through all records', async () => {
+        expect(ids).to.have.members(expectedIds);
       });
 
-      it('returns the record id', () => {
-        expect(commit.hash).to.include(id);
+      it('iterates in ascending order', async () => {
+        expect(fetchDates).to.deep.equal([ FETCH_DATE_EARLIER, FETCH_DATE, FETCH_DATE_LATER ]);
       });
+    });
+  });
 
-      it('stores information that it is a refilter of this specific document', () => {
-        expect(commit.message).to.include('Refilter');
+  context('Snapshot', () => {
+    before(async function () {
+      this.timeout(5000);
+      git = new Git({
+        path: RECORDER_PATH,
+        author: {
+          name: config.get('recorder.snapshots.storage.git.author.name'),
+          email: config.get('recorder.snapshots.storage.git.author.email'),
+        },
       });
+
+      await git.initialize();
+
+      subject = new GitRepository({
+        ...config.get('recorder.snapshots.storage.git'),
+        path: RECORDER_PATH,
+      });
+
+      return subject.initialize();
     });
 
-    context('with PDF document', () => {
-      before(async () => {
-        numberOfRecordsBefore = (await git.log()).length;
+    describe('#save', () => {
+      let id;
+      let commit;
+      let isFirstRecord;
+      let numberOfRecordsBefore;
+      let numberOfRecordsAfter;
 
-        ({ id, isFirstRecord } = await subject.save(new Record({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: PDF_CONTENT,
-          fetchDate: FETCH_DATE,
-          snapshotIds: [SNAPSHOT_ID],
-          mimeType: PDF_MIME_TYPE,
-        })));
+      context('when it is the first record', () => {
+        before(async () => {
+          numberOfRecordsBefore = (await git.log()).length;
+
+          ({ id, isFirstRecord } = await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            documentId: DOCUMENT_ID,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            mimeType: HTML_MIME_TYPE,
+          })));
+
+          numberOfRecordsAfter = (await git.log()).length;
+
+          ([commit] = await git.log());
+        });
+
+        after(async () => subject.removeAll());
 
-        numberOfRecordsAfter = (await git.log()).length;
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(commit.hash).to.include(id);
+        });
+
+        it('states that it is the first record', () => {
+          expect(isFirstRecord).to.be.true;
+        });
+
+        it('stores the service ID', () => {
+          expect(commit.message).to.include(SERVICE_PROVIDER_ID);
+        });
+
+        it('stores the terms type', () => {
+          expect(commit.message).to.include(TERMS_TYPE);
+        });
+
+        it('stores information that it is the first record for these specific terms', () => {
+          expect(commit.message).to.include(COMMIT_MESSAGE_PREFIXES.startTracking);
+        });
+
+        it('stores the proper content', () => {
+          expect(fs.readFileSync(EXPECTED_SNAPSHOT_FILE_PATH_WITH_DOCUMENT_ID, { encoding: 'utf8' })).to.equal(CONTENT);
+        });
 
-        ([commit] = await git.log());
+        it('stores the fetch date', () => {
+          expect(new Date(commit.date).getTime()).to.equal(FETCH_DATE.getTime());
+        });
+
+        it('stores the MIME type', () => {
+          expect(mime.getType(EXPECTED_SNAPSHOT_FILE_PATH_WITH_DOCUMENT_ID)).to.equal(HTML_MIME_TYPE);
+        });
+
+        it('stores the document ID', () => {
+          expect(commit.body).to.include(DOCUMENT_ID);
+        });
       });
 
-      after(async () => subject.removeAll());
+      context('when it is not the first record', () => {
+        const UPDATED_CONTENT = `${CONTENT} updated`;
+
+        before(async () => {
+          await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            mimeType: HTML_MIME_TYPE,
+            fetchDate: FETCH_DATE,
+          }));
+
+          numberOfRecordsBefore = (await git.log()).length;
+
+          ({ id, isFirstRecord } = await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: UPDATED_CONTENT,
+            fetchDate: FETCH_DATE,
+            mimeType: HTML_MIME_TYPE,
+          })));
+
+          numberOfRecordsAfter = (await git.log()).length;
+
+          ([commit] = await git.log());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(commit.hash).to.include(id);
+        });
 
-      it('saves the record', () => {
-        expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        it('states that it is not the first record', () => {
+          expect(isFirstRecord).to.be.false;
+        });
       });
 
-      it('returns the record id', () => {
-        expect(commit.hash).to.include(id);
+      context('when the content has not changed', () => {
+        before(async () => {
+          await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            mimeType: HTML_MIME_TYPE,
+            fetchDate: FETCH_DATE,
+          }));
+
+          numberOfRecordsBefore = (await git.log()).length;
+
+          ({ id, isFirstRecord } = await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            mimeType: HTML_MIME_TYPE,
+            fetchDate: FETCH_DATE,
+          })));
+
+          numberOfRecordsAfter = (await git.log()).length;
+        });
+
+        after(async () => subject.removeAll());
+
+        it('does not save the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore);
+        });
+
+        it('returns no id', () => {
+          expect(id).to.equal(undefined);
+        });
       });
 
-      it('stores the proper content', () => {
-        expect(fs.readFileSync(EXPECTED_PDF_FILE_PATH, { encoding: 'utf8' })).to.equal(PDF_CONTENT);
+      context('when there are no document ID specified', () => {
+        before(async () => {
+          numberOfRecordsBefore = (await git.log()).length;
+
+          ({ id, isFirstRecord } = await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            mimeType: HTML_MIME_TYPE,
+          })));
+
+          numberOfRecordsAfter = (await git.log()).length;
+
+          ([commit] = await git.log());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(commit.hash).to.include(id);
+        });
+
+        it('stores the proper content under the proper file path', () => {
+          expect(fs.readFileSync(EXPECTED_SNAPSHOT_FILE_PATH, { encoding: 'utf8' })).to.equal(CONTENT);
+        });
       });
 
-      it('stores the MIME type', () => {
-        expect(mime.getType(EXPECTED_PDF_FILE_PATH)).to.equal(PDF_MIME_TYPE);
+      context('with PDF document', () => {
+        before(async () => {
+          numberOfRecordsBefore = (await git.log()).length;
+
+          ({ id, isFirstRecord } = await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: PDF_CONTENT,
+            fetchDate: FETCH_DATE,
+            mimeType: PDF_MIME_TYPE,
+          })));
+
+          numberOfRecordsAfter = (await git.log()).length;
+
+          ([commit] = await git.log());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(commit.hash).to.include(id);
+        });
+
+        it('stores the proper content', () => {
+          expect(fs.readFileSync(EXPECTED_PDF_SNAPSHOT_FILE_PATH, { encoding: 'utf8' })).to.equal(PDF_CONTENT);
+        });
+        it('stores the MIME type', () => {
+          expect(mime.getType(EXPECTED_PDF_SNAPSHOT_FILE_PATH)).to.equal(PDF_MIME_TYPE);
+        });
       });
     });
 
-    context('when there is no snapshots IDs specified', () => {
+    describe('#findById', () => {
+      let record;
+      let id;
+
       before(async () => {
-        ({ id, isFirstRecord } = await subject.save(new Record({
+        ({ id } = await subject.save(new Snapshot({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          pageId: PAGE_ID,
+          termsType: TERMS_TYPE,
+          documentId: DOCUMENT_ID,
           content: CONTENT,
           fetchDate: FETCH_DATE,
-          mimeType: MIME_TYPE,
+          mimeType: HTML_MIME_TYPE,
         })));
 
-        ([commit] = await git.log());
+        (record = await subject.findById(id));
       });
 
       after(async () => subject.removeAll());
 
-      it('does not store snapshots IDs', () => {
-        expect(commit.body).to.be.equal(`Page ID ${PAGE_ID}\n`);
+      it('returns a Snapshot object', () => {
+        expect(record).to.be.an.instanceof(Snapshot);
       });
 
-      it('stores the service ID', () => {
-        expect(commit.message).to.include(SERVICE_PROVIDER_ID);
+      it('returns the record id', () => {
+        expect(record.id).to.include(id);
       });
 
-      it('stores the terms type', () => {
-        expect(commit.message).to.include(DOCUMENT_TYPE);
+      it('states that it is the first record', () => {
+        expect(record.isFirstRecord).to.be.true;
       });
 
-      it('stores the page ID', () => {
-        expect(commit.body).to.include(PAGE_ID);
+      it('returns the service ID', () => {
+        expect(record.serviceId).to.equal(SERVICE_PROVIDER_ID);
       });
-    });
-
-    context('when one snapshot ID is specified', () => {
-      const SNAPSHOT_ID = 'c01533c0e546ef430eea84d23c1b18a2b8420dfb';
-      const snapshotIds = [SNAPSHOT_ID];
-
-      before(async () => {
-        ({ id, isFirstRecord } = await subject.save(new Record({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          pageId: PAGE_ID,
-          content: CONTENT,
-          fetchDate: FETCH_DATE,
-          mimeType: MIME_TYPE,
-          snapshotIds,
-        })));
 
-        ([commit] = await git.log());
+      it('returns the terms type', () => {
+        expect(record.termsType).to.equal(TERMS_TYPE);
       });
 
-      after(async () => subject.removeAll());
+      it('returns the content', async () => {
+        expect(record.content).to.equal(CONTENT);
+      });
 
-      it('stores snapshot ID', () => {
-        expect(commit.body).to.include(config.get('recorder.versions.storage.git.snapshotIdentiferTemplate').replace(SNAPSHOT_ID_MARKER, SNAPSHOT_ID));
+      it('returns the fetch date', () => {
+        expect(new Date(record.fetchDate).getTime()).to.equal(FETCH_DATE.getTime());
       });
 
-      it('stores the service ID', () => {
-        expect(commit.message).to.include(SERVICE_PROVIDER_ID);
+      it('returns the MIME type', () => {
+        expect(record.mimeType).to.equal(HTML_MIME_TYPE);
       });
 
-      it('stores the terms type', () => {
-        expect(commit.message).to.include(DOCUMENT_TYPE);
+      it('returns the document ID', () => {
+        expect(record.documentId).to.equal(DOCUMENT_ID);
       });
 
-      it('stores the page ID', () => {
-        expect(commit.body).to.include(PAGE_ID);
+      context('when requested record does not exist', () => {
+        it('returns null', async () => {
+          expect(await subject.findById('inexistantID')).to.equal(null);
+        });
       });
     });
 
-    context('when there are many snapshots IDs specified', () => {
-      const SNAPSHOT_ID_1 = 'c01533c0e546ef430eea84d23c1b18a2b8420dfb';
-      const SNAPSHOT_ID_2 = '0fd16cca9e1a86a2267bd587107c485f06099d7d';
-      const snapshotIds = [ SNAPSHOT_ID_1, SNAPSHOT_ID_2 ];
+    describe('#findAll', () => {
+      let records;
+      const expectedIds = [];
 
-      before(async () => {
-        ({ id, isFirstRecord } = await subject.save(new Record({
+      before(async function () {
+        this.timeout(5000);
+
+        const { id: id1 } = await subject.save(new Snapshot({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          pageId: PAGE_ID,
+          termsType: TERMS_TYPE,
           content: CONTENT,
           fetchDate: FETCH_DATE,
-          mimeType: MIME_TYPE,
-          snapshotIds,
-        })));
+          documentId: DOCUMENT_ID,
+          mimeType: HTML_MIME_TYPE,
+        }));
+
+        expectedIds.push(id1);
+
+        const { id: id2 } = await subject.save(new Snapshot({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated`,
+          fetchDate: FETCH_DATE_LATER,
+          mimeType: HTML_MIME_TYPE,
+        }));
+
+        expectedIds.push(id2);
 
-        ([commit] = await git.log());
+        const { id: id3 } = await subject.save(new Snapshot({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated 2`,
+          isExtractOnly: true,
+          fetchDate: FETCH_DATE_EARLIER,
+          mimeType: HTML_MIME_TYPE,
+        }));
+
+        expectedIds.push(id3);
+
+        (records = await subject.findAll());
       });
 
       after(async () => subject.removeAll());
 
-      it('stores snapshots IDs', () => {
-        expect(commit.body).to.include(config.get('recorder.versions.storage.git.snapshotIdentiferTemplate').replace(SNAPSHOT_ID_MARKER, SNAPSHOT_ID_1));
-        expect(commit.body).to.include(config.get('recorder.versions.storage.git.snapshotIdentiferTemplate').replace(SNAPSHOT_ID_MARKER, SNAPSHOT_ID_2));
+      it('returns all records', () => {
+        expect(records.length).to.equal(3);
       });
 
-      it('stores number of pages', () => {
-        expect(commit.body).to.include(`${snapshotIds.length} pages`);
+      it('returns Snapshot objects', () => {
+        for (const record of records) {
+          expect(record).to.be.an.instanceof(Snapshot);
+        }
       });
 
-      it('stores the service ID', () => {
-        expect(commit.message).to.include(SERVICE_PROVIDER_ID);
+      it('returns records in ascending order', async () => {
+        expect(records.map(record => record.fetchDate)).to.deep.equal([ FETCH_DATE_EARLIER, FETCH_DATE, FETCH_DATE_LATER ]);
       });
+    });
+
+    describe('#count', () => {
+      let count;
+
+      before(async function () {
+        this.timeout(5000);
 
-      it('stores the terms type', () => {
-        expect(commit.message).to.include(DOCUMENT_TYPE);
+        await subject.save(new Snapshot({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: CONTENT,
+          fetchDate: FETCH_DATE,
+          mimeType: HTML_MIME_TYPE,
+        }));
+        await subject.save(new Snapshot({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated`,
+          fetchDate: FETCH_DATE_LATER,
+          mimeType: HTML_MIME_TYPE,
+        }));
+        await subject.save(new Snapshot({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated 2`,
+          isExtractOnly: true,
+          fetchDate: FETCH_DATE_EARLIER,
+          mimeType: HTML_MIME_TYPE,
+        }));
+
+        (count = await subject.count());
       });
 
-      it('stores the page ID', () => {
-        expect(commit.body).to.include(PAGE_ID);
+      after(async () => subject.removeAll());
+
+      it('returns the proper count', async () => {
+        expect(count).to.equal(3);
       });
     });
-  });
 
-  describe('#findById', () => {
-    let record;
-    let id;
-
-    before(async () => {
-      ({ id } = await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        pageId: PAGE_ID,
-        content: CONTENT,
-        fetchDate: FETCH_DATE,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      })));
-
-      (record = await subject.findById(id));
-    });
+    describe('#findLatest', () => {
+      context('when there are records for the given service', () => {
+        let lastSnapshotId;
+        let latestRecord;
+
+        context('with HTML document', () => {
+          const UPDATED_FILE_CONTENT = `${CONTENT} (with additional content to trigger a record)`;
+
+          before(async () => {
+            await subject.save(new Snapshot({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              content: CONTENT,
+              mimeType: HTML_MIME_TYPE,
+              fetchDate: FETCH_DATE_EARLIER,
+            }));
+
+            ({ id: lastSnapshotId } = await subject.save(new Snapshot({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              content: UPDATED_FILE_CONTENT,
+              mimeType: HTML_MIME_TYPE,
+              fetchDate: FETCH_DATE,
+            })));
+
+            latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, TERMS_TYPE);
+          });
+
+          after(async () => subject.removeAll());
+
+          it('returns a Snapshot object', () => {
+            expect(latestRecord).to.be.an.instanceof(Snapshot);
+          });
+
+          it('returns the latest record id', () => {
+            expect(latestRecord.id).to.include(lastSnapshotId);
+          });
+
+          it('returns the latest record content', async () => {
+            expect(latestRecord.content.toString('utf8')).to.equal(UPDATED_FILE_CONTENT);
+          });
+
+          it('returns the latest record mime type', () => {
+            expect(latestRecord.mimeType).to.equal(HTML_MIME_TYPE);
+          });
+        });
 
-    after(async () => subject.removeAll());
+        context('with PDF document', () => {
+          before(async () => {
+            ({ id: lastSnapshotId } = await subject.save(new Snapshot({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              content: PDF_CONTENT,
+              mimeType: PDF_MIME_TYPE,
+              fetchDate: FETCH_DATE,
+            })));
 
-    it('returns the record id', () => {
-      expect(record.id).to.include(id);
-    });
+            latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, TERMS_TYPE);
+          });
 
-    it('returns a boolean to know if it is the first record', () => {
-      expect(record.isFirstRecord).to.be.true;
-    });
+          after(async () => subject.removeAll());
 
-    it('returns the service ID', () => {
-      expect(record.serviceId).to.equal(SERVICE_PROVIDER_ID);
-    });
+          it('returns the latest record id', () => {
+            expect(latestRecord.id).to.include(lastSnapshotId);
+          });
 
-    it('returns the terms type', () => {
-      expect(record.documentType).to.equal(DOCUMENT_TYPE);
-    });
+          it('returns the latest record content', async () => {
+            expect(latestRecord.content.toString('utf8')).to.equal(PDF_CONTENT);
+          });
 
-    it('returns the content', async () => {
-      expect(record.content).to.equal(CONTENT);
-    });
+          it('returns the latest record mime type', () => {
+            expect(latestRecord.mimeType).to.equal(PDF_MIME_TYPE);
+          });
+        });
+      });
 
-    it('returns the fetch date', () => {
-      expect(new Date(record.fetchDate).getTime()).to.equal(FETCH_DATE.getTime());
-    });
+      context('when there are no records for the given service', () => {
+        let latestRecord;
 
-    it('returns the MIME type', () => {
-      expect(record.mimeType).to.equal(MIME_TYPE);
-    });
+        before(async () => {
+          latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, TERMS_TYPE);
+        });
 
-    it('returns the snapshot ID', () => {
-      expect(record.snapshotIds).to.deep.equal([SNAPSHOT_ID]);
+        it('returns null', async () => {
+          expect(latestRecord).to.equal(null);
+        });
+      });
     });
 
-    it('returns the page ID', () => {
-      expect(record.pageId).to.equal(PAGE_ID);
-    });
+    describe('#iterate', () => {
+      const expectedIds = [];
+      const ids = [];
+      const fetchDates = [];
 
-    context('when requested record does not exist', () => {
-      it('returns null', async () => {
-        expect(await subject.findById('inexistantID')).to.equal(null);
-      });
-    });
-  });
+      before(async () => {
+        const { id: id1 } = await subject.save(new Snapshot({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: CONTENT,
+          fetchDate: FETCH_DATE,
+          mimeType: HTML_MIME_TYPE,
+        }));
 
-  describe('#findAll', () => {
-    let records;
-    const expectedIds = [];
+        expectedIds.push(id1);
 
-    before(async function () {
-      this.timeout(5000);
+        const { id: id2 } = await subject.save(new Snapshot({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated`,
+          fetchDate: FETCH_DATE_LATER,
+          mimeType: HTML_MIME_TYPE,
+        }));
 
-      const { id: id1 } = await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        content: CONTENT,
-        fetchDate: FETCH_DATE,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      }));
-
-      expectedIds.push(id1);
-
-      const { id: id2 } = await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        content: `${CONTENT} - updated`,
-        fetchDate: FETCH_DATE_LATER,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      }));
-
-      expectedIds.push(id2);
-
-      const { id: id3 } = await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        content: `${CONTENT} - updated 2`,
-        isRefilter: true,
-        fetchDate: FETCH_DATE_EARLIER,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      }));
-
-      expectedIds.push(id3);
-
-      (records = await subject.findAll());
-    });
+        expectedIds.push(id2);
 
-    after(async () => subject.removeAll());
+        const { id: id3 } = await subject.save(new Snapshot({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated 2`,
+          isExtractOnly: true,
+          fetchDate: FETCH_DATE_EARLIER,
+          mimeType: HTML_MIME_TYPE,
+        }));
 
-    it('returns all records', () => {
-      expect(records.length).to.equal(3);
-    });
+        expectedIds.push(id3);
 
-    it('returns Record objects', () => {
-      for (const record of records) {
-        expect(record).to.be.an.instanceof(Record);
-      }
-    });
+        for await (const record of subject.iterate()) {
+          ids.push(record.id);
+          fetchDates.push(record.fetchDate);
+        }
+      });
+
+      after(async () => subject.removeAll());
+
+      it('iterates through all records', async () => {
+        expect(ids).to.have.members(expectedIds);
+      });
 
-    it('returns records in ascending order', async () => {
-      expect(records.map(record => record.fetchDate)).to.deep.equal([ FETCH_DATE_EARLIER, FETCH_DATE, FETCH_DATE_LATER ]);
+      it('iterates in ascending order', async () => {
+        expect(fetchDates).to.deep.equal([ FETCH_DATE_EARLIER, FETCH_DATE, FETCH_DATE_LATER ]);
+      });
     });
   });
 
-  describe('#count', () => {
-    let count;
+  context('backwards compatibility with deprecated commit messages', () => {
+    const expectedIds = [];
+    const expectedDates = [];
+
+    let subject;
+
+    const commits = {
+      deprecatedFirstRecord: {
+        path: 'service/terms-deprecated.md',
+        content: 'content',
+        message: 'Start tracking Service Terms\n\nThis version was recorded after extracting from snapshot https://github.com/ambanum/OpenTermsArchive-snapshots/commit/513fadb2ae415c87747047e33287805d59e2dd55',
+        date: new Date('2023-02-28T01:00:00.000Z'),
+      },
+      deprecatedRefilter: {
+        path: 'service/terms-deprecated.md',
+        content: 'content refiltered',
+        message: 'Refilter Service Terms\n\nThis version was recorded after extracting from snapshot https://github.com/ambanum/OpenTermsArchive-snapshots/commit/513fadb2ae415c87747047e33287805d59e2dd55',
+        date: new Date('2023-02-28T02:00:00.000Z'),
+      },
+      deprecatedUpdate: {
+        path: 'service/terms-deprecated.md',
+        content: 'content updated',
+        message: 'Update Service Terms\n\nThis version was recorded after extracting from snapshot https://github.com/ambanum/OpenTermsArchive-snapshots/commit/513fadb2ae415c87747047e33287805d59e2dd55',
+        date: new Date('2023-02-28T03:00:00.000Z'),
+      },
+      currentFirstRecord: {
+        path: 'service/terms-current.md',
+        content: 'content',
+        message: 'First record of Service Terms\n\nThis version was recorded after extracting from snapshot https://github.com/ambanum/OpenTermsArchive-snapshots/commit/513fadb2ae415c87747047e33287805d59e2dd55',
+        date: new Date('2023-02-28T04:00:00.000Z'),
+      },
+      currentExtractOnly: {
+        path: 'service/terms-current.md',
+        content: 'content extract only',
+        message: 'Apply technical or declaration upgrade on Service Terms\n\nThis version was recorded after extracting from snapshot https://github.com/ambanum/OpenTermsArchive-snapshots/commit/513fadb2ae415c87747047e33287805d59e2dd55',
+        date: new Date('2023-02-28T05:00:00.000Z'),
+      },
+      currentUpdate: {
+        path: 'service/terms-current.md',
+        content: 'content updated',
+        message: 'Record new changes of Service Terms\n\nThis version was recorded after extracting from snapshot https://github.com/ambanum/OpenTermsArchive-snapshots/commit/513fadb2ae415c87747047e33287805d59e2dd55',
+        date: new Date('2023-02-28T06:00:00.000Z'),
+      },
+    };
 
     before(async function () {
       this.timeout(5000);
+      git = new Git({
+        path: RECORDER_PATH,
+        author: {
+          name: config.get('recorder.versions.storage.git.author.name'),
+          email: config.get('recorder.versions.storage.git.author.email'),
+        },
+      });
 
-      await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        content: CONTENT,
-        fetchDate: FETCH_DATE,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      }));
-      await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        content: `${CONTENT} - updated`,
-        fetchDate: FETCH_DATE_LATER,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      }));
-      await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        content: `${CONTENT} - updated 2`,
-        isRefilter: true,
-        fetchDate: FETCH_DATE_EARLIER,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      }));
-
-      (count = await subject.count());
-    });
+      await git.initialize();
+      subject = new GitRepository({
+        ...config.get('recorder.versions.storage.git'),
+        path: RECORDER_PATH,
+      });
 
-    after(async () => subject.removeAll());
+      await subject.initialize();
 
-    it('returns the proper count', async () => {
-      expect(count).to.equal(3);
-    });
-  });
+      /* eslint-disable no-await-in-loop */
+      for (const commit of Object.values(commits)) {
+        const { path: relativeFilePath, date, content, message } = commit;
+        const filePath = path.join(RECORDER_PATH, relativeFilePath);
 
-  describe('#findLatest', () => {
-    context('when there are records for the given service', () => {
-      let lastSnapshotId;
-      let latestRecord;
+        await GitRepository.writeFile({ filePath, content });
 
-      context('with HTML document', () => {
-        const UPDATED_FILE_CONTENT = `${CONTENT} (with additional content to trigger a record)`;
+        await git.add(filePath);
+        const sha = await git.commit({ filePath, message, date });
 
-        before(async () => {
-          await subject.save(new Record({
-            serviceId: SERVICE_PROVIDER_ID,
-            documentType: DOCUMENT_TYPE,
-            content: CONTENT,
-            mimeType: MIME_TYPE,
-            fetchDate: FETCH_DATE_EARLIER,
-          }));
+        commit.id = sha;
+        expectedIds.push(sha);
+        expectedDates.push(date);
+      }
+      /* eslint-enable no-await-in-loop */
+    });
 
-          ({ id: lastSnapshotId } = await subject.save(new Record({
-            serviceId: SERVICE_PROVIDER_ID,
-            documentType: DOCUMENT_TYPE,
-            content: UPDATED_FILE_CONTENT,
-            mimeType: MIME_TYPE,
-            fetchDate: FETCH_DATE,
-          })));
+    after(async () => subject.removeAll());
+
+    describe('Records attributes', () => {
+      describe('#isExtractOnly', () => {
+        context('records with deprecated message', () => {
+          it('returns the proper value', async () => {
+            expect((await subject.findById(commits.deprecatedRefilter.id)).isExtractOnly).to.be.true;
+          });
 
-          latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, DOCUMENT_TYPE);
+          it('returns the proper value', async () => {
+            expect((await subject.findById(commits.deprecatedFirstRecord.id)).isExtractOnly).to.be.false;
+          });
         });
 
-        after(async () => subject.removeAll());
+        context('record with current message', () => {
+          it('returns the proper value', async () => {
+            expect((await subject.findById(commits.currentExtractOnly.id)).isExtractOnly).to.be.true;
+          });
 
-        it('returns the latest record id', () => {
-          expect(latestRecord.id).to.include(lastSnapshotId);
+          it('returns the proper value', async () => {
+            expect((await subject.findById(commits.currentFirstRecord.id)).isExtractOnly).to.be.false;
+          });
         });
+      });
 
-        it('returns the latest record content', async () => {
-          expect(latestRecord.content.toString('utf8')).to.equal(UPDATED_FILE_CONTENT);
+      describe('#isFirstRecord', () => {
+        context('records with deprecated message', () => {
+          it('returns the proper value', async () => {
+            expect((await subject.findById(commits.deprecatedFirstRecord.id)).isFirstRecord).to.be.true;
+          });
+
+          it('returns the proper value', async () => {
+            expect((await subject.findById(commits.deprecatedRefilter.id)).isFirstRecord).to.be.false;
+          });
         });
 
-        it('returns the latest record mime type', () => {
-          expect(latestRecord.mimeType).to.equal(MIME_TYPE);
+        context('record with current message', () => {
+          it('returns the proper value', async () => {
+            expect((await subject.findById(commits.currentFirstRecord.id)).isFirstRecord).to.be.true;
+          });
+
+          it('returns the proper value', async () => {
+            expect((await subject.findById(commits.currentExtractOnly.id)).isFirstRecord).to.be.false;
+          });
         });
       });
+    });
 
-      context('with PDF document', () => {
-        before(async () => {
-          ({ id: lastSnapshotId } = await subject.save(new Record({
-            serviceId: SERVICE_PROVIDER_ID,
-            documentType: DOCUMENT_TYPE,
-            content: PDF_CONTENT,
-            mimeType: PDF_MIME_TYPE,
-            fetchDate: FETCH_DATE,
-          })));
+    describe('#findAll', () => {
+      let records;
 
-          latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, DOCUMENT_TYPE);
-        });
+      before(async function () {
+        this.timeout(5000);
 
-        after(async () => subject.removeAll());
+        (records = await subject.findAll());
+      });
 
-        it('returns the latest record id', () => {
-          expect(latestRecord.id).to.include(lastSnapshotId);
-        });
+      it('returns all records', () => {
+        expect(records.map(record => record.id)).to.have.members(expectedIds);
+      });
 
-        it('returns the latest record content', async () => {
-          expect(latestRecord.content.toString('utf8')).to.equal(PDF_CONTENT);
-        });
+      it('returns Version objects', () => {
+        for (const record of records) {
+          expect(record).to.be.an.instanceof(Version);
+        }
+      });
 
-        it('returns the latest record mime type', () => {
-          expect(latestRecord.mimeType).to.equal(PDF_MIME_TYPE);
-        });
+      it('returns records in ascending order', async () => {
+        expect(records.map(record => record.fetchDate)).to.deep.equal(expectedDates);
       });
     });
 
-    context('when there are no records for the given service', () => {
-      let latestRecord;
+    describe('#count', () => {
+      let count;
 
       before(async () => {
-        latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, DOCUMENT_TYPE);
+        (count = await subject.count());
       });
 
-      it('returns null', async () => {
-        expect(latestRecord).to.equal(null);
+      it('returns the proper count', async () => {
+        expect(count).to.equal(expectedIds.length);
       });
     });
-  });
 
-  describe('#iterate', () => {
-    const expectedIds = [];
-    const ids = [];
-    const fetchDates = [];
-
-    before(async () => {
-      const { id: id1 } = await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        content: CONTENT,
-        fetchDate: FETCH_DATE,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      }));
-
-      expectedIds.push(id1);
-
-      const { id: id2 } = await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        content: `${CONTENT} - updated`,
-        fetchDate: FETCH_DATE_LATER,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      }));
-
-      expectedIds.push(id2);
-
-      const { id: id3 } = await subject.save(new Record({
-        serviceId: SERVICE_PROVIDER_ID,
-        documentType: DOCUMENT_TYPE,
-        content: `${CONTENT} - updated 2`,
-        isRefilter: true,
-        fetchDate: FETCH_DATE_EARLIER,
-        snapshotIds: [SNAPSHOT_ID],
-        mimeType: MIME_TYPE,
-      }));
-
-      expectedIds.push(id3);
-
-      for await (const record of subject.iterate()) {
-        ids.push(record.id);
-        fetchDates.push(record.fetchDate);
-      }
-    });
+    describe('#iterate', () => {
+      const ids = [];
+      const fetchDates = [];
 
-    after(async () => subject.removeAll());
+      before(async () => {
+        for await (const record of subject.iterate()) {
+          ids.push(record.id);
+          fetchDates.push(record.fetchDate);
+        }
+      });
 
-    it('iterates through all records', async () => {
-      expect(ids).to.have.members(expectedIds);
-    });
+      it('iterates through all records', async () => {
+        expect(ids).to.have.members(expectedIds);
+      });
 
-    it('iterates in ascending order', async () => {
-      expect(fetchDates).to.deep.equal([ FETCH_DATE_EARLIER, FETCH_DATE, FETCH_DATE_LATER ]);
+      it('iterates in ascending order', async () => {
+        expect(fetchDates).to.deep.equal(expectedDates);
+      });
     });
   });
 });