@xano/xanoscript-language-server 11.12.2 → 12.0.0

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

@@ -1,63 +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.unitExpectToBeWithinFn();
-  return parser;
-}
-
-describe("unitExpectToBeWithinFn", () => {
-  it("unitExpectToBeWithinFn accepts args and a value argument", () => {
-    const parser = parse(`to_be_within ($response) {
-        min = 11
-        max = 13
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("unitExpectToBeWithinFn does not accept a non $response variable", () => {
-    const parser = parse(`to_equal ($foo) {
-      min = 11
-      max = 13
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("unitExpectToBeWithinFn does not accepts filters on value argument", () => {
-    const parser = parse(`to_be_within (($response|get:foo:"bar")
-        |first
-        |concat:bar
-      ) {
-      min = 11
-      max = 13
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("unitExpectToBeWithinFn does not accept a missing min", () => {
-    const parser = parse(`to_be_within ($response) {
-      max = 13
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("unitExpectToBeWithinFn does not accept a missing max", () => {
-    const parser = parse(`to_be_within ($response) {
-      min = 11
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("unitExpectToBeWithinFn 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/unitExpectToThrowFn.spec.js

@@ -1,40 +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.unitExpectToThrowFn();
-  return parser;
-}
-
-describe("unitExpectToThrowFn", () => {
-  it("unitExpectToThrowFn accepts data field", () => {
-    const parser = parse(`to_throw {
-      exception = "error"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("unitExpectToThrowFn accepts an empty payload", () => {
-    const parser = parse(`to_throw`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("unitExpectToThrowFn does not accept an operand", () => {
-    const parser = parse(`to_throw ($response.x) {
-      exception = "foo"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("unitExpectToThrowFn rejects an expression", () => {
-    const parser = parse(`to_throw {
-      exception = $var.exception
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

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

@@ -1,355 +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.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 to_equal accepts a $response subpath with $ prefix", () => {
-    const parser = parse(`to_equal ($response.$xyz) {
-      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 accepts an expression", () => {
-    const parser = parse(`to_equal ($response) {
-      value = \`12092834098240928304982039840923908402384.09823904823098402834\`  
-    }`);
-    expect(parser.errors).to.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.spec.js

@@ -1,69 +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.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.spec.js

@@ -1,70 +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.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.spec.js

@@ -1,56 +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.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;
-  });
-});