diff --git a/ghost/limit-service/test/limit.test.js b/ghost/limit-service/test/limit.test.js
index fc57babddd..e15a611f5c 100644
--- a/ghost/limit-service/test/limit.test.js
+++ b/ghost/limit-service/test/limit.test.js
@@ -6,94 +6,98 @@ const {MaxLimit} = require('../lib/limit');
 
 describe('Limit Service', function () {
     describe('Max Limit', function () {
-        it('throws if initialized without a max limit', function () {
-            const config = {};
+        describe('Constructor', function () {
+            it('throws if initialized without a max limit', function () {
+                const config = {};
 
-            try {
-                const limit = new MaxLimit({name: 'no limits!', config});
-                should.fail(limit, 'Should have errored');
-            } catch (err) {
-                should.exist(err);
-                should.exist(err.errorType);
-                should.equal(err.errorType, 'IncorrectUsageError');
-            }
+                try {
+                    const limit = new MaxLimit({name: 'no limits!', config});
+                    should.fail(limit, 'Should have errored');
+                } catch (err) {
+                    should.exist(err);
+                    should.exist(err.errorType);
+                    should.equal(err.errorType, 'IncorrectUsageError');
+                }
+            });
+
+            it('throws if initialized without a current count query', function () {
+                const config = {};
+
+                try {
+                    const limit = new MaxLimit({name: 'no accountability!', config});
+                    should.fail(limit, 'Should have errored');
+                } catch (err) {
+                    should.exist(err);
+                    should.exist(err.errorType);
+                    should.equal(err.errorType, 'IncorrectUsageError');
+                }
+            });
         });
 
-        it('throws if initialized without a current count query', function () {
-            const config = {};
+        describe('Would go over limit', function () {
+            it('throws if would go over the limit', async function () {
+                const config = {
+                    max: 1,
+                    currentCountQuery: () => 1
+                };
+                const limit = new MaxLimit({name: 'maxy', config});
 
-            try {
-                const limit = new MaxLimit({name: 'no accountability!', config});
-                should.fail(limit, 'Should have errored');
-            } catch (err) {
-                should.exist(err);
-                should.exist(err.errorType);
-                should.equal(err.errorType, 'IncorrectUsageError');
-            }
-        });
+                try {
+                    await limit.errorIfWouldGoOverLimit();
+                    should.fail(limit, 'Should have errored');
+                } catch (err) {
+                    should.exist(err);
 
-        it('throws if would go over the limit', async function () {
-            const config = {
-                max: 1,
-                currentCountQuery: () => 1
-            };
-            const limit = new MaxLimit({name: 'maxy', config});
+                    should.exist(err.errorType);
+                    should.equal(err.errorType, 'HostLimitError');
+
+                    should.exist(err.errorDetails);
+                    should.equal(err.errorDetails.name, 'maxy');
+
+                    should.exist(err.message);
+                    should.equal(err.message, 'This action would exceed the maxy limit on your current plan.');
+                }
+            });
+
+            it('passes if does not go over the limit', async function () {
+                const config = {
+                    max: 2,
+                    currentCountQuery: () => 1
+                };
+
+                const limit = new MaxLimit({name: 'maxy', config});
 
-            try {
                 await limit.errorIfWouldGoOverLimit();
-                should.fail(limit, 'Should have errored');
-            } catch (err) {
-                should.exist(err);
+            });
 
-                should.exist(err.errorType);
-                should.equal(err.errorType, 'HostLimitError');
+            it('ignores default configured max limit when it is passed explicitly', async function () {
+                const config = {
+                    max: 10,
+                    currentCountQuery: () => 10
+                };
 
-                should.exist(err.errorDetails);
-                should.equal(err.errorDetails.name, 'maxy');
+                const limit = new MaxLimit({name: 'maxy', config});
 
-                should.exist(err.message);
-                should.equal(err.message, 'This action would exceed the maxy limit on your current plan.');
-            }
-        });
+                // should pass as the limit is overridden to 10 + 1 = 11
+                await limit.errorIfWouldGoOverLimit({max: 11});
 
-        it('passes if does not go over the limit', async function () {
-            const config = {
-                max: 2,
-                currentCountQuery: () => 1
-            };
+                try {
+                    // should fail because limit is overridden to 10 + 1 < 1
+                    await limit.errorIfWouldGoOverLimit({max: 1});
+                    should.fail(limit, 'Should have errored');
+                } catch (err) {
+                    should.exist(err);
 
-            const limit = new MaxLimit({name: 'maxy', config});
+                    should.exist(err.errorType);
+                    should.equal(err.errorType, 'HostLimitError');
 
-            await limit.errorIfWouldGoOverLimit();
-        });
+                    should.exist(err.errorDetails);
+                    should.equal(err.errorDetails.name, 'maxy');
 
-        it('ignores default configured max limit when it is passed explicitly', async function () {
-            const config = {
-                max: 10,
-                currentCountQuery: () => 10
-            };
-
-            const limit = new MaxLimit({name: 'maxy', config});
-
-            // should pass as the limit is overridden to 10 + 1 = 11
-            await limit.errorIfWouldGoOverLimit({max: 11});
-
-            try {
-                // should fail because limit is overridden to 10 + 1 < 1
-                await limit.errorIfWouldGoOverLimit({max: 1});
-                should.fail(limit, 'Should have errored');
-            } catch (err) {
-                should.exist(err);
-
-                should.exist(err.errorType);
-                should.equal(err.errorType, 'HostLimitError');
-
-                should.exist(err.errorDetails);
-                should.equal(err.errorDetails.name, 'maxy');
-
-                should.exist(err.message);
-                should.equal(err.message, 'This action would exceed the maxy limit on your current plan.');
-            }
+                    should.exist(err.message);
+                    should.equal(err.message, 'This action would exceed the maxy limit on your current plan.');
+                }
+            });
         });
     });
 });