@opentermsarchive/engine 0.26.0 → 0.27.0

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

@@ -4,9 +4,11 @@ import { fileURLToPath } from 'url';
 
 import chai from 'chai';
 import config from 'config';
+import mime from 'mime';
 import { MongoClient } from 'mongodb';
 
-import Record from '../../record.js';
+import Snapshot from '../../snapshot.js';
+import Version from '../../version.js';
 
 import MongoRepository from './index.js';
 
@@ -17,705 +19,1122 @@ const { connectionURI } = config.get('recorder.snapshots.storage.mongo');
 const client = new MongoClient(connectionURI);
 
 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 = 'community-standards-hate-speech';
 const CONTENT = 'ToS fixture data with UTF-8 çhãràčtęrs';
-const MIME_TYPE = 'text/html';
+
 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 = '61af86dc5ff5caa74ae926ad';
+const HTML_MIME_TYPE = mime.getType('html');
+
 const PDF_CONTENT = fs.readFileSync(path.resolve(__dirname, '../../../../../test/fixtures/terms.pdf'));
 const UPDATED_PDF_CONTENT = fs.readFileSync(path.resolve(__dirname, '../../../../../test/fixtures/termsModified.pdf'));
-const PDF_MIME_TYPE = 'application/pdf';
+const PDF_MIME_TYPE = mime.getType('pdf');
 
 let collection;
 
 describe('MongoRepository', () => {
   let subject;
 
-  before(async () => {
-    subject = new MongoRepository(config.get('recorder.snapshots.storage.mongo'));
-    await subject.initialize();
-    await client.connect();
-    const db = client.db(config.get('recorder.snapshots.storage.mongo.database'));
+  context('Version', () => {
+    before(async () => {
+      subject = new MongoRepository(config.get('recorder.versions.storage.mongo'));
+      await subject.initialize();
+      await client.connect();
+      const db = client.db(config.get('recorder.versions.storage.mongo.database'));
 
-    collection = db.collection(config.get('recorder.snapshots.storage.mongo.collection'));
-  });
+      collection = db.collection(config.get('recorder.versions.storage.mongo.collection'));
+    });
 
-  describe('#save', () => {
-    let record;
-    let mongoDocument;
-    let numberOfRecordsBefore;
-    let numberOfRecordsAfter;
+    describe('#save', () => {
+      let record;
+      let mongoDocument;
+      let numberOfRecordsBefore;
+      let numberOfRecordsAfter;
 
-    context('when it is the first record', () => {
-      before(async () => {
-        numberOfRecordsBefore = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).count();
+      context('when it is the first record', () => {
+        before(async () => {
+          numberOfRecordsBefore = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
 
-        (record = await subject.save(new Record({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          pageId: PAGE_ID,
-          content: CONTENT,
-          mimeType: MIME_TYPE,
-          fetchDate: FETCH_DATE,
-          snapshotIds: [SNAPSHOT_ID],
-        })));
+          (record = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds: [SNAPSHOT_ID],
+          })));
 
-        numberOfRecordsAfter = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).count();
+          numberOfRecordsAfter = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
 
-        (mongoDocument = await collection.findOne({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }));
-      });
+          (mongoDocument = await collection.findOne({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }));
+        });
 
-      after(async () => subject.removeAll());
+        after(async () => subject.removeAll());
 
-      it('saves the record', () => {
-        expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
-      });
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
 
-      it('returns the record id', () => {
-        expect(mongoDocument._id.toString()).to.equal(record.id);
-      });
+        it('returns the record id', () => {
+          expect(mongoDocument._id.toString()).to.equal(record.id);
+        });
 
-      it('returns a boolean to know if it is the first record', () => {
-        expect(record.isFirstRecord).to.be.true;
-      });
+        it('states that it is the first record', () => {
+          expect(record.isFirstRecord).to.be.true;
+        });
 
-      it('stores the service ID', () => {
-        expect(mongoDocument.serviceId).to.include(SERVICE_PROVIDER_ID);
-      });
+        it('stores the service ID', () => {
+          expect(mongoDocument.serviceId).to.include(SERVICE_PROVIDER_ID);
+        });
 
-      it('stores the terms type', () => {
-        expect(mongoDocument.documentType).to.include(DOCUMENT_TYPE);
-      });
+        it('stores the terms type', () => {
+          expect(mongoDocument.termsType).to.include(TERMS_TYPE);
+        });
 
-      it('stores information that it is the first record for this specific document', () => {
-        expect(mongoDocument.isFirstRecord).to.be.true;
-      });
+        it('stores information that it is the first record for these specific terms', () => {
+          expect(mongoDocument.isFirstRecord).to.be.true;
+        });
 
-      it('stores the proper content', () => {
-        expect(mongoDocument.content).to.equal(CONTENT);
-      });
+        it('stores the proper content', () => {
+          expect(mongoDocument.content).to.equal(CONTENT);
+        });
 
-      context('when provided', () => {
         it('stores the fetch date', () => {
           expect(new Date(mongoDocument.fetchDate).getTime()).to.equal(FETCH_DATE.getTime());
         });
 
-        it('stores the MIME type', () => {
-          expect(mongoDocument.mimeType).to.equal(MIME_TYPE);
-        });
-
         it('stores the snapshot ID', () => {
           expect(mongoDocument.snapshotIds.map(snapshotId => snapshotId.toString())).to.deep.equal([SNAPSHOT_ID]);
         });
+      });
+
+      context('when it is not the first record', () => {
+        const UPDATED_CONTENT = `${CONTENT} updated`;
 
-        it('stores the page ID', () => {
-          expect(mongoDocument.pageId).to.equal(PAGE_ID);
+        before(async () => {
+          (record = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds: [SNAPSHOT_ID],
+          })));
+
+          numberOfRecordsBefore = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
+
+          (record = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: UPDATED_CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds: [SNAPSHOT_ID],
+          })));
+
+          numberOfRecordsAfter = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
+
+          ([mongoDocument] = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).limit(1).sort({ created_at: -1 }).toArray());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(mongoDocument._id.toString()).to.equal(record.id);
+        });
+
+        it('states that it is not the first record', () => {
+          expect(record.isFirstRecord).to.be.false;
         });
       });
-    });
 
