@platformos/platformos-check-common 0.0.2

package/src/checks/valid-block-target/index.spec.ts

@@ -0,0 +1,1396 @@
+import { expect, describe, it } from 'vitest';
+import { ValidBlockTarget } from './index';
+import { check, MockTheme } from '../../test';
+import { Preset, Setting } from '../../types/schemas';
+
+describe('Module: ValidBlockTarget', () => {
+  const paths = ['sections', 'blocks'];
+
+  describe('File Existence Tests', () => {
+    paths.forEach((path) => {
+      it(`should ignore @app and @theme block types in ${path} bucket`, async () => {
+        const theme: MockTheme = {
+          [`${path}/app-theme.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "@app"
+                },
+                {
+                  "type": "@theme"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.be.empty;
+      });
+
+      it(`should not report any errors when all block files exist (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/text.liquid': '',
+          [`${path}/valid.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "text"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.be.empty;
+      });
+
+      it(`should report errors when root level block file does not exist (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          [`${path}/invalid-section.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "invalid"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses[0].message).to.equal("Theme block 'blocks/invalid.liquid' does not exist.");
+      });
+
+      it(`should report an error when a preset defined block file does not exist (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          [`${path}/invalid-block.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "@theme"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "missing_block"
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses[0].message).to.equal(
+          "Theme block 'blocks/missing_block.liquid' does not exist.",
+        );
+      });
+
+      if (path === 'sections') {
+        it(`should report an error when default defined block file does not exist`, async () => {
+          const theme: MockTheme = {
+            [`${path}/invalid-file.liquid`]: `
+              {% schema %}
+              {
+                "name": "Section name",
+                "blocks": [
+                  {
+                    "type": "@theme"
+                  }
+                ],
+                "default": {
+                  "title": "Default",
+                  "blocks": [
+                    {
+                      "name": "some block",
+                      "type": "missing_block"
+                    }
+                  ]
+                }
+              }
+              {% endschema %}
+            `,
+          };
+
+          const offenses = await check(theme, [ValidBlockTarget]);
+          expect(offenses).to.have.length(1);
+          expect(offenses).to.containOffense(
+            "Theme block 'blocks/missing_block.liquid' does not exist.",
+          );
+        });
+      }
+
+      it(`should not report subsequent errors in present defined blocks if error in root level (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          [`${path}/invalid-block.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "invalid"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "text"
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses[0].message).to.equal("Theme block 'blocks/invalid.liquid' does not exist.");
+      });
+
+      it(`should report an error when a preset defined block file does not exist with hash-style presets (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          [`${path}/invalid-block.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "@theme"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": {
+                    "missing_block_hash": {
+                      "type": "missing_block"
+                    }
+                  },
+                  "block_order": ["missing_block_hash"]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses[0].message).to.equal(
+          "Theme block 'blocks/missing_block.liquid' does not exist.",
+        );
+      });
+
+      it(`should not report an error when a preset defined block file exists with hash-style presets (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/text.liquid': '',
+          [`${path}/invalid-block.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "@theme"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": {
+                    "text_block": {
+                      "type": "text"
+                    }
+                  },
+                  "block_order": ["text_block"]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.be.empty;
+      });
+    });
+
+    it('should not report errors for locally scoped blocks at root level', async () => {
+      const theme: MockTheme = {
+        'sections/local-blocks.liquid': `
+          {% schema %}
+          {
+            "name": "Section name",
+            "blocks": [
+              {
+                "type": "local_block",
+                "name": "Local block"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+      };
+
+      const offenses = await check(theme, [ValidBlockTarget]);
+      expect(offenses).to.be.empty;
+    });
+  });
+
+  describe('Allowed Targeting Tests', () => {
+    paths.forEach((path) => {
+      it(`should report an error when a preset defined block is not specified at root level (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/text.liquid': '',
+          [`${path}/invalid-preset.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "text"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default preset",
+                  "blocks": [
+                    {
+                      "type": "invalid_preset_block"
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(2);
+        expect(offenses).to.containOffense(
+          'Theme block type "invalid_preset_block" must be allowed in "blocks" at the root of this schema.',
+        );
+        expect(offenses).to.containOffense(
+          "Theme block 'blocks/invalid_preset_block.liquid' does not exist.",
+        );
+      });
+
+      if (path === 'sections') {
+        it(`should report an error when a default defined block is not specified at root level`, async () => {
+          const theme: MockTheme = {
+            'blocks/text.liquid': '',
+            [`${path}/invalid-preset.liquid`]: `
+              {% schema %}
+              {
+                "name": "Section name",
+                "blocks": [
+                  {
+                    "type": "text"
+                  }
+                ],
+                "default": {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "name": "invalid_preset_block",
+                      "type": "invalid_preset_block"
+                    }
+                  ]
+                }
+              }
+              {% endschema %}
+            `,
+          };
+
+          const offenses = await check(theme, [ValidBlockTarget]);
+          expect(offenses).to.have.length(2);
+          expect(offenses).to.containOffense(
+            'Theme block type "invalid_preset_block" must be allowed in "blocks" at the root of this schema.',
+          );
+          expect(offenses).to.containOffense(
+            "Theme block 'blocks/invalid_preset_block.liquid' does not exist.",
+          );
+        });
+      }
+
+      it(`should report errors in presets for private blocks even when @theme is specified at root level (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/_private.liquid': '',
+          [`${path}/private-blocks.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "@theme"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "_private"
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses).to.containOffense(
+          'Theme block type "_private" is a private block so it must be explicitly allowed in "blocks" at the root of this schema.',
+        );
+      });
+
+      if (path === 'sections') {
+        it(`should report errors in default for private blocks even when @theme is specified at root level`, async () => {
+          const theme: MockTheme = {
+            'blocks/_private.liquid': '',
+            [`${path}/private-blocks.liquid`]: `
+              {% schema %}
+              {
+                "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+                "blocks": [
+                  {
+                    "type": "@theme"
+                  }
+                ],
+                "default": {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "name": "private",
+                      "type": "_private"
+                    }
+                  ]
+                }
+              }
+              {% endschema %}
+            `,
+          };
+
+          const offenses = await check(theme, [ValidBlockTarget]);
+          expect(offenses).to.have.length(1);
+          expect(offenses).to.containOffense(
+            'Theme block type "_private" is a private block so it must be explicitly allowed in "blocks" at the root of this schema.',
+          );
+        });
+      }
+
+      it(`should report errors with correct indices (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          [`${path}/private-blocks.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "@theme"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "_private"
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(2);
+
+        for (const offense of offenses) {
+          const content = theme[`${path}/private-blocks.liquid`];
+          const erroredContent = content.slice(offense.start.index, offense.end.index);
+          expect(erroredContent).to.equal('"_private"');
+        }
+      });
+
+      it(`should not report errors for private blocks when listed at root level (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/_private.liquid': '',
+          [`${path}/private-blocks.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "_private"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "_private"
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.be.empty;
+      });
+
+      it(`should handle mixed private and public blocks correctly (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/_private.liquid': '',
+          'blocks/custom.liquid': '',
+          [`${path}/mixed-blocks.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "@theme"
+                },
+                {
+                  "type": "_private"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "_private"
+                    },
+                    {
+                      "type": "custom"
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.be.empty;
+      });
+
+      it(`should report an error when a preset defined block is not specified at root level with hash-style presets (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/text.liquid': '',
+          [`${path}/invalid-preset.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "text"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default preset",
+                  "blocks": {
+                    "invalid_preset_block_hash": {
+                      "type": "invalid_preset_block"
+                    }
+                  },
+                  "block_order": ["invalid_preset_block_hash"]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(2);
+        expect(offenses).to.containOffense(
+          'Theme block type "invalid_preset_block" must be allowed in "blocks" at the root of this schema.',
+        );
+        expect(offenses).to.containOffense(
+          "Theme block 'blocks/invalid_preset_block.liquid' does not exist.",
+        );
+      });
+
+      it(`should report errors for private blocks even when @theme is specified at root level with hash-style presets (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/_private.liquid': '',
+          [`${path}/private-blocks.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "@theme"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": {
+                    "private_hash": {
+                      "type": "_private"
+                    }
+                  },
+                  "block_order": ["private_hash"]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses[0].message).to.equal(
+          'Theme block type "_private" is a private block so it must be explicitly allowed in "blocks" at the root of this schema.',
+        );
+      });
+
+      it(`should not report errors for private blocks when listed at root level with hash-style presets (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/_private.liquid': '',
+          [`${path}/private-blocks.liquid`]: `
+            {% schema %}
+            {
+              "name": "${path === 'sections' ? 'Section' : 'Block'} name",
+              "blocks": [
+                {
+                  "type": "_private"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": {
+                    "private_hash": {
+                      "type": "_private"
+                    }
+                  },
+                  "block_order": ["private_hash"]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.be.empty;
+      });
+
+      it(`should report errors for nested blocks when they are not allowed (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/image.liquid': '',
+          'blocks/group.liquid': '',
+          'blocks/text.liquid': '',
+          'blocks/slide.liquid': `
+            {% schema %}
+            {
+              "name": "Slide",
+              "blocks": [
+                {
+                  "type": "text"
+                },
+                {
+                  "type": "image"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+          [`${path}/slideshow.liquid`]: `
+            {% schema %}
+            {
+              "name": "Slideshow",
+              "blocks": [
+                {
+                  "type": "slide"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "slide",
+                      "blocks": [
+                        {
+                          "type": "group"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses[0].message).to.equal(
+          'Block type "group" is not allowed in "slide" blocks. Allowed types are: text, image.',
+        );
+      });
+
+      it(`should report errors for nested private blocks when they are not allowed (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/image.liquid': '',
+          'blocks/_private.liquid': '',
+          'blocks/text.liquid': '',
+          'blocks/slide.liquid': `
+            {% schema %}
+            {
+              "name": "Slide",
+              "blocks": [
+                {
+                  "type": "text"
+                },
+                {
+                  "type": "image"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+          [`${path}/slideshow.liquid`]: `
+            {% schema %}
+            {
+              "name": "Slideshow",
+              "blocks": [
+                {
+                  "type": "slide"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "slide",
+                      "blocks": [
+                        {
+                          "type": "_private"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses[0].message).to.equal(
+          'Private block type "_private" is not allowed in "slide" blocks.',
+        );
+      });
+
+      it(`should report errors for nested blocks when they are not allowed with hash-style presets (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/image.liquid': '',
+          'blocks/group.liquid': '',
+          'blocks/text.liquid': '',
+          'blocks/slide.liquid': `
+            {% schema %}
+            {
+              "name": "Slide",
+              "blocks": [
+                {
+                  "type": "text"
+                },
+                {
+                  "type": "image"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+          [`${path}/slideshow.liquid`]: `
+            {% schema %}
+            {
+              "name": "Slideshow",
+              "blocks": [
+                {
+                  "type": "slide"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": {
+                    "slide_hash": {
+                      "type": "slide",
+                      "blocks": {
+                        "group_hash": {
+                           "type": "group"
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses[0].message).to.equal(
+          'Block type "group" is not allowed in "slide" blocks. Allowed types are: text, image.',
+        );
+      });
+
+      it(`should report errors for further nested blocks when they are not allowed (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/image.liquid': '',
+          'blocks/group.liquid': `
+            {% schema %}
+            {
+              "name": "Group",
+              "blocks": [
+                {
+                  "type": "text"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+          'blocks/text.liquid': '',
+          'blocks/slide.liquid': `
+            {% schema %}
+            {
+              "name": "Slide",
+              "blocks": [
+                {
+                  "type": "group"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+          [`${path}/slideshow.liquid`]: `
+            {% schema %}
+            {
+              "name": "Slideshow",
+              "blocks": [
+                {
+                  "type": "slide"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "slide",
+                      "blocks": [
+                        {
+                          "type": "group",
+                          "blocks": [
+                            {
+                              "type": "image"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        expect(offenses[0].message).to.equal(
+          'Block type "image" is not allowed in "group" blocks. Allowed types are: text.',
+        );
+      });
+
+      describe(`Static Blocks used in a ${path} file`, () => {
+        const textSetting: Setting.Text = {
+          type: 'text' as Setting.Type.Text,
+          id: 'text',
+          label: 'Text',
+        };
+
+        describe('When presets are defined as a hash', () => {
+          describe('When the static block is used in the same file', () => {
+            const makeTheme = (
+              preset: Preset.PresetBlockHash,
+              blocks_order: string[] = [],
+            ): MockTheme => {
+              return {
+                [`${path}/slideshow.liquid`]: `
+                  # Static block is defined in the body of the file
+                  {% content_for "block", type: "static", id: "static_id" %}
+
+                  {% schema %}
+                    {
+                      "name": "Slideshow",
+                      "presets": [
+                        {
+                          "name": "Default",
+                          "blocks": ${JSON.stringify(preset, null, 2)},
+                          "block_order": ${JSON.stringify(blocks_order)}
+                        }
+                      ]
+                    }
+                  {% endschema %}
+                `,
+                'blocks/static.liquid': `
+                  {% schema %}
+                    {
+                      "name": "some static block",
+                      "settings": [${JSON.stringify(textSetting)}]
+                    }
+                  {% endschema %}
+                `,
+              };
+            };
+
+            it(`is silent for valid static blocks references`, async () => {
+              const theme: MockTheme = makeTheme({
+                static_id: {
+                  type: 'static',
+                  static: true,
+                  settings: {
+                    text: 'some text',
+                  },
+                },
+              });
+              const offenses = await check(theme, [ValidBlockTarget]);
+              expect(offenses).to.be.empty;
+            });
+
+            it(`reports a warning for missing (or mismatching) static blocks references`, async () => {
+              const theme: MockTheme = makeTheme({
+                mismatching_id: {
+                  type: 'static',
+                  static: true,
+                  settings: {
+                    text: 'some text',
+                  },
+                },
+              });
+
+              const offenses = await check(theme, [ValidBlockTarget]);
+              expect(offenses).not.to.be.empty;
+              expect(offenses).to.containOffense(
+                'Could not find a static block of type "static" with id "mismatching_id" in this file.',
+              );
+            });
+          });
+
+          describe('When the static block preset is defined in a nested block', () => {
+            const makeTheme = (
+              preset: Preset.PresetBlockHash,
+              blocks_order: string[] = [],
+            ): MockTheme => {
+              return {
+                [`${path}/slideshow-container.liquid`]: `
+                  # This file demonstrates how a static block can be used inside a nested block's preset
+                  {% content_for "blocks" %}
+
+                  {% schema %}
+                    {
+                      "name": "Slideshow container",
+                      "blocks": [{ "type": "slideshow" }],
+                      "presets": [{
+                        "name": "default",
+                        "block_order": ["slideshow1"],
+                        "blocks": {
+                          "slideshow1": {
+                            "type": "slideshow",
+                            "blocks": ${JSON.stringify(preset, null, 2)},
+                            "block_order": ${JSON.stringify(blocks_order)}
+                          }
+                        }
+                      }]
+                    }
+                  {% endschema %}
+                `,
+                [`blocks/slideshow.liquid`]: `
+                  # Static block is defined in the body of the file
+                  {% content_for "block", type: "static", id: "static_id" %}
+                  # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+                  {% schema %}
+                    { "name": "Slideshow" }
+                  {% endschema %}
+                `,
+                'blocks/static.liquid': `
+                  {% schema %}
+                    {
+                      "name": "some static block",
+                      "settings": [${JSON.stringify(textSetting)}]
+                    }
+                  {% endschema %}
+                `,
+              };
+            };
+
+            it('is silent for valid static blocks references', async () => {
+              const theme = makeTheme({
+                static_id: {
+                  type: 'static',
+                  static: true,
+                },
+              });
+              const offenses = await check(theme, [ValidBlockTarget]);
+              expect(offenses).to.be.empty;
+            });
+
+            it('reports warnings when using a mismatching (or nonexisting) static block', async () => {
+              const theme = makeTheme({
+                mismatching_id: {
+                  type: 'static',
+                  static: true,
+                },
+              });
+              const offenses = await check(theme, [ValidBlockTarget]);
+              expect(offenses).not.to.be.empty;
+              expect(offenses).to.containOffense(
+                'Could not find a static block of type "static" with id "mismatching_id" in "blocks/slideshow.liquid".',
+              );
+            });
+          });
+        });
+
+        describe('When preset are defined as an array', () => {
+          describe('When the static block is used in the same file', () => {
+            const makeTheme = (preset: Preset.PresetBlockForArray[]): MockTheme => {
+              return {
+                'blocks/static.liquid': `
+                  {% schema %}
+                  {
+                    "name": "some static block",
+                    "settings": [{ "label": "some setting", "type": "text", "id": "text" }],
+                  }
+                  {% endschema %}
+                `,
+                [`${path}/slideshow.liquid`]: `
+
+                  # Static block is defined in the body of the file
+                  {% content_for "block", type: "static", id: "static_id" %}
+                  # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+                  {% schema %}
+                  {
+                    "name": "Slideshow",
+                    "presets": [
+                      {
+                        "name": "Default",
+                        "blocks": ${JSON.stringify(preset, null, 2)}
+                      }
+                    ]
+                  }
+                  {% endschema %}
+                `,
+              };
+            };
+
+            it(`is silent for valid static blocks references (${path} bucket)`, async () => {
+              const theme: MockTheme = makeTheme([
+                {
+                  type: 'static',
+                  id: 'static_id',
+                  static: true,
+                  settings: {
+                    text: 'some text',
+                  },
+                },
+              ]);
+              const offenses = await check(theme, [ValidBlockTarget]);
+              expect(offenses).to.be.empty;
+            });
+
+            it(`reports a warning for missing (or mismatching) static blocks references (${path} bucket)`, async () => {
+              const theme: MockTheme = makeTheme([
+                {
+                  type: 'static',
+                  id: 'mismatching_id',
+                  static: true,
+                  settings: {
+                    text: 'some text',
+                  },
+                },
+              ]);
+
+              const offenses = await check(theme, [ValidBlockTarget]);
+              expect(offenses).not.to.be.empty;
+              expect(offenses).to.containOffense(
+                'Could not find a static block of type "static" with id "mismatching_id" in this file.',
+              );
+            });
+          });
+        });
+
+        describe('When the static block preset is defined in a nested block', () => {
+          const makeTheme = (
+            preset: Preset.PresetBlockForArray[],
+            blocks_order: string[] = [],
+          ): MockTheme => {
+            return {
+              [`${path}/slideshow-container.liquid`]: `
+                # This file demonstrates how a static block can be used inside a nested block's preset
+                {% content_for "blocks" %}
+
+                {% schema %}
+                  {
+                    "name": "Slideshow container",
+                    "blocks": [{ "type": "slideshow" }],
+                    "presets": [{
+                      "name": "default",
+                      "blocks": [
+                        {
+                          "type": "slideshow",
+                          "id": "slideshow1",
+                          "blocks": ${JSON.stringify(preset, null, 2)},
+                        }
+                      ]
+                    }]
+                  }
+                {% endschema %}
+              `,
+              [`blocks/slideshow.liquid`]: `
+                # Static block is defined in the body of the file
+                {% content_for "block", type: "static", id: "static_id" %}
+                # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+                {% schema %}
+                  { "name": "Slideshow" }
+                {% endschema %}
+              `,
+              'blocks/static.liquid': `
+                {% schema %}
+                  {
+                    "name": "some static block",
+                    "settings": [${JSON.stringify(textSetting)}]
+                  }
+                {% endschema %}
+              `,
+            };
+          };
+
+          it('is silent for valid static blocks references', async () => {
+            const theme = makeTheme([
+              {
+                id: 'static_id',
+                type: 'static',
+                static: true,
+              },
+            ]);
+            const offenses = await check(theme, [ValidBlockTarget]);
+            expect(offenses).to.be.empty;
+          });
+
+          it('reports warnings when using a mismatching (or nonexisting) static block', async () => {
+            const theme = makeTheme([
+              {
+                id: 'mismatching_id',
+                type: 'static',
+                static: true,
+              },
+            ]);
+            const offenses = await check(theme, [ValidBlockTarget]);
+            expect(offenses).not.to.be.empty;
+            expect(offenses).to.containOffense(
+              'Could not find a static block of type "static" with id "mismatching_id" in "blocks/slideshow.liquid".',
+            );
+          });
+        });
+      });
+
+      it(`should report errors with correct indices for nested blocks when they are not allowed (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/image.liquid': '',
+          'blocks/group.liquid': '',
+          'blocks/text.liquid': '',
+          'blocks/slide.liquid': `
+            {% schema %}
+            {
+              "name": "Slide",
+              "blocks": [
+                {
+                  "type": "text"
+                },
+                {
+                  "type": "image"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+          [`${path}/slideshow.liquid`]: `
+            {% schema %}
+            {
+              "name": "Slideshow",
+              "blocks": [
+                {
+                  "type": "slide"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "slide",
+                      "blocks": [
+                        {
+                          "type": "group"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.length(1);
+        const content = theme[`${path}/slideshow.liquid`];
+        const erroredContent = content.slice(offenses[0].start.index, offenses[0].end.index);
+        expect(erroredContent).to.equal('"group"');
+      });
+
+      it(`should not report errors for nested blocks when they are allowed (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/image.liquid': '',
+          'blocks/text.liquid': '',
+          'blocks/slide.liquid': `
+            {% schema %}
+            {
+              "name": "Slide",
+              "blocks": [
+                {
+                  "type": "text"
+                },
+                {
+                  "type": "image"
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+          [`${path}/slideshow.liquid`]: `
+            {% schema %}
+            {
+              "name": "Slideshow",
+              "blocks": [
+                {
+                  "type": "slide"
+                }
+              ],
+              "presets": [
+                {
+                  "name": "Default",
+                  "blocks": [
+                    {
+                      "type": "slide",
+                      "blocks": [
+                        {
+                          "type": "image"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+            {% endschema %}
+          `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.be.empty;
+      });
+
+      it(`should report errors on the correct file for nested blocks when they are not allowed (${path} bucket)`, async () => {
+        const theme: MockTheme = {
+          'blocks/image.liquid': '',
+          'blocks/group.liquid': '',
+          'blocks/text.liquid': '',
+          'blocks/slide.liquid': `
+          {% schema %}
+          {
+            "name": "Slide",
+            "blocks": [
+              {
+                "type": "text"
+              },
+              {
+                "type": "image"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+          [`${path}/slideshow.liquid`]: `
+          {% schema %}
+          {
+            "name": "Slideshow",
+            "blocks": [
+              {
+                "type": "slide"
+              }
+            ],
+            "presets": [
+              {
+                "name": "Default",
+                "blocks": [
+                  {
+                    "type": "slide",
+                    "blocks": [
+                      {
+                        "type": "group"
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        };
+
+        const offenses = await check(theme, [ValidBlockTarget]);
+        expect(offenses).to.have.lengthOf(1);
+        expect(offenses[0].uri).to.equal(`file:///${path}/slideshow.liquid`);
+      });
+
+      it('should not crash or timeout with cyclical nested block relationships', async () => {
+        const theme: MockTheme = {
+          'blocks/block-b.liquid': `
+          {% schema %}
+          {
+            "name": "Block B",
+            "blocks": [
+              {
+                "type": "block-c"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+          'blocks/block-a.liquid': `
+          {% schema %}
+          {
+            "name": "Block A",
+            "blocks": [
+              {
+                "type": "block-b"
+              }
+            ],
+            "presets": [
+              {
+                "name": "Default",
+                "blocks": [
+                  {
+                    "type": "block-b",
+                    "blocks": [
+                      {
+                        "type": "block-c"
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+          'blocks/block-c.liquid': `
+          {% schema %}
+          {
+            "name": "Block C",
+            "blocks": [
+              {
+                "type": "block-a"
+              }
+            ],
+            "presets": [
+              {
+                "name": "Default",
+                "blocks": [
+                  {
+                    "type": "block-a",
+                    "blocks": [
+                      {
+                        "type": "block-b"
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        };
+
+        const timeout = new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Test exceeded 500 ms')), 500),
+        );
+
+        const testPromise = (async () => {
+          const offenses = await check(theme, [ValidBlockTarget]);
+          expect(offenses).to.be.empty;
+        })();
+
+        await Promise.race([testPromise, timeout]);
+      });
+    });
+  });
+});