@platformos/platformos-check-common 0.0.6 → 0.0.8

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

@@ -1,1396 +0,0 @@
-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]);
-      });
-    });
-  });
-});