@platformos/platformos-check-common 0.0.2

package/src/checks/undefined-object/index.spec.ts

@@ -0,0 +1,519 @@
+import { expect, describe, it, assert } from 'vitest';
+import { UndefinedObject } from './index';
+import { runLiquidCheck, highlightedOffenses } from '../../test';
+import { Offense } from '../../types';
+
+describe('Module: UndefinedObject', () => {
+  it('should report an offense when object is undefined', async () => {
+    const sourceCode = `
+      {{ my_var }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'my_var' used."]);
+
+    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
+    expect(highlights).toEqual(['my_var']);
+  });
+
+  it('should report an offense when object with an attribute is undefined', async () => {
+    const sourceCode = `
+      {{ my_var.my_attr }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'my_var' used."]);
+  });
+
+  it('should report an offense when undefined object is used as an argument', async () => {
+    const sourceCode = `
+      {{ product[my_object] }}
+      {{ product[my_object] }}
+
+      {% comment %} string arguments should not be reported {% endcomment %}
+      {{ product["my_object"] }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(2);
+    expect(offenses.map((e) => e.message)).toEqual([
+      "Unknown object 'my_object' used.",
+      "Unknown object 'my_object' used.",
+    ]);
+  });
+
+  it('should report an offense when object is undefined in a Liquid tag', async () => {
+    const sourceCode = `
+    {% liquid
+      echo my_var
+    %}
+  `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'my_var' used."]);
+
+    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
+    expect(highlights).toEqual(['my_var']);
+  });
+
+  it('should not report an offense when object is defined with an assign tag', async () => {
+    const sourceCode = `
+      {% assign my_var = "value" %}
+      {{ my_var }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an offense when object is defined with an assign tag and it is used as an argument', async () => {
+    const sourceCode = `
+      {% assign prop = "title" %}
+      {{ product[prop] }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an offense when object is defined with an assign tag in a Liquid tag', async () => {
+    const sourceCode = `
+      {% liquid
+        assign my_var = "value"
+        echo my_var
+      %}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an offense when object is defined with a capture tag', async () => {
+    const sourceCode = `
+      {% capture my_var %} value {% endcapture %}
+      {{ my_var }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an offense when object is defined in a for loop', async () => {
+    const sourceCode = `
+      {% for c in collections %}
+        {{ c }}
+      {% endfor %}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report an offense when object is defined in a for loop but used outside of the scope', async () => {
+    const sourceCode = `
+      {% for c in collections %}
+        {{ c }}
+      {% endfor %}{{ c }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'c' used."]);
+  });
+
+  it('should not report an offense for function result variables', async () => {
+    const sourceCode = `
+      {% function a = 'test' %}
+      {{ a }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report an offense when object is defined in a for loop but used outside of the scope (in scenarios where the same variable has multiple scopes in the file)', async () => {
+    const sourceCode = `
+      {% for c in collections %}
+        {% comment %} -- Scope 1 -- {% endcomment %}
+        {{ c }}
+      {% endfor %}
+      {{ c }}
+      {% for c in collections %}
+        {% comment %} -- Scope 2 -- {% endcomment %}
+        {{ c }}
+      {% endfor %}
+      {{ c }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(2);
+    expect(offenses.map((e) => e.message)).toEqual([
+      "Unknown object 'c' used.",
+      "Unknown object 'c' used.",
+    ]);
+  });
+
+  it('should report an offense when undefined object defines another object', async () => {
+    const sourceCode = `
+      {% assign my_object = my_var %}
+      {{ my_object }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'my_var' used."]);
+  });
+
+  it('should not report an offense when object is defined in a tablerow loop', async () => {
+    const sourceCode = `
+      {% tablerow c in collections %}
+        {{ c }}
+      {% endtablerow %}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report an offense when object is defined in a tablerow loop but used outside of the scope', async () => {
+    const sourceCode = `
+      {% tablerow c in collections %}
+        {{ c }}
+      {% endtablerow %}{{ c }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'c' used."]);
+  });
+
+  it('should contextually report on the undefined nature of the paginate object (defined in paginate tag, undefined outside)', async () => {
+    const sourceCode = `
+      {% assign col = 'string' | split: '' %}
+      {% paginate col by 5 %}
+        {{ paginate }}
+      {% endpaginate %}{{ paginate }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'paginate' used."]);
+  });
+
+  it('should contextually report on the undefined nature of the form object (defined in form tag, undefined outside)', async () => {
+    const sourceCode = `
+      {% form "cart" %}
+        {{ form }}
+      {% endform %}{{ form }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'form' used."]);
+  });
+
+  it('should support {% layout none %}', async () => {
+    const sourceCode = `
+      {% layout none %}
+      {{ none }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'none' used."]);
+  });
+
+  it('should support {% increment var %} and {% decrement var %}', async () => {
+    for (const tag of ['increment', 'decrement']) {
+      const sourceCode = `
+        {% ${tag} var %}
+        {{ var }}
+      `;
+
+      const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+      expect(offenses).toHaveLength(0);
+    }
+  });
+
+  it('should report an offense when object is undefined in a "snippet" file with doc tags that are missing the associated param', async () => {
+    const sourceCode = `
+    {% doc %}
+    {% enddoc %}
+    {{ my_var }}
+      `;
+
+    const offenses = await runLiquidCheck(
+      UndefinedObject,
+      sourceCode,
+      'app/views/partials/file.liquid',
+    );
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'my_var' used."]);
+  });
+
+  it('should not report an offense when object is defined with @param in a snippet file', async () => {
+    const sourceCode = `
+      {% doc %}
+        @param {string} text
+      {% enddoc %}
+
+      {{ text }}
+    `;
+
+    const filePath = 'app/views/partials/file.liquid';
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode, filePath);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report an offense when object is not global', async () => {
+    const sourceCode = `
+      {{ image }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'image' used."]);
+  });
+
+  it('should not report an offense for forloop/tablerowloop variables when in the correct context', async () => {
+    for (const tag of ['for', 'tablerow']) {
+      const sourceCode = `
+        {% ${tag} x in collections %}
+          {{ ${tag}loop }}
+        {% end${tag} %}
+      `;
+
+      const offenses = await runLiquidCheck(UndefinedObject, sourceCode, 'file.liquid');
+
+      expect(offenses).toHaveLength(0);
+    }
+  });
+
+  it('should support contextual exceptions', async () => {
+    let offenses: Offense[];
+    const contexts: [string, string][] = [
+      ['section', 'sections/section.liquid'],
+      ['predictive_search', 'sections/predictive-search.liquid'],
+      ['recommendations', 'sections/recommendations.liquid'],
+      ['comment', 'sections/main-article.liquid'],
+      ['block', 'blocks/theme-app-extension.liquid'],
+      ['app', 'blocks/theme-app-extension.liquid'],
+      ['app', 'app/views/partials/theme-app-extension.liquid'],
+    ];
+    for (const [object, goodPath] of contexts) {
+      offenses = await runLiquidCheck(UndefinedObject, `{{ ${object} }}`, goodPath);
+      expect(offenses).toHaveLength(0);
+      offenses = await runLiquidCheck(UndefinedObject, `{{ ${object} }}`, 'file.liquid');
+      expect(offenses).toHaveLength(1);
+    }
+  });
+
+  it('should support contextual exceptions for checkout.liquid', async () => {
+    let offenses: Offense[];
+    const contexts: [string, string][] = [
+      ['locale', 'layout/checkout.liquid'],
+      ['direction', 'layout/checkout.liquid'],
+      ['skip_to_content_link', 'layout/checkout.liquid'],
+      ['checkout_html_classes', 'layout/checkout.liquid'],
+      ['checkout_stylesheets', 'layout/checkout.liquid'],
+      ['checkout_scripts', 'layout/checkout.liquid'],
+      ['content_for_logo', 'layout/checkout.liquid'],
+      ['breadcrumb', 'layout/checkout.liquid'],
+      ['order_summary_toggle', 'layout/checkout.liquid'],
+      ['content_for_order_summary', 'layout/checkout.liquid'],
+      ['alternative_payment_methods', 'layout/checkout.liquid'],
+      ['content_for_footer', 'layout/checkout.liquid'],
+      ['tracking_code', 'layout/checkout.liquid'],
+    ];
+    for (const [object, goodPath] of contexts) {
+      offenses = await runLiquidCheck(UndefinedObject, `{{ ${object} }}`, goodPath);
+      expect(offenses).toHaveLength(0);
+      offenses = await runLiquidCheck(UndefinedObject, `{{ ${object} }}`, 'file.liquid');
+      expect(offenses).toHaveLength(1);
+    }
+  });
+
+  it('should report an offense for forloop/tablerowloop used outside of context', async () => {
+    const sourceCode = `
+      {{ forloop }}
+      {{ tablerowloop }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode, 'file.liquid');
+
+    expect(offenses).toHaveLength(2);
+  });
+
+  it('should not report an offenses when definitions for global objects are unavailable', async () => {
+    const sourceCode = `
+      {{ my_var }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode, 'file.liquid', {
+      themeDocset: undefined,
+    });
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an offense when object is defined with @param in a block file', async () => {
+    const sourceCode = `
+      {% doc %}
+        @param {string} text
+      {% enddoc %}
+
+      {{ text }}
+    `;
+
+    const filePath = 'blocks/my-custom-block.liquid';
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode, filePath);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report an offense when an undefined object is used alongside @param in a block file', async () => {
+    const sourceCode = `
+      {% doc %}
+        @param {string} text
+      {% enddoc %}
+
+      {{ text }}
+      {{ undefined_variable }}
+    `;
+
+    const filePath = 'blocks/my-custom-block.liquid';
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode, filePath);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toBe("Unknown object 'undefined_variable' used.");
+  });
+
+  it('should not report an offense when a self defined variable is defined with a @param tag', async () => {
+    const sourceCode = `
+      {% doc %}
+        @param {string} text
+      {% enddoc %}
+
+      {% assign text = text | default: "value" %}
+    `;
+
+    const filePath = 'app/views/partials/file.liquid';
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode, filePath);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report an offense when assigning an undefined variable to itself', async () => {
+    const sourceCode = `
+      {% assign my_var = my_var | default: "fallback" %}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toBe("Unknown object 'my_var' used.");
+  });
+
+  it('should not report an offense when using variables inside visible_if statements in a schema tag', async () => {
+    const sourceCode = `
+    {% schema %}
+    {
+      "settings": [
+        {
+          "type": "text",
+          "label": "foo",
+          "id": "foo",
+        }
+        {
+          "type": "text",
+          "label": "bar",
+          "id": "bar",
+          "visible_if": "{{ block.settings.foo }}",
+        }
+      ]
+    }
+    {% endschema %}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    assert(offenses.length == 0);
+    expect(offenses).to.be.empty;
+  });
+
+  it('should report an offense when job_id is used inside background block', async () => {
+    const sourceCode = `
+      {% background job_id %}
+        {{ job_id }}
+      {% endbackground %}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+  });
+
+  it('should not report an offense when job_id is used after background block', async () => {
+    const sourceCode = `
+      {% background job_id %}
+        {% assign a = 5 %}
+      {% endbackground %}
+      {{ job_id }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an offense when job_id is used after background block with args', async () => {
+    const sourceCode = `
+      {% background job_id, priority: 'low' %}
+        {% assign a = 5 %}
+      {% endbackground %}
+      {{ job_id }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report an offense when job_id is used before background block', async () => {
+    const sourceCode = `
+      {{ job_id }}
+      {% background job_id %}
+        {% assign a = 5 %}
+      {% endbackground %}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'job_id' used."]);
+  });
+});