@xano/xanoscript-language-server 11.12.2 → 11.12.3

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

@@ -1,308 +0,0 @@
-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.workflowExpectWithArgumentsFn();
-  return parser;
-}
-
-describe("workflowExpectWithArgumentsFn", () => {
-  // to_equal
-  it("workflowExpectWithArgumentsFn to_equal accepts a $var.x variable", () => {
-    const parser = parse(`to_equal ($var.x) {
-      value = "foo"
-    };`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn accepts an $input variable", () => {
-    const parser = parse(`to_equal ($input.x) {
-      value = 12
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("accept string a named attribute", () => {
-    const parser = parse(`to_equal ($attr.sub."some value") {
-      value = "enabled"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn accepts a filtered variable", () => {
-    // foo is not in quotes
-    let parser = parse(`to_equal ($x|get:foo:"bar") {
-      value = 12
-    }`);
-    expect(parser.errors).to.not.be.empty;
-
-    // all good, foo is in quotes
-    parser = parse(`to_equal ($x|get:"foo":"bar") {
-      value = 12
-    }`);
-    expect(parser.errors).to.be.empty;
-
-    // foo is not in quotes but is in an expression markers
-    parser = parse(`to_equal (\`$x|get:foo:"bar"\`) {
-      value = 12
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn accepts a description", () => {
-    const parser = parse(`to_equal ($foo) {
-      value = 12
-      description = "This is a description"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn accepts a disabled attribute", () => {
-    const parser = parse(`to_equal ($foo) {
-      value = 12
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_equal accepts a filter on $variable argument", () => {
-    let parser = parse(`to_equal ($variable|get:"foo":"bar") {
-      value = "foo"
-    };`);
-    expect(parser.errors).to.be.empty;
-
-    parser = parse(`to_equal (\`variable|get:"foo":"bar"\`) {
-      value = "foo"
-    };`);
-    expect(parser.errors).to.be.empty;
-
-    parser = parse(`to_equal (variable|get:"foo":bar) {
-      value = "foo"
-    };`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_equal accepts a $variable with a subpath", () => {
-    const parser = parse(`to_equal ($variable.x) {
-      value = "foo"
-    };`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_equal rejects a missing value", () => {
-    let parser = parse(`to_equal ($variable) {
-    };`);
-    expect(parser.errors).to.not.be.empty;
-
-    parser = parse(`to_equal ($variable)`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_equal rejects a missing argument", () => {
-    const parser = parse(`to_equal {
-      value = 10
-    };`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  // to_start_with
-  it("workflowExpectWithArgumentsFn to_start_with accepts a $variable", () => {
-    const parser = parse(`to_start_with ($variable) {
-      value = "bar"
-    };`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_start_with rejects a missing argument", () => {
-    const parser = parse(`to_start_with {
-      value = "bar"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_start_with rejects a missing value", () => {
-    const parser = parse(`to_start_with ($variable) {
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_start_with accepts subattribute from variable", () => {
-    const parser = parse(`to_start_with ($variable.x) {
-      value = "bar"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // to_end_with
-  it("workflowExpectWithArgumentsFn to_end_with accepts a $variable variable", () => {
-    const parser = parse(`to_end_with ($variable) {
-      value = "baz"
-    };`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_end_with rejects a missing value", () => {
-    const parser = parse(`to_end_with ($variable) {
-    };`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_end_with rejects a missing argument", () => {
-    const parser = parse(`to_end_with {
-      value = "baz"
-    };`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_end_with does accept subattribute from variable", () => {
-    const parser = parse(`to_end_with ($variable.x) {
-      value = "baz"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // to_be_greater_than
-  it("workflowExpectWithArgumentsFn to_be_greater_than accepts a $variable variable", () => {
-    const parser = parse(`to_be_greater_than ($variable) {
-      value = 10
-    };`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_be_greater_than rejects a missing argument", () => {
-    const parser = parse(`to_be_greater_than {
-      value = 22 + 12
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_be_greater_than rejects a missing value", () => {
-    const parser = parse(`to_be_greater_than ($variable) {
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_be_greater_than does accept subattribute from variable", () => {
-    const parser = parse(`to_be_greater_than ($variable.x) {
-      value = $variable.y + 10
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // to_be_less_than
-  it("workflowExpectWithArgumentsFn to_be_less_than accepts a $variable variable", () => {
-    const parser = parse(`to_be_less_than ($variable) {
-      value = 10
-    };`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_be_less_than rejects a missing value", () => {
-    const parser = parse(`to_be_less_than ($variable) {
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_be_less_than rejects a missing argument", () => {
-    const parser = parse(`to_be_less_than {
-      value = 10
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_be_less_than does accept subattribute from variable", () => {
-    const parser = parse(`to_be_less_than ($variable.x) {
-      value = $variable.y - 55
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // to_match
-  it("workflowExpectWithArgumentsFn to_match accepts a $variable variable", () => {
-    const parser = parse(`to_match ($variable) {
-      value = "pattern"
-    };`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_match rejects a missing argument", () => {
-    const parser = parse(`to_match {
-      value = $variable
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_match rejects a missing value", () => {
-    const parser = parse(`to_match ($variable) {
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_match does accept subattribute from variable", () => {
-    const parser = parse(`to_match ($variable.x) {
-      value = "pattern"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // to_not_equal
-  it("workflowExpectWithArgumentsFn to_not_equal accepts a $variable variable", () => {
-    const parser = parse(`to_not_equal ($variable) {
-      value = "notfoo"
-    };`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_not_equal rejects a missing value", () => {
-    const parser = parse(`to_not_equal ($variable) {
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_not_equal rejects a missing argument", () => {
-    const parser = parse(`to_not_equal {
-      value = 66
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_not_equal does accept subattribute from variable", () => {
-    const parser = parse(`to_not_equal ($variable.x) {
-      value = $variable.y
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  // to_contain
-  it("workflowExpectWithArgumentsFn to_contain accepts a $variable variable", () => {
-    const parser = parse(`to_contain ($variable) {
-      value = "needle"
-    };`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_contain rejects a missing argument", () => {
-    const parser = parse(`to_contain {
-      value = $variable.x
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_contain rejects a missing value", () => {
-    const parser = parse(`to_contain ($variable){
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithArgumentsFn to_contain does accept subattribute from variable", () => {
-    const parser = parse(`to_contain ($haystack){
-      value = "needle"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

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

@@ -1,87 +0,0 @@
-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.workflowExpectWithoutArgumentsFn();
-  return parser;
-}
-
-describe("workflowExpectWithoutArgumentsFn", () => {
-  it("workflowExpectWithoutArgumentsFn has the expect to_be_true", () => {
-    const parser = parse(`to_be_true ($var.x)`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn accepts an $input variable", () => {
-    const parser = parse(`to_be_true ($input.x)`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn accepts a filter on var argument", () => {
-    let parser = parse(`to_be_true ($x|get:"foo":"bar")`);
-    expect(parser.errors).to.be.empty;
-
-    parser = parse('to_be_true (`$x|get:foo:"bar"`)');
-    expect(parser.errors).to.be.empty;
-
-    parser = parse("to_be_true (`$x|get:foo:bar`)");
-    expect(parser.errors).to.be.empty;
-
-    parser = parse('to_be_true ($x|get:foo:"bar")');
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn accepts a description", () => {
-    const parser = parse(`to_be_false ($x) {
-      description = "This is a description"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn can be disabled", () => {
-    const parser = parse(`to_be_false ($x) {
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn has the expect to_be_in_the_past", () => {
-    const parser = parse(`to_be_in_the_past ($var.x)`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn has the expect to_be_in_the_future", () => {
-    const parser = parse(`to_be_in_the_future ($var.x)`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn has the expect to_be_defined", () => {
-    const parser = parse(`to_be_defined ($var.x)`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn has the expect to_not_be_defined", () => {
-    const parser = parse(`to_not_be_defined ($var.x)`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn has the expect to_be_null", () => {
-    const parser = parse(`to_be_null ($var.x)`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn has the expect to_not_be_null", () => {
-    const parser = parse(`to_not_be_null ($response)`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("workflowExpectWithoutArgumentsFn has the expect to_be_empty", () => {
-    const parser = parse(`to_be_empty ($var.x)`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/math/allMathFn.spec.js

@@ -1,100 +0,0 @@
-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.allMathFn();
-  return parser;
-}
-
-describe("allMathFn", () => {
-  it("allMathFn accepts a value", () => {
-    const parser = parse(`add $x1 {
-      value = 1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn requires a value", () => {
-    const parser = parse(`add $x1 {
-      description = "foo"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("allMathFn accepts a description", () => {
-    const parser = parse(`add $x1 {
-      value = $x1
-      description = "foo"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn can be disabled", () => {
-    const parser = parse(`add $x1 {
-      value = $x1
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn accepts a long form variable", () => {
-    const parser = parse(`add $var.x1 {
-      value = $x1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn accepts an attribute for assignment", () => {
-    const parser = parse(`add $x1.bar {
-      value = $x1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn can sub", () => {
-    const parser = parse(`sub $x1 {
-      value = 1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn can mul", () => {
-    const parser = parse(`mul $x1 {
-      value = 1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn can div", () => {
-    const parser = parse(`div $x1 {
-      value = 1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn can bitwise.xor", () => {
-    const parser = parse(`bitwise.xor $x1 {
-      value = 1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn can bitwise.and", () => {
-    const parser = parse(`bitwise.and $x1 {
-      value = 1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("allMathFn can bitwise.or", () => {
-    const parser = parse(`bitwise.or $x1 {
-      value = 1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/middlewareCallFn.spec.js

@@ -1,44 +0,0 @@
-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.middlewareCallFn();
-  return parser;
-}
-
-describe("middlewareCallFn", () => {
-  it("should parse middleware.call statement", () => {
-    const parser = parse(`middleware.call my_action {
-      input = {
-        "vars": {
-          "key": "value"
-        },
-        "type": "pre"
-      }
-    } as $result`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middleware.call requires inputs", () => {
-    const parser = parse(`middleware.call my_action as $result`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("middleware.call accepts a description", () => {
-    const parser = parse(`middleware.call my_agent {
-      description = "This is a middleware call"
-      input = {
-        "vars": {
-          "key": "value"
-        },
-        "type": "post"
-      }
-    } as $result`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/object/objectEntriesFn.spec.js

@@ -1,44 +0,0 @@
-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.objectEntriesFn();
-  return parser;
-}
-
-describe("objectEntriesFn", () => {
-  it("objectEntriesFn accepts a value", () => {
-    const parser = parse(`entries {
-      value = $var.obj
-    } as $x4`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectEntriesFn can be disabled", () => {
-    const parser = parse(`entries {
-      value = $var.obj
-      disabled = true
-    } as $x4`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectEntriesFn accept a description", () => {
-    const parser = parse(`entries {
-      value = $var.obj
-      description = "compressed data"
-    } as $x4`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectEntriesFn requires a value", () => {
-    const parser = parse(`entries {
-      description = "compressed data"
-    } as $x4`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/functions/object/objectKeysFn.spec.js

@@ -1,44 +0,0 @@
-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.objectKeysFn();
-  return parser;
-}
-
-describe("objectKeysFn", () => {
-  it("objectKeysFn accepts a value", () => {
-    const parser = parse(`keys {
-      value = $input.my_object
-    } as $keys`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectKeysFn can be disabled", () => {
-    const parser = parse(`keys {
-      value = $input.my_object
-      disabled = true
-    } as $keys`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectKeysFn accept a description", () => {
-    const parser = parse(`keys {
-      value = $input.my_object
-      description = "compressed data"
-    } as $keys`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectKeysFn requires a value", () => {
-    const parser = parse(`keys {
-      description = "compressed data"
-    } as $keys`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/functions/object/objectValuesFn.spec.js

@@ -1,44 +0,0 @@
-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.objectValuesFn();
-  return parser;
-}
-
-describe("objectValuesFn", () => {
-  it("objectValuesFn accepts a value", () => {
-    const parser = parse(`values {
-      value = $my_object
-    } as $values`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectValuesFn can be disabled", () => {
-    const parser = parse(`values {
-      value = $my_object
-      disabled = true
-    } as $values`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectValuesFn accept a description", () => {
-    const parser = parse(`values {
-      value = $my_object
-      description = "compressed data"
-    } as $values`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectValuesFn requires a value", () => {
-    const parser = parse(`values {
-      description = "compressed data"
-    } as $values`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});