-    context('when it is not the first record', () => {
-      const UPDATED_CONTENT = `${CONTENT} updated`;
+      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,
+            snapshotIds: [SNAPSHOT_ID],
+          }));
 
-      before(async () => {
-        (record = await subject.save(new Record({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: CONTENT,
-          mimeType: MIME_TYPE,
-          fetchDate: FETCH_DATE,
-          snapshotIds: [SNAPSHOT_ID],
-        })));
+          numberOfRecordsBefore = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
 
-        numberOfRecordsBefore = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).count();
+          (record = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE_LATER,
+            snapshotIds: [SNAPSHOT_ID],
+          })));
 
-        (record = await subject.save(new Record({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: UPDATED_CONTENT,
-          mimeType: MIME_TYPE,
-          fetchDate: FETCH_DATE,
-          snapshotIds: [SNAPSHOT_ID],
-        })));
+          numberOfRecordsAfter = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
+        });
 
-        numberOfRecordsAfter = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).count();
+        after(async () => subject.removeAll());
 
-        ([mongoDocument] = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).limit(1).sort({ created_at: -1 }).toArray());
+        it('does not save the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore);
+        });
+
+        it('returns no id', () => {
+          expect(record.id).to.equal(undefined);
+        });
       });
 
-      after(async () => subject.removeAll());
+      context('when it is an extracted only version', () => {
+        const EXTRACTED_ONLY_CONTENT = `${CONTENT} extracted only`;
 
-      it('saves the record', () => {
-        expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
-      });
+        before(async () => {
+          await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE_EARLIER,
+            snapshotIds: [SNAPSHOT_ID],
+          })); // An extracted only version cannot be the first record
 
-      it('returns the record id', () => {
-        expect(mongoDocument._id.toString()).to.equal(record.id);
-      });
+          numberOfRecordsBefore = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
 
-      it('returns a boolean to know if it is the first record', () => {
-        expect(record.isFirstRecord).to.be.false;
-      });
-    });
+          (record = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: EXTRACTED_ONLY_CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds: [SNAPSHOT_ID],
+            isExtractOnly: true,
+          })));
 
-    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,
-        }));
+          numberOfRecordsAfter = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
 
-        numberOfRecordsBefore = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).count();
+          ([mongoDocument] = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).limit(1).sort({ created_at: -1 }).toArray());
+        });
 
-        (record = await subject.save(new Record({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: CONTENT,
-          mimeType: MIME_TYPE,
-          fetchDate: FETCH_DATE_LATER,
-        })));
+        after(async () => subject.removeAll());
 
