@xano/xanoscript-language-server 11.12.1 → 11.12.3

package/parser/functions/redis/redisCountFn.spec.js

@@ -1,58 +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.redisCountFn();
-  return parser;
-}
-
-describe("redis.count", () => {
-  it("Check count is taking required params", () => {
-    const parser = parse(`count {
-      key = "list"
-    } as $x9`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check count is missing required params", () => {
-    const parser = parse(`count {} as $x9`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check count has duplicate attributes", () => {
-    const parser = parse(`count {
-      key = "list"
-      key = "another_list"
-    } as $x9`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check count has illegal attributes", () => {
-    const parser = parse(`count {
-      key = "list"
-      illegalAttr = "value"
-    } as $x9`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check count is having description attribute", () => {
-    const parser = parse(`count {
-      key = "list"
-      description = "A description"
-    } as $x9`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check count is having disabled attribute", () => {
-    const parser = parse(`count {
-      key = "list"
-      disabled = true
-    } as $x9`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/redis/redisDecrFn.spec.js

@@ -1,47 +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.redisDecrFn();
-  return parser;
-}
-
-describe("redis.decr", () => {
-  it("Check decr is taking required params", () => {
-    const parser = parse(`decr {
-      key = "counter"
-      by = 1
-    } as $x4`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check decr is missing required params", () => {
-    const parser = parse(`decr {
-      key = "counter"
-    } as $x4`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check decr has duplicate attributes", () => {
-    const parser = parse(`decr {
-      key = "counter"
-      key = "another_counter"
-      by = 1
-    } as $x4`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check decr has illegal attributes", () => {
-    const parser = parse(`decr {
-      key = "counter"
-      by = 1
-      illegalAttr = "value"
-    } as $x4`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/functions/redis/redisDelFn.spec.js

@@ -1,58 +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.redisDelFn();
-  return parser;
-}
-
-describe("redis.del", () => {
-  it("Check del is taking required params", () => {
-    const parser = parse(`del {
-      key = "name"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check del is missing required params", () => {
-    const parser = parse(`del {}`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check del has duplicate attributes", () => {
-    const parser = parse(`del {
-      key = "name"
-      key = "another_name"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check del has illegal attributes", () => {
-    const parser = parse(`del {
-      key = "name"
-      illegalAttr = "value"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check del is taking description and disabled attributes", () => {
-    const parser = parse(`del {
-      key = "name"
-      description = "This is a test description"
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check del doesn't return value as variable", () => {
-    const parser = parse(`del {
-      key = "name"
-    } as $deleted`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/functions/redis/redisGetFn.spec.js

@@ -1,67 +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.redisGetFn();
-  return parser;
-}
-
-describe("redis.get", () => {
-  it("Check get is taking required params", () => {
-    const parser = parse(`get {
-      key = "name"
-    } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check get is missing required params", () => {
-    const parser = parse(`get {} as $x1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check get has duplicate attributes", () => {
-    const parser = parse(`get {
-      key = "name"
-      key = "another_name"
-    } as $x1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check get has illegal attributes", () => {
-    const parser = parse(`get {
-      key = "name"
-      illegalAttr = "value"
-    } as $x1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check get with optional description attribute", () => {
-    const parser = parse(`get {
-      key = "name"
-      description = "This is a description"
-    } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check get with optional disabled attribute", () => {
-    const parser = parse(`get {
-      key = "name"
-      disabled = true
-    } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check get with both optional attributes", () => {
-    const parser = parse(`get {
-      key = "name"
-      description = "This is a description"
-      disabled = true
-    } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/redis/redisHasFn.spec.js

@@ -1,58 +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.redisHasFn();
-  return parser;
-}
-
-describe("redis.has", () => {
-  it("Check has is taking required params", () => {
-    const parser = parse(`has {
-      key = "name"
-    } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check has is missing required params", () => {
-    const parser = parse(`has {} as $x1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check has has duplicate attributes", () => {
-    const parser = parse(`has {
-      key = "name"
-      key = "another_name"
-    } as $x1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check has has illegal attributes", () => {
-    const parser = parse(`has {
-      key = "name"
-      illegalAttr = "value"
-    } as $x1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check has is missing description attribute", () => {
-    const parser = parse(`has {
-      key = "name"
-      description = "A description"
-    } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check has is missing disabled attribute", () => {
-    const parser = parse(`has {
-      key = "name"
-      disabled = true
-    } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/redis/redisIncrFn.spec.js

@@ -1,74 +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.redisIncrFn();
-  return parser;
-}
-
-describe("redis.incr", () => {
-  it("Check incr is taking required params", () => {
-    const parser = parse(`incr {
-      key = "counter"
-      by = 1
-    } as $x3`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check incr is missing required params", () => {
-    const parser = parse(`incr {
-    } as $x3`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check incr has duplicate attributes", () => {
-    const parser = parse(`incr {
-      key = "counter"
-      key = "another_counter"
-      by = 1
-    } as $x3`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check incr has illegal attributes", () => {
-    const parser = parse(`incr {
-      key = "counter"
-      by = 1
-      illegalAttr = "value"
-    } as $x3`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check incr with optional description attribute", () => {
-    const parser = parse(`incr {
-      key = "counter"
-      by = 1
-      description = "Increment counter"
-    } as $x3`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check incr with optional disabled attribute", () => {
-    const parser = parse(`incr {
-      key = "counter"
-      by = 1
-      disabled = true
-    } as $x3`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check incr with both optional attributes", () => {
-    const parser = parse(`incr {
-      key = "counter"
-      by = 1
-      description = "Increment counter"
-      disabled = false
-    } as $x3`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/redis/redisKeysFn.spec.js

@@ -1,67 +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.redisKeysFn();
-  return parser;
-}
-
-describe("redis.keys", () => {
-  it("Check keys is taking required params", () => {
-    const parser = parse(`keys {
-            search = "user*"
-        } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check keys is missing required params", () => {
-    const parser = parse(`keys {} as $x1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check keys has duplicate attributes", () => {
-    const parser = parse(`keys {
-            search = "user*"
-            search = "name"
-        } as $x1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check keys has illegal attributes", () => {
-    const parser = parse(`keys {
-            search = "user*"
-            illegalAttr = "value"
-        } as $x1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check keys with optional description attribute", () => {
-    const parser = parse(`keys {
-            search = "user*"
-            description = "This is a description"
-        } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check keys with optional disabled attribute", () => {
-    const parser = parse(`keys {
-            search = "user*"
-            disabled = true
-        } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check keys with both optional attributes", () => {
-    const parser = parse(`keys {
-            search = "user*"
-            description = "This is a description"
-            disabled = true
-        } as $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/redis/redisPopFn.spec.js

@@ -1,75 +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.redisPopFn();
-  return parser;
-}
-
-describe("redis.pop", () => {
-  it("Check pop is taking required params", () => {
-    const parser = parse(`pop {
-      key = "list"
-    } as $x7`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check pop is missing required params", () => {
-    const parser = parse(`pop {} as $x7`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check pop has duplicate attributes", () => {
-    const parser = parse(`pop {
-      key = "list"
-      key = "another_list"
-    } as $x7`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check pop has illegal attributes", () => {
-    const parser = parse(`pop {
-      key = "list"
-      illegalAttr = "value"
-    } as $x7`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check pop with optional description attribute", () => {
-    const parser = parse(`pop {
-      key = "list"
-      description = "This is a description"
-    } as $x7`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check pop with optional disabled attribute", () => {
-    const parser = parse(`pop {
-      key = "list"
-      disabled = true
-    } as $x7`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check pop with both optional attributes", () => {
-    const parser = parse(`pop {
-      key = "list"
-      description = "This is a description"
-      disabled = true
-    } as $x7`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("pop accepts an optional count attribute", () => {
-    const parser = parse(`pop {
-      key = "list"
-      count = 5
-    } as $x7`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/redis/redisPushFn.spec.js

@@ -1,71 +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.redisPushFn();
-  return parser;
-}
-
-describe("redis.push", () => {
-  it("Check push is taking required params", () => {
-    const parser = parse(`push {
-      key = "list"
-      value = "second"
-    } as $x5`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check push is missing required params", () => {
-    const parser = parse(`push {} as $x5`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check push has duplicate attributes", () => {
-    const parser = parse(`push {
-      key = "list"
-      key = "another_list"
-    } as $x5`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check push has illegal attributes", () => {
-    const parser = parse(`push {
-      key = "list"
-      illegalAttr = "value"
-    } as $x5`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check push with optional description attribute", () => {
-    const parser = parse(`push {
-      key = "list"
-      value = "second"
-      description = "This is a description"
-    } as $x5`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check push with optional disabled attribute", () => {
-    const parser = parse(`push {
-      key = "list"
-      value = "second"
-      disabled = true
-    } as $x5`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check push with both optional attributes", () => {
-    const parser = parse(`push {
-      key = "list"
-      value = "second"
-      description = "This is a description"
-      disabled = true
-    } as $x5`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/redis/redisRangeFn.spec.js

@@ -1,80 +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.redisRangeFn();
-  return parser;
-}
-
-describe("redis.range", () => {
-  it("Check range is taking required params", () => {
-    const parser = parse(`range {
-      key = "list"
-      start = 0
-      stop = 1
-    } as $x10`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check range is missing required params", () => {
-    const parser = parse(`range {
-      key = "list"
-    } as $x10`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check range has duplicate attributes", () => {
-    const parser = parse(`range {
-      key = "list"
-      start = 0
-      start = 1
-    } as $x10`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check range has illegal attributes", () => {
-    const parser = parse(`range {
-      key = "list"
-      start = 0
-      stop = 1
-      illegalAttr = "value"
-    } as $x10`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("Check range with optional description attribute", () => {
-    const parser = parse(`range {
-      key = "list"
-      start = 0
-      stop = 1
-      description = "This is a description"
-    } as $x10`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check range with optional disabled attribute", () => {
-    const parser = parse(`range {
-      key = "list"
-      start = 0
-      stop = 1
-      disabled = true
-    } as $x10`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("Check range with both optional attributes", () => {
-    const parser = parse(`range {
-      key = "list"
-      start = 0
-      stop = 1
-      description = "This is a description"
-      disabled = true
-    } as $x10`);
-    expect(parser.errors).to.be.empty;
-  });
-});