Skip to content
Moirova

Engineering

How we test privacy features before they ship

A privacy feature that almost works is worse than none, because people rely on it. Here is how we check that erasing, exporting and restricting a person in Moirova do exactly what the screen says.

By the Moirova teamPublished 7 min read

In short

  • Every place that holds personal data is listed in one register, measured from the code rather than written from memory.
  • Each privacy feature ships with server tests that run it against realistic records, including the awkward cases.
  • A reviewer who did not build the feature reads it fresh, looking for ways it could fail.
  • We plant deliberate bugs to prove the tests would catch them.

Start with a map you can trust

You cannot erase a person from places you do not know about. Moirova keeps a register of every collection that can hold personal data: what it holds, why, how long it is kept and how each privacy right applies to it.

The links between records and people are not written from memory. A tool reads every place in the code that writes data and records which fields tie a record to a person. If someone adds code that stores personal data somewhere the register does not know, a test fails before it can ship.

Test the hard cases, and the normal ones

Each privacy feature comes with server tests that run it against realistic records. The interesting tests are the awkward ones:

  • Two contacts who share an office email address: erasing one must not touch the other.
  • A phone number written three different ways: all of them must be found, and unrelated numbers left alone.
  • An erasure interrupted halfway: it must finish, not start again or stop with half the work done.
  • A restore from a backup after an erasure: the person must not come back.

We also test that the normal path works. A check that refuses everything would pass every "refuse this" test and still be broken, so every guard has a test that ordinary input passes.

A fresh pair of eyes

The person who builds a feature knows how it is meant to work, which is exactly why they miss how it can fail. For every high-stakes privacy feature, a separate reviewer who has not seen the work reads it from scratch, looking for data that could leak, records that could be missed and checks that could be skipped. Their findings are fixed and each fix gets a test of its own.

Plant bugs on purpose

A test suite can pass because the code is right, or because the tests are too weak to notice it is wrong. To tell the difference, we deliberately break the code in small ways - remove a check, swap a condition, skip a step - and run the tests again. Each planted bug must be caught. When one is not, we write the test that was missing.

Check what people see

Finally, an automated browser opens the screens in the dark and light themes, on a desktop and a phone, and checks them: no errors, nothing cut off, the words the guide promises actually on screen. The guides in our Help center describe only what those tests show the product does today.

What the numbers look like

Tests are only as good as what they cover, so here is the size of it today. The server tests for the privacy features - finding a person, exporting their data, correcting and restricting, erasing with approval, team-member requests and retention - run close to seven hundred checks against realistic records. Every release runs every earlier test suite again and compares the results with the release before, so a change in one feature cannot quietly break another.

Planted bugs are counted too. In our most recent release, which keeps the files clients attach to their emails, 14 deliberate bugs were planted - a size limit removed, a type check skipped, a counter left out - and all 14 were caught by the tests before the release went out.

Every guard is tested both ways

A guard is a check that refuses something: an erasure without approval, a file that is not what its name says, a request from another workspace. The easy mistake is to test only that the guard refuses. A guard that refuses everything passes that test and is still broken, because ordinary work stops.

So each guard in Moirova has two kinds of test. One proves it refuses what it should. The other proves that ordinary, correct input passes straight through. Only when both pass do we consider the guard done.

Restores are rehearsed, not assumed

A backup you have never restored is a hope, not a plan. We rehearse restores of a single workspace from a backup, and the rehearsal checks that an erasure made before the restore is applied again, so the person does not come back. A restore that would bring back personal data that was erased is treated as a failed restore.

Reproduce first, then fix

When a customer reports a problem, the first job is to make it happen again, on purpose, in a test. A report describes what someone saw; the cause can be somewhere else entirely. A fix written from the description alone can leave the real fault in place.

So every reported privacy or security problem gets a test that fails because of it, before any code changes. The fix is done when that test passes - and it stays in the suite, so the same problem cannot return unnoticed.

What we do not claim

Testing is not the same as an independent audit. We have not yet been through a formal third-party security audit, and we do not say otherwise. Our Trust center lists where data is kept, which sub-processors handle it and how backups and restores work, and it says plainly which independent audits we have not completed yet. When we complete one, it will be listed there with its date.

Tests that read the reads

Some promises are about what the software does not do. When Moirova links a customer workspace to our own records, for example, it must carry account details only and never read the customer's clients, deals or invoices. A test that checks the result cannot prove that, because a hidden read leaves no trace in the result.

So those tests record every read the code makes against the database while it runs, and fail on any read of a collection it has no business touching. It turns a promise in a policy into something a machine checks on every release.

Small changes, each one checked before it lands

Every change to Moirova ships as one small, reviewable update. Before it writes anything, the update checks that each file it changes is exactly the version it was made for, and stops without changing anything if one is not. It keeps a copy of every file it replaces, and running it twice does nothing the second time. That discipline matters for privacy: a change that half-applies is how a check disappears without anyone noticing.

After each update, the full set of tests runs again on the result and is compared with the run before, so the only differences are the ones the change meant to make. A difference nobody planned is treated as a failure until it is explained.

Questions

Questions and answers

How do you know a privacy feature works?

Each feature ships with server tests that run it against realistic records, including awkward cases such as shared addresses and interrupted erasures. A separate reviewer reads it fresh, and deliberately planted bugs must all be caught by the tests before the feature is released.

What is mutation testing?

It is the practice of planting small, deliberate bugs in the code - removing a check, swapping a condition - and running the tests again. If the tests still pass, they were too weak, and a new test is written. We use it on every privacy and security feature.

Has an outside firm audited your security?

Not yet, and we do not claim otherwise. Our Trust center describes how data is stored, backed up and restored, lists our sub-processors and says plainly which independent audits we have not completed yet.

Can a restore from a backup undo an erasure?

No. Every restore applies the erasure ledger again before the workspace is used, and our restore rehearsals check exactly that. A restore that would bring back erased personal data is treated as a failed restore.

What happens when a customer reports a bug?

We first reproduce it in a test that fails because of it, so we fix the real cause rather than the description. The fix is finished when that test passes, and the test stays in the suite so the problem cannot come back unnoticed.

Do the help guides match what the software really does?

Yes. An automated browser opens each screen in both themes, on a desktop and a phone, and checks that the words and buttons a guide describes are really there. Guides describe only what those checks show the product does today.

Bring Moirova to your team.

Tell us a little about your business. A person on our team reviews every request and replies by email.