@xano/xanoscript-language-server 11.0.3

package/parser/functions/expect/unitExpectWithArgumentsFn.spec.js

@@ -0,0 +1,341 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { parser } from "../../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.unitExpectWithArgumentsFn();
+  return parser;
+}
+
+describe("unitExpectWithArgumentsFn", () => {
+  // to_equal
+  it("unitExpectWithArgumentsFn to_equal accepts a $response variable", () => {
+    const parser = parse(`to_equal ($response) {
+      value = "foo"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn does not accept a non response variable", () => {
+    const parser = parse(`to_equal ($foo) {
+      value = 12  
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn does not accept variables", () => {
+    const parser = parse(`to_equal ($response) {
+      value = $response.x
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn accepts multiple type of objects", () => {
+    let parser = parse(`to_equal ($response) {
+      value = [1,2, [3,4]]
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`to_equal ($response) {
+      value = "string"
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`to_equal ($response) {
+      value = 12.34
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`to_equal ($response) {
+      value = {
+        "key": "value"
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`to_equal ($response) {
+      value = true
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`to_equal ($response) {
+      value = null
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn does not accept variable, expressions", () => {
+    let parser = parse(`to_equal ($response) {
+      value = $input.foo
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`to_equal ($response) {
+      value = 12 + 10
+    }`);
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`to_equal ($response) {
+      value = { foo: { bar: 12 + 10 }}
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`to_equal ($response) {
+      value = { foo: { bar: $response.y }}
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`to_equal ($response) {
+      value = [ 1, [2, [$response.x]]]
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  // to_equal
+  it("unitExpectWithArgumentsFn to_equal do not accept a filter on $response argument", () => {
+    const parser = parse(`to_equal ($response|get:foo:"bar") {
+      value = "foo"
+    };`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_equal accepts a $response variable with subpath", () => {
+    const parser = parse(`to_equal ($response.x) {
+      value = "foo"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_equal does not accept a missing equals", () => {
+    const parser = parse(`to_equal ($response) {
+    };`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_equal does not accept a missing value", () => {
+    const parser = parse(`to_equal {
+      value = 10
+    };`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  // to_start_with
+  it("unitExpectWithArgumentsFn to_start_with accepts a $response variable", () => {
+    const parser = parse(`to_start_with ($response) {
+      value = "bar"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_start_with does not accept a missing value", () => {
+    const parser = parse(`to_start_with {
+      value = "bar"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_start_with does not accept a missing argument", () => {
+    const parser = parse(`to_start_with ($response) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_start_with does accept subattribute from response", () => {
+    const parser = parse(`to_start_with ($response.x) {
+      value = "bar"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_end_with
+  it("unitExpectWithArgumentsFn to_end_with accepts a $response variable", () => {
+    const parser = parse(`to_end_with ($response) {
+      value = "baz"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_end_with does not accept a missing value", () => {
+    const parser = parse(`to_end_with ($response) {
+    };`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_end_with does not accept a missing argument", () => {
+    const parser = parse(`to_end_with {
+      value = "baz"
+    };`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_end_with does accept subattribute from response", () => {
+    const parser = parse(`to_end_with ($response.x) {
+      value = "baz"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_be_greater_than
+  it("unitExpectWithArgumentsFn to_be_greater_than accepts a $response variable", () => {
+    const parser = parse(`to_be_greater_than ($response) {
+      value = 10
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_be_greater_than does not accept a missing argument", () => {
+    const parser = parse(`to_be_greater_than {
+      value = 22 + 12
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_be_greater_than does not accept a missing value", () => {
+    const parser = parse(`to_be_greater_than ($response) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_be_greater_than does accept subattribute from response", () => {
+    let parser = parse(`to_be_greater_than ($response.x) {
+      value = $response.y + 10
+    }`);
+    // does not accept a variable in value
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`to_be_greater_than ($response.x) {
+      value =  10
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_be_less_than
+  it("unitExpectWithArgumentsFn to_be_less_than accepts a $response variable", () => {
+    const parser = parse(`to_be_less_than ($response) {
+      value = 10
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_be_less_than does not accept a missing value", () => {
+    const parser = parse(`to_be_less_than ($response) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_be_less_than does not accept a missing argument", () => {
+    const parser = parse(`to_be_less_than {
+      value = 10
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_be_less_than does accept subattribute from response", () => {
+    let parser = parse(`to_be_less_than ($response.x) {
+      value = $response.y - 55
+    }`);
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`to_be_less_than ($response.x) {
+      value =  55
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_match
+  it("unitExpectWithArgumentsFn to_match accepts a $response variable", () => {
+    const parser = parse(`to_match ($response) {
+      value = "pattern"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_match does not accept a missing argument", () => {
+    const parser = parse(`to_match {
+      value = 12
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_match does not accept a missing value", () => {
+    const parser = parse(`to_match ($response) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_match does accept subattribute from response", () => {
+    const parser = parse(`to_match ($response.x) {
+      value = "pattern"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_not_equal
+  it("unitExpectWithArgumentsFn to_not_equal accepts a $response variable", () => {
+    const parser = parse(`to_not_equal ($response) {
+      value = "notfoo"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_not_equal does not accept a missing value", () => {
+    const parser = parse(`to_not_equal ($response) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_not_equal does not accept a missing argument", () => {
+    const parser = parse(`to_not_equal {
+      value = 66
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_not_equal does accept subattribute from response", () => {
+    let parser = parse(`to_not_equal ($response.x) {
+      value = $response.y
+    }`);
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`to_not_equal ($response.x) {
+      value = 66
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_contain
+  it("unitExpectWithArgumentsFn to_contain accepts a $response variable", () => {
+    const parser = parse(`to_contain ($response) {
+      value = "needle"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_contain does not accept a missing argument", () => {
+    const parser = parse(`to_contain {
+      value = 12
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_contain does not accept a missing value", () => {
+    const parser = parse(`to_contain ($response){
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithArgumentsFn to_contain does accept subattribute from response", () => {
+    const parser = parse(`to_contain ($response.haystack){
+      value = "needle"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/expect/unitExpectWithoutArgumentsFn.js

@@ -0,0 +1,42 @@
+import { LParent, RParent } from "../../../lexer/control.js";
+import {
+  ToBeDefinedToken,
+  ToBeEmptyToken,
+  ToBeFalseToken,
+  ToBeInTheFutureToken,
+  ToBeInThePastToken,
+  ToBeNullToken,
+  ToBeTrueToken,
+  ToNotBeDefinedToken,
+  ToNotBeNullToken,
+} from "../../../lexer/expect.js";
+import { DotToken, Identifier } from "../../../lexer/tokens.js";
+import { ResponseVariable } from "../../../lexer/variables.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function unitExpectWithoutArgumentsFn($) {
+  return () => {
+    $.sectionStack.push("unitExpectWithoutArgumentsFn");
+    $.OR([
+      { ALT: () => $.CONSUME(ToBeTrueToken) }, // "to_be_true"
+      { ALT: () => $.CONSUME(ToBeFalseToken) }, // "to_be_false"
+      { ALT: () => $.CONSUME(ToBeInThePastToken) }, // "to_be_in_the_past"
+      { ALT: () => $.CONSUME(ToBeInTheFutureToken) }, // "to_be_in_the_future"
+      { ALT: () => $.CONSUME(ToBeDefinedToken) }, // "to_be_defined"
+      { ALT: () => $.CONSUME(ToNotBeDefinedToken) }, // "to_not_be_defined"
+      { ALT: () => $.CONSUME(ToBeNullToken) }, // "to_be_null"
+      { ALT: () => $.CONSUME(ToNotBeNullToken) }, // "to_not_be_null"
+      { ALT: () => $.CONSUME(ToBeEmptyToken) }, // "to_be_empty"
+    ]);
+    $.CONSUME(LParent); // "("
+    $.CONSUME(ResponseVariable); // "$response"
+    $.MANY(() => {
+      $.CONSUME(DotToken); // "."
+      $.CONSUME(Identifier); // "x", "users", etc.
+    });
+    $.CONSUME(RParent); // ")"
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/expect/unitExpectWithoutArgumentsFn.spec.js

@@ -0,0 +1,69 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { parser } from "../../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.unitExpectWithoutArgumentsFn();
+  return parser;
+}
+
+describe("unitExpectWithoutArgumentsFn", () => {
+  it("unitExpectWithoutArgumentsFn has the expect to_be_true", () => {
+    const parser = parse(`to_be_true ($response.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn does not accept a non response variable", () => {
+    const parser = parse(`to_be_true ($foo)`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn does not accept a filter on $response argument", () => {
+    const parser = parse(`to_be_true ($response.x|get:foo:"bar")`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn has the expect to_be_false", () => {
+    const parser = parse(`to_be_false ($response.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn has the expect to_be_in_the_past", () => {
+    const parser = parse(`to_be_in_the_past ($response.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn has the expect to_be_in_the_future", () => {
+    const parser = parse(`to_be_in_the_future ($response.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn has the expect to_be_defined", () => {
+    const parser = parse(`to_be_defined ($response.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn has the expect to_not_be_defined", () => {
+    const parser = parse(`to_not_be_defined ($response.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn has the expect to_be_null", () => {
+    const parser = parse(`to_be_null ($response.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn has the expect to_not_be_null", () => {
+    const parser = parse(`to_not_be_null ($response)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectWithoutArgumentsFn has the expect to_be_empty", () => {
+    const parser = parse(`to_be_empty ($response.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/expect/workflowExpectToBeWithinFn.js

@@ -0,0 +1,22 @@
+import { LParent, RParent } from "../../../lexer/control.js";
+import { ToBeWithinToken } from "../../../lexer/expect.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function workflowExpectToBeWithinFn($) {
+  const requiredAttrs = ["min", "max"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("workflowExpectToBeWithinFn");
+    const fnToken = $.CONSUME(ToBeWithinToken); // "to_be_within"
+    $.CONSUME(LParent); // "("
+    $.SUBRULE($.expressionFn); // "$foo|get:bar:null"
+    $.CONSUME(RParent); // ")"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/expect/workflowExpectToBeWithinFn.spec.js

@@ -0,0 +1,70 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { parser } from "../../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.workflowExpectToBeWithinFn();
+  return parser;
+}
+
+describe("workflowExpectToBeWithinFn", () => {
+  it("workflowExpectToBeWithinFn accepts args and a value argument", () => {
+    const parser = parse(`to_be_within ($foo) {
+        min = 11
+        max = 13
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectToBeWithinFn accepts a filtered variable", () => {
+    const parser = parse(`to_be_within ($var.foo|first) {
+      min = 11
+      max = 13
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectToBeWithinFn accepts a description", () => {
+    const parser = parse(`to_be_within ($foo) {
+        min = 11
+        max = 13
+        description = "This is a description"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectToBeWithinFn accepts a disabled flag", () => {
+    const parser = parse(`to_be_within ($foo) {
+        min = 11
+        max = 13
+        disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectToBeWithinFn does not accept a missing min", () => {
+    const parser = parse(`to_be_within ($input.x) {
+      max = 13
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectToBeWithinFn does not accept a missing max", () => {
+    const parser = parse(`to_be_within ($var.foo) {
+      min = 11
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectToBeWithinFn does not accept a missing value", () => {
+    const parser = parse(`to_be_within {
+      min = 11
+      max = 13
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/expect/workflowExpectToThrowFn.js

@@ -0,0 +1,21 @@
+import { ToThrowToken } from "../../../lexer/expect.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function workflowExpectToThrowFn($) {
+  return () => {
+    $.sectionStack.push("workflowExpectToThrowFn");
+    const fnToken = $.CONSUME(ToThrowToken); // "to_throw"
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          "stack?": "[test-stack]",
+          "exception?": "[string]",
+        },
+      ],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/expect/workflowExpectToThrowFn.spec.js

@@ -0,0 +1,56 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { parser } from "../../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.workflowExpectToThrowFn();
+  return parser;
+}
+
+describe("workflowExpectToThrowFn", () => {
+  it("workflowExpectToThrowFn accepts data field", () => {
+    const parser = parse(`to_throw {
+      exception = "error"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectToThrowFn accepts an empty payload", () => {
+    const parser = parse(`to_throw`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectToThrowFn accepts a stack", () => {
+    const parser = parse(`to_throw {
+      exception = "error"
+      stack {
+        var $x1 {
+          value = 12
+        }
+
+        function.run my_function {
+          input = { key: $x1 }
+        }
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectToThrowFn does not accept an operand", () => {
+    const parser = parse(`to_throw ($response.x) {
+      value = "foo"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectToThrowFn rejects an expression", () => {
+    const parser = parse(`to_throw {
+        exception = $var.exception
+      }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/expect/workflowExpectWithArgumentsFn.js

@@ -0,0 +1,40 @@
+import { LParent, RParent } from "../../../lexer/control.js";
+import {
+  ToBeGreaterThanToken,
+  ToBeLessThanToken,
+  ToContainToken,
+  ToEndWithToken,
+  ToEqualToken,
+  ToMatchToken,
+  ToNotEqualToken,
+  ToStartWithToken,
+} from "../../../lexer/expect.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function workflowExpectWithArgumentsFn($) {
+  const requiredAttrs = ["value"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("workflowExpectWithArgumentsFn");
+    const fnToken = $.OR([
+      { ALT: () => $.CONSUME(ToEqualToken) }, // "to_equal"
+      { ALT: () => $.CONSUME(ToStartWithToken) }, // "to_start_with"
+      { ALT: () => $.CONSUME(ToEndWithToken) }, // "to_end_with"
+      { ALT: () => $.CONSUME(ToBeGreaterThanToken) }, // "to_be_greater_than"
+      { ALT: () => $.CONSUME(ToBeLessThanToken) }, // "to_be_less_than"
+      { ALT: () => $.CONSUME(ToMatchToken) }, // "to_match"
+      { ALT: () => $.CONSUME(ToNotEqualToken) }, // "to_not_equal"
+      { ALT: () => $.CONSUME(ToContainToken) }, // "to_contain"
+    ]);
+    $.CONSUME(LParent); // "("
+    $.SUBRULE($.expressionFn); // "$foo|get:bar:null"
+    $.CONSUME(RParent); // ")"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.sectionStack.pop();
+  };
+}