-        numberOfRecordsAfter = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).count();
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(mongoDocument._id.toString()).to.equal(record.id);
+        });
+
+        it('stores information that it is an extracted only version', () => {
+          expect(mongoDocument.isExtractOnly).to.be.true;
+        });
       });
 
-      after(async () => subject.removeAll());
+      context('when one snapshot ID is specified', () => {
+        before(async () => {
+          (record = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds: [SNAPSHOT_ID],
+          })));
+
+          (mongoDocument = await collection.findOne({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }));
+        });
+
+        after(async () => subject.removeAll());
+
+        it('stores snapshot ID', () => {
+          const snapshotIds = mongoDocument.snapshotIds.map(id => id.toString());
+
+          expect(snapshotIds).to.include(SNAPSHOT_ID);
+        });
 
-      it('does not save the record', () => {
-        expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore);
+        it('stores the service ID', () => {
+          expect(mongoDocument.serviceId).to.include(SERVICE_PROVIDER_ID);
+        });
+
+        it('stores the terms type', () => {
+          expect(mongoDocument.termsType).to.include(TERMS_TYPE);
+        });
       });
 
-      it('returns no id', () => {
-        expect(record.id).to.equal(undefined);
+      context('when there are many snapshots IDs specified', () => {
+        const SNAPSHOT_ID_1 = '61af86dc5ff5caa74ae926ad';
+        const SNAPSHOT_ID_2 = '630cdfa67d2e3cc51f6e284c';
+
+        before(async () => {
+          (record = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds: [ SNAPSHOT_ID_1, SNAPSHOT_ID_2 ],
+          })));
+
+          (mongoDocument = await collection.findOne({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }));
+        });
+
+        after(async () => subject.removeAll());
+
+        it('stores snapshots IDs', () => {
+          const snapshotIds = mongoDocument.snapshotIds.map(id => id.toString());
+
+          expect(snapshotIds).to.include(SNAPSHOT_ID_1);
+          expect(snapshotIds).to.include(SNAPSHOT_ID_2);
+        });
+
+        it('stores the service ID', () => {
+          expect(mongoDocument.serviceId).to.include(SERVICE_PROVIDER_ID);
+        });
+
+        it('stores the terms type', () => {
+          expect(mongoDocument.termsType).to.include(TERMS_TYPE);
+        });
       });
     });
 
-    context('when it is a refilter', () => {
-      const REFILTERED_CONTENT = `${CONTENT} refiltered`;
+    describe('#findById', () => {
+      let record;
+      let id;
 
       before(async () => {
-        await subject.save(new Record({
+        ({ id } = 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
-
-        numberOfRecordsBefore = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).count();
-
-        (record = await subject.save(new Record({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: REFILTERED_CONTENT,
-          mimeType: MIME_TYPE,
           fetchDate: FETCH_DATE,
           snapshotIds: [SNAPSHOT_ID],
-          isRefilter: true,
         })));
 
-        numberOfRecordsAfter = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).count();
-
-        ([mongoDocument] = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).limit(1).sort({ created_at: -1 }).toArray());
+        (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(mongoDocument._id.toString()).to.equal(record.id);
+        expect(record.id).to.include(id);
+      });
+
+      it('states that it is the first record', () => {
+        expect(record.isFirstRecord).to.be.true;
+      });
+
+      it('returns the service ID', () => {
+        expect(record.serviceId).to.equal(SERVICE_PROVIDER_ID);
+      });
+
+      it('returns the terms type', () => {
+        expect(record.termsType).to.equal(TERMS_TYPE);
+      });
+
+      it('returns the content', async () => {
+        expect(record.content).to.equal(CONTENT);
+      });
+
+      it('returns the fetch date', () => {
+        expect(new Date(record.fetchDate).getTime()).to.equal(FETCH_DATE.getTime());
       });
 
-      it('stores information that it is a refilter of this specific document', () => {
-        expect(mongoDocument.isRefilter).to.be.true;
+      it('returns the snapshot ID', () => {
+        expect(record.snapshotIds).to.deep.equal([SNAPSHOT_ID]);
+      });
+
+      context('when requested record does not exist', () => {
+        it('returns null', async () => {
+          expect(await subject.findById('inexistantID')).to.equal(null);
+        });
       });
     });
 
-    context('with PDF document', () => {
-      before(async () => {
-        numberOfRecordsBefore = await collection.find({
-          serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: PDF_CONTENT,
-          mimeType: PDF_MIME_TYPE,
-        }).count();
+    describe('#findAll', () => {
+      let records;
+      const expectedIds = [];
 
-        (record = await subject.save(new Record({
+      before(async () => {
+        const { id: id1 } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          content: PDF_CONTENT,
-          mimeType: PDF_MIME_TYPE,
+          termsType: TERMS_TYPE,
+          content: CONTENT,
           fetchDate: FETCH_DATE,
           snapshotIds: [SNAPSHOT_ID],
-        })));
+        }));
+
+        expectedIds.push(id1);
 
-        numberOfRecordsAfter = await collection.find({
+        const { id: id2 } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-        }).count();
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated`,
+          fetchDate: FETCH_DATE_LATER,
+          snapshotIds: [SNAPSHOT_ID],
+        }));
 
-        (mongoDocument = await collection.findOne({
+        expectedIds.push(id2);
+
+        const { id: id3 } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated 2`,
+          isExtractOnly: true,
+          fetchDate: FETCH_DATE_EARLIER,
+          snapshotIds: [SNAPSHOT_ID],
         }));
-      });
 
-      after(async () => subject.removeAll());
+        expectedIds.push(id3);
 
-      it('saves the record', () => {
-        expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        (records = await subject.findAll());
       });
 
-      it('returns the record id', () => {
-        expect(mongoDocument._id.toString()).to.equal(record.id);
-      });
+      after(async () => subject.removeAll());
 
-      it('stores the proper content', async () => {
-        const isSameContent = Buffer.compare(mongoDocument.content.buffer, PDF_CONTENT) == 0;
+      it('returns all records', () => {
+        expect(records.length).to.equal(3);
+      });
 
-        expect(isSameContent).to.be.true;
+      it('returns Version objects', () => {
+        for (const record of records) {
+          expect(record).to.be.an.instanceof(Version);
+        }
       });
 
-      it('stores the MIME type', () => {
-        expect(mongoDocument.mimeType).to.equal(PDF_MIME_TYPE);
+      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 there is no snapshots IDs specified', () => {
+    describe('#count', () => {
+      let count;
+
       before(async () => {
-        (record = await subject.save(new Record({
+        await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          pageId: PAGE_ID,
+          termsType: TERMS_TYPE,
           content: CONTENT,
-          mimeType: MIME_TYPE,
           fetchDate: FETCH_DATE,
-        })));
-
-        (mongoDocument = await collection.findOne({
+          snapshotIds: [SNAPSHOT_ID],
+        }));
+        await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
+          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],
+        }));
+
+        (count = await subject.count());
       });
 
       after(async () => subject.removeAll());
 
-      it('does not store snapshots IDs', () => {
-        expect(mongoDocument.snapshotIds).to.be.undefined;
+      it('returns the proper count', async () => {
+        expect(count).to.equal(3);
       });
+    });
 
-      it('stores the service ID', () => {
-        expect(mongoDocument.serviceId).to.include(SERVICE_PROVIDER_ID);
+    describe('#findLatest', () => {
+      context('when there are records for the given service', () => {
+        let lastSnapshotId;
+        let latestRecord;
+
+        context('with HTML document', () => {
+          const UPDATED_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,
+              snapshotIds: [SNAPSHOT_ID],
+            }));
+
+            ({ id: lastSnapshotId } = await subject.save(new Version({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              content: UPDATED_CONTENT,
+              fetchDate: FETCH_DATE_LATER,
+              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((await latestRecord.content).toString('utf8')).to.equal(UPDATED_CONTENT);
+          });
+        });
       });
 
-      it('stores the terms type', () => {
-        expect(mongoDocument.documentType).to.include(DOCUMENT_TYPE);
-      });
+      context('when there are no records for the given service', () => {
+        let latestRecord;
+
+        before(async () => {
+          latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, TERMS_TYPE);
+        });
 
-      it('stores the page ID', () => {
-        expect(mongoDocument.pageId).to.include(PAGE_ID);
+        it('returns null', async () => {
+          expect(latestRecord).to.equal(null);
+        });
       });
     });
 
-    context('when there are many snapshots IDs specified', () => {
-      const SNAPSHOT_ID_1 = '61af86dc5ff5caa74ae926ad';
-      const SNAPSHOT_ID_2 = '630cdfa67d2e3cc51f6e284c';
+    describe('#iterate', () => {
+      const expectedIds = [];
+      const ids = [];
+      const fetchDates = [];
 
       before(async () => {
-        (record = await subject.save(new Record({
+        const { id: id1 } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
-          pageId: PAGE_ID,
+          termsType: TERMS_TYPE,
           content: CONTENT,
-          mimeType: MIME_TYPE,
           fetchDate: FETCH_DATE,
-          snapshotIds: [ SNAPSHOT_ID_1, SNAPSHOT_ID_2 ],
-        })));
+          snapshotIds: [SNAPSHOT_ID],
+        }));
+
+        expectedIds.push(id1);
 
-        (mongoDocument = await collection.findOne({
+        const { id: id2 } = await subject.save(new Version({
           serviceId: SERVICE_PROVIDER_ID,
-          documentType: DOCUMENT_TYPE,
+          termsType: TERMS_TYPE,
+          content: `${CONTENT} - updated`,
+          fetchDate: FETCH_DATE_LATER,
+          snapshotIds: [SNAPSHOT_ID],
         }));
-      });
 
-      after(async () => subject.removeAll());
+        expectedIds.push(id2);
+
+        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],
+        }));
 
-      it('stores snapshots IDs', () => {
-        const snapshotIds = mongoDocument.snapshotIds.map(id => id.toString());
+        expectedIds.push(id3);
 
-        expect(snapshotIds).to.include(SNAPSHOT_ID_1);
-        expect(snapshotIds).to.include(SNAPSHOT_ID_2);
+        for await (const record of subject.iterate()) {
+          ids.push(record.id);
+          fetchDates.push(record.fetchDate);
+        }
       });
 
-      it('stores the service ID', () => {
-        expect(mongoDocument.serviceId).to.include(SERVICE_PROVIDER_ID);
-      });
+      after(async () => subject.removeAll());
 
-      it('stores the terms type', () => {
-        expect(mongoDocument.documentType).to.include(DOCUMENT_TYPE);
+      it('iterates through all records', async () => {
+        expect(ids).to.have.members(expectedIds);
       });
 
-      it('stores the page ID', () => {
-        expect(mongoDocument.pageId).to.include(PAGE_ID);
+      it('iterates in ascending order', async () => {
+        expect(fetchDates).to.deep.equal([ FETCH_DATE_EARLIER, FETCH_DATE, FETCH_DATE_LATER ]);
       });
     });
   });
 
-  describe('#findById', () => {
-    let record;
-    let id;
-
+  context('Snapshot', () => {
     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));
+      subject = new MongoRepository(config.get('recorder.snapshots.storage.mongo'));
+      await subject.initialize();
+      await client.connect();
+      const db = client.db(config.get('recorder.snapshots.storage.mongo.database'));
+
+      collection = db.collection(config.get('recorder.snapshots.storage.mongo.collection'));
     });
 
-    after(async () => subject.removeAll());
+    describe('#save', () => {
+      let record;
+      let mongoDocument;
+      let numberOfRecordsBefore;
+      let numberOfRecordsAfter;
 
-    it('returns the record id', () => {
-      expect(record.id).to.include(id);
-    });
+      context('when it is the first record', () => {
+        before(async () => {
+          numberOfRecordsBefore = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
 
-    it('returns a boolean to know if it is the first record', () => {
-      expect(record.isFirstRecord).to.be.true;
-    });
+          (record = await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            documentId: DOCUMENT_ID,
+            content: CONTENT,
+            mimeType: HTML_MIME_TYPE,
+            fetchDate: FETCH_DATE,
+          })));
 
-    it('returns the service ID', () => {
-      expect(record.serviceId).to.equal(SERVICE_PROVIDER_ID);
-    });
+          numberOfRecordsAfter = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
 
-    it('returns the terms type', () => {
-      expect(record.documentType).to.equal(DOCUMENT_TYPE);
-    });
+          (mongoDocument = await collection.findOne({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }));
+        });
 
-    it('returns the content', async () => {
-      expect(record.content).to.equal(CONTENT);
-    });
+        after(async () => subject.removeAll());
 
-    it('returns the fetch date', () => {
-      expect(new Date(record.fetchDate).getTime()).to.equal(FETCH_DATE.getTime());
-    });
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
 
-    it('returns the MIME type', () => {
-      expect(record.mimeType).to.equal(MIME_TYPE);
-    });
+        it('returns the record id', () => {
+          expect(mongoDocument._id.toString()).to.equal(record.id);
+        });
 
-    it('returns the snapshot ID', () => {
-      expect(record.snapshotIds).to.deep.equal([SNAPSHOT_ID]);
-    });
+        it('states that it is the first record', () => {
+          expect(record.isFirstRecord).to.be.true;
+        });
 
-    it('returns the page ID', () => {
-      expect(record.pageId).to.equal(PAGE_ID);
-    });
+        it('stores the service ID', () => {
+          expect(mongoDocument.serviceId).to.include(SERVICE_PROVIDER_ID);
+        });
 
-    context('when requested record does not exist', () => {
-      it('returns null', async () => {
-        expect(await subject.findById('inexistantID')).to.equal(null);
-      });
-    });
-  });
+        it('stores the terms type', () => {
+          expect(mongoDocument.termsType).to.include(TERMS_TYPE);
+        });
 
-  describe('#findAll', () => {
-    let records;
-    const expectedIds = [];
+        it('stores information that it is the first record for these specific terms', () => {
+          expect(mongoDocument.isFirstRecord).to.be.true;
+        });
 
-    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);
-
-      (records = await subject.findAll());
-    });
+        it('stores the proper content', () => {
+          expect(mongoDocument.content).to.equal(CONTENT);
+        });
 
-    after(async () => subject.removeAll());
+        it('stores the fetch date', () => {
+          expect(new Date(mongoDocument.fetchDate).getTime()).to.equal(FETCH_DATE.getTime());
+        });
 
-    it('returns all records', () => {
-      expect(records.length).to.equal(3);
-    });
+        it('stores the MIME type', () => {
+          expect(mongoDocument.mimeType).to.equal(HTML_MIME_TYPE);
+        });
 
-    it('returns Record objects', () => {
-      for (const record of records) {
-        expect(record).to.be.an.instanceof(Record);
-      }
-    });
+        it('stores the document ID', () => {
+          expect(mongoDocument.documentId).to.equal(DOCUMENT_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 ]);
-    });
-  });
+      context('when it is not the first record', () => {
+        const UPDATED_CONTENT = `${CONTENT} updated`;
 
-  describe('#count', () => {
-    let count;
+        before(async () => {
+          (record = await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            mimeType: HTML_MIME_TYPE,
+            fetchDate: FETCH_DATE,
+          })));
 
-    before(async () => {
-      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());
-    });
+          numberOfRecordsBefore = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
 
-    after(async () => subject.removeAll());
+          (record = await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: UPDATED_CONTENT,
+            mimeType: HTML_MIME_TYPE,
+            fetchDate: FETCH_DATE,
+          })));
 
-    it('returns the proper count', async () => {
-      expect(count).to.equal(3);
-    });
-  });
+          numberOfRecordsAfter = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
 
-  describe('#findLatest', () => {
-    context('when there are records for the given service', () => {
-      let lastSnapshotId;
-      let latestRecord;
+          ([mongoDocument] = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).limit(1).sort({ created_at: -1 }).toArray());
+        });
+
+        after(async () => subject.removeAll());
+
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(mongoDocument._id.toString()).to.equal(record.id);
+        });
 
-      context('with HTML document', () => {
-        const UPDATED_CONTENT = `${CONTENT} (with additional content to trigger a record)`;
+        it('states that it is not the first record', () => {
+          expect(record.isFirstRecord).to.be.false;
+        });
+      });
 
+      context('when the content has not changed', () => {
         before(async () => {
-          await subject.save(new Record({
+          await subject.save(new Snapshot({
             serviceId: SERVICE_PROVIDER_ID,
-            documentType: DOCUMENT_TYPE,
+            termsType: TERMS_TYPE,
             content: CONTENT,
+            mimeType: HTML_MIME_TYPE,
             fetchDate: FETCH_DATE,
-            mimeType: MIME_TYPE,
           }));
 
-          ({ id: lastSnapshotId } = await subject.save(new Record({
+          numberOfRecordsBefore = await collection.find({
             serviceId: SERVICE_PROVIDER_ID,
-            documentType: DOCUMENT_TYPE,
-            content: UPDATED_CONTENT,
-            mimeType: MIME_TYPE,
+            termsType: TERMS_TYPE,
+          }).count();
+
+          (record = await subject.save(new Snapshot({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            content: CONTENT,
+            mimeType: HTML_MIME_TYPE,
             fetchDate: FETCH_DATE_LATER,
           })));
 
-          latestRecord = await subject.findLatest(
-            SERVICE_PROVIDER_ID,
-            DOCUMENT_TYPE,
-          );
+          numberOfRecordsAfter = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
         });
 
         after(async () => subject.removeAll());
 
-        it('returns the latest record id', () => {
-          expect(latestRecord.id).to.include(lastSnapshotId);
-        });
-
-        it('returns the latest record content', async () => {
-          expect((await latestRecord.content).toString('utf8')).to.equal(UPDATED_CONTENT);
+        it('does not save the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore);
         });
 
-        it('returns the latest record mime type', () => {
-          expect(latestRecord.mimeType).to.equal(MIME_TYPE);
+        it('returns no id', () => {
+          expect(record.id).to.equal(undefined);
         });
       });
 
       context('with PDF document', () => {
         before(async () => {
-          await subject.save(new Record({
+          numberOfRecordsBefore = await collection.find({
             serviceId: SERVICE_PROVIDER_ID,
-            documentType: DOCUMENT_TYPE,
+            termsType: TERMS_TYPE,
             content: PDF_CONTENT,
             mimeType: PDF_MIME_TYPE,
-            fetchDate: FETCH_DATE,
-          }));
+          }).count();
 
-          ({ id: lastSnapshotId } = await subject.save(new Record({
+          (record = await subject.save(new Snapshot({
             serviceId: SERVICE_PROVIDER_ID,
-            documentType: DOCUMENT_TYPE,
-            content: UPDATED_PDF_CONTENT,
+            termsType: TERMS_TYPE,
+            content: PDF_CONTENT,
             mimeType: PDF_MIME_TYPE,
-            fetchDate: FETCH_DATE_LATER,
+            fetchDate: FETCH_DATE,
           })));
 
-          latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, DOCUMENT_TYPE);
+          numberOfRecordsAfter = await collection.find({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }).count();
+
+          (mongoDocument = await collection.findOne({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }));
         });
 
         after(async () => subject.removeAll());
 
-        it('returns the latest record id', () => {
-          expect(latestRecord.id).to.include(lastSnapshotId);
+        it('saves the record', () => {
+          expect(numberOfRecordsAfter).to.equal(numberOfRecordsBefore + 1);
+        });
+
+        it('returns the record id', () => {
+          expect(mongoDocument._id.toString()).to.equal(record.id);
         });
 
-        it('returns the latest record content', async () => {
-          const isSameContent = Buffer.compare(latestRecord.content, UPDATED_PDF_CONTENT) == 0;
+        it('stores the proper content', async () => {
+          const isSameContent = Buffer.compare(mongoDocument.content.buffer, PDF_CONTENT) == 0;
 
           expect(isSameContent).to.be.true;
         });
 
-        it('returns the latest record mime type', () => {
-          expect(latestRecord.mimeType).to.equal(PDF_MIME_TYPE);
+        it('stores the MIME type', () => {
+          expect(mongoDocument.mimeType).to.equal(PDF_MIME_TYPE);
         });
       });
     });
 
-    context('when there are no records for the given service', () => {
-      let latestRecord;
+    describe('#findById', () => {
+      let record;
+      let id;
 
       before(async () => {
-        latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, DOCUMENT_TYPE);
+        ({ id } = await subject.save(new Snapshot({
+          serviceId: SERVICE_PROVIDER_ID,
+          termsType: TERMS_TYPE,
+          documentId: DOCUMENT_ID,
+          content: CONTENT,
+          fetchDate: FETCH_DATE,
+          mimeType: HTML_MIME_TYPE,
+        })));
+
+        (record = await subject.findById(id));
+      });
+
+      after(async () => subject.removeAll());
+
+      it('returns a Snapshot object', () => {
+        expect(record).to.be.an.instanceof(Snapshot);
+      });
+
+      it('returns the record id', () => {
+        expect(record.id).to.include(id);
+      });
+
+      it('states that it is the first record', () => {
+        expect(record.isFirstRecord).to.be.true;
+      });
+
+      it('returns the service ID', () => {
+        expect(record.serviceId).to.equal(SERVICE_PROVIDER_ID);
+      });
+
+      it('returns the terms type', () => {
+        expect(record.termsType).to.equal(TERMS_TYPE);
+      });
+
+      it('returns the content', async () => {
+        expect(record.content).to.equal(CONTENT);
+      });
+
+      it('returns the fetch date', () => {
+        expect(new Date(record.fetchDate).getTime()).to.equal(FETCH_DATE.getTime());
+      });
+
+      it('returns the MIME type', () => {
+        expect(record.mimeType).to.equal(HTML_MIME_TYPE);
+      });
+
+      it('returns the document ID', () => {
+        expect(record.documentId).to.equal(DOCUMENT_ID);
       });
 
-      it('returns null', async () => {
-        expect(latestRecord).to.equal(null);
+      context('when requested record does not exist', () => {
+        it('returns null', async () => {
+          expect(await subject.findById('inexistantID')).to.equal(null);
+        });
       });
     });
-  });
 
-  describe('#iterate', () => {
-    const expectedIds = [];
-    const ids = [];
-    const fetchDates = [];
+    describe('#findAll', () => {
+      let records;
+      const expectedIds = [];
 
-    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);
-      }
+      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,
+        }));
+
+        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);
+
+        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('returns all records', () => {
+        expect(records.length).to.equal(3);
+      });
+
+      it('returns Snapshot objects', () => {
+        for (const record of records) {
+          expect(record).to.be.an.instanceof(Snapshot);
+        }
+      });
+
+      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 () => {
+        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());
+      });
+
+      after(async () => subject.removeAll());
+
+      it('returns the proper count', async () => {
+        expect(count).to.equal(3);
+      });
     });
 
-    after(async () => subject.removeAll());
+    describe('#findLatest', () => {
+      context('when there are records for the given service', () => {
+        let lastSnapshotId;
+        let latestRecord;
+
+        context('with HTML document', () => {
+          const UPDATED_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,
+              fetchDate: FETCH_DATE,
+              mimeType: HTML_MIME_TYPE,
+            }));
+
+            ({ id: lastSnapshotId } = await subject.save(new Snapshot({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              content: UPDATED_CONTENT,
+              mimeType: HTML_MIME_TYPE,
+              fetchDate: FETCH_DATE_LATER,
+            })));
+
+            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((await latestRecord.content).toString('utf8')).to.equal(UPDATED_CONTENT);
+          });
+
+          it('returns the latest record mime type', () => {
+            expect(latestRecord.mimeType).to.equal(HTML_MIME_TYPE);
+          });
+        });
+
+        context('with PDF document', () => {
+          before(async () => {
+            await subject.save(new Snapshot({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              content: PDF_CONTENT,
+              mimeType: PDF_MIME_TYPE,
+              fetchDate: FETCH_DATE,
+            }));
+
+            ({ id: lastSnapshotId } = await subject.save(new Snapshot({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              content: UPDATED_PDF_CONTENT,
+              mimeType: PDF_MIME_TYPE,
+              fetchDate: FETCH_DATE_LATER,
+            })));
+
+            latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, TERMS_TYPE);
+          });
+
+          after(async () => subject.removeAll());
+
+          it('returns the latest record id', () => {
+            expect(latestRecord.id).to.include(lastSnapshotId);
+          });
+
+          it('returns the latest record content', async () => {
+            const isSameContent = Buffer.compare(latestRecord.content, UPDATED_PDF_CONTENT) == 0;
+
+            expect(isSameContent).to.be.true;
+          });
+
+          it('returns the latest record mime type', () => {
+            expect(latestRecord.mimeType).to.equal(PDF_MIME_TYPE);
+          });
+        });
+      });
+
+      context('when there are no records for the given service', () => {
+        let latestRecord;
+
+        before(async () => {
+          latestRecord = await subject.findLatest(SERVICE_PROVIDER_ID, TERMS_TYPE);
+        });
 
-    it('iterates through all records', async () => {
-      expect(ids).to.have.members(expectedIds);
+        it('returns null', async () => {
+          expect(latestRecord).to.equal(null);
+        });
+      });
     });
 
-    it('iterates in ascending order', async () => {
-      expect(fetchDates).to.deep.equal([ FETCH_DATE_EARLIER, FETCH_DATE, FETCH_DATE_LATER ]);
+    describe('#iterate', () => {
+      const expectedIds = [];
+      const ids = [];
+      const fetchDates = [];
+
+      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,
+        }));
+
+        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);
+
+        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);
+
+        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('iterates in ascending order', async () => {
+        expect(fetchDates).to.deep.equal([ FETCH_DATE_EARLIER, FETCH_DATE, FETCH_DATE_LATER ]);
+      });
     });
   });
 });