unit/influx.test.js

import { expect } from "chai";
import * as sinon from "sinon";
import { FieldType, InfluxDB, toNanoDate } from "../../src";
import { dbFixture } from "./helpers";
describe("influxdb", () => {
    describe("constructor", () => {
        it("uses default options", () => {
            expect(new InfluxDB()._options).to.deep.equal({
                username: "root",
                password: "root",
                database: null,
                pool: undefined,
                schema: [],
                hosts: [
                    {
                        host: "127.0.0.1",
                        port: 8086,
                        path: "",
                        protocol: "http",
                        options: undefined,
                    },
                ],
            });
        });
        it("parses dsns", () => {
            expect(new InfluxDB("https://connor:password@192.168.0.1:1337/foo")
                ._options).to.deep.equal({
                username: "connor",
                password: "password",
                database: "foo",
                pool: undefined,
                schema: [],
                hosts: [
                    {
                        host: "192.168.0.1",
                        port: 1337,
                        path: "",
                        protocol: "https",
                        options: undefined,
                    },
                ],
            });
        });
        it("parses single configs", () => {
            expect(new InfluxDB({ database: "foo", host: "192.168.0.1" })._options).to.deep.equal({
                username: "root",
                password: "root",
                database: "foo",
                pool: undefined,
                schema: [],
                hosts: [
                    {
                        host: "192.168.0.1",
                        port: 8086,
                        path: "",
                        protocol: "http",
                        options: undefined,
                    },
                ],
            });
        });
        it("parses cluster configs", () => {
            expect(new InfluxDB({
                database: "foo",
                hosts: [{ host: "192.168.0.1", options: { ca: null } }],
            })._options).to.deep.equal({
                username: "root",
                password: "root",
                database: "foo",
                schema: [],
                hosts: [
                    {
                        host: "192.168.0.1",
                        port: 8086,
                        path: "",
                        protocol: "http",
                        options: { ca: null },
                    },
                ],
            });
        });
        it("parses parses schema", () => {
            let client = new InfluxDB({
                schema: [
                    {
                        database: "my_db",
                        measurement: "my_measurement",
                        fields: {},
                        tags: ["my_tag"],
                    },
                ],
                hosts: [{ host: "192.168.0.1", options: undefined }],
            });
            expect(client._schema.my_db.my_measurement).to.not.be.undefined;
            client = new InfluxDB({
                schema: [
                    {
                        measurement: "my_measurement",
                        fields: {},
                        tags: ["my_tag"],
                    },
                ],
                database: "my_db",
                hosts: [{ host: "192.168.0.1" }],
            });
            expect(client._schema.my_db.my_measurement).to.not.be.undefined;
            expect(() => {
                new InfluxDB({
                    // eslint-disable-line no-new
                    schema: [
                        {
                            measurement: "my_measurement",
                            fields: {},
                            tags: ["my_tag"],
                        },
                    ],
                    hosts: [{ host: "192.168.0.1" }],
                });
            }).to.throw(/no default database is provided/);
        });
    });
    describe("methods", () => {
        let influx;
        let pool;
        const expectations = [];
        beforeEach(() => {
            influx = new InfluxDB({
                hosts: [],
                schema: [
                    {
                        database: "my_db",
                        measurement: "my_schemed_measure",
                        tags: ["my_tag"],
                        fields: {
                            int: FieldType.INTEGER,
                            float: FieldType.FLOAT,
                            string: FieldType.STRING,
                            bool: FieldType.BOOLEAN,
                        },
                    },
                ],
            });
            pool = influx._pool;
            sinon.stub(pool, "discard");
            sinon.stub(pool, "json");
            sinon.stub(pool, "text");
        });
        afterEach(() => {
            while (expectations.length) {
                expectations.pop()();
            }
        });
        const setDefaultDB = (db) => {
            influx._options.database = db;
        };
        const expectQuery = (method, options, httpMethod = "POST", yields = { results: [{}] }) => {
            if (typeof options === "string") {
                options = { q: options };
            }
            pool[method].returns(Promise.resolve(yields));
            expectations.push(() => {
                expect(pool[method]).to.have.been.calledWith({
                    method: httpMethod,
                    path: "/query",
                    query: Object.assign({ u: "root", p: "root" }, options),
                });
            });
        };
        const expectWrite = (body, options) => {
            if (typeof options === "string") {
                options = { q: options };
            }
            pool.discard.returns(Promise.resolve());
            expectations.push(() => {
                expect(pool.discard).to.have.been.calledWith({
                    method: "POST",
                    path: "/write",
                    body,
                    query: Object.assign({ u: "root", p: "root" }, options),
                });
            });
        };
        it(".createDatabase()", () => {
            expectQuery("json", 'create database "foo"');
            influx.createDatabase("foo");
            expectQuery("json", 'create database "f\\"oo"');
            influx.createDatabase('f"oo');
        });
        it(".dropDatabase()", () => {
            expectQuery("json", 'drop database "foo"');
            influx.dropDatabase("foo");
            expectQuery("json", 'drop database "f\\"oo"');
            influx.dropDatabase('f"oo');
        });
        it(".dropShard()", () => {
            expectQuery("json", "drop shard 1");
            influx.dropShard(1);
        });
        it(".getDatabaseNames()", () => {
            expectQuery("json", "show databases", "GET", dbFixture("showDatabases"));
            return influx.getDatabaseNames().then((names) => {
                expect(names).to.deep.equal(["_internal", "influx_test_gen"]);
            });
        });
        it(".getMeasurements()", () => {
            setDefaultDB("mydb");
            expectQuery("json", {
                db: "mydb",
                q: "show measurements",
            }, "GET", dbFixture("showMeasurements"));
            return influx.getMeasurements().then((names) => {
                expect(names).to.deep.equal(["series_0", "series_1", "series_2"]);
            });
        });
        it(".getSeries() from all", () => {
            setDefaultDB("mydb");
            expectQuery("json", {
                db: "mydb",
                q: "show series",
            }, "GET", dbFixture("showSeries"));
            return influx.getSeries().then((names) => {
                expect(names).to.deep.equal([
                    "series_0,my_tag=0",
                    "series_0,my_tag=1",
                    "series_0,my_tag=5",
                    "series_0,my_tag=6",
                    "series_0,my_tag=7",
                    "series_0,my_tag=8",
                    "series_0,my_tag=9",
                    "series_1,my_tag=0",
                    "series_1,my_tag=2",
                    "series_1,my_tag=4",
                    "series_1,my_tag=5",
                    "series_1,my_tag=6",
                    "series_1,my_tag=7",
                    "series_1,my_tag=8",
                    "series_1,my_tag=9",
                    "series_2,my_tag=1",
                    "series_2,my_tag=2",
                    "series_2,my_tag=3",
                    "series_2,my_tag=4",
                    "series_2,my_tag=5",
                    "series_2,my_tag=6",
                    "series_2,my_tag=7",
                    "series_2,my_tag=8",
                    "series_2,my_tag=9",
                ]);
            });
        });
        it(".getSeries() from single", () => {
            expectQuery("json", {
                db: "mydb",
                q: 'show series from "measure_1"',
            }, "GET", dbFixture("showSeriesFromOne"));
            return influx
                .getSeries({
                database: "mydb",
                measurement: "measure_1",
            })
                .then((names) => {
                expect(names).to.deep.equal([
                    "series_1,my_tag=0",
                    "series_1,my_tag=2",
                    "series_1,my_tag=4",
                    "series_1,my_tag=5",
                    "series_1,my_tag=6",
                    "series_1,my_tag=7",
                    "series_1,my_tag=8",
                    "series_1,my_tag=9",
                ]);
            });
        });
        it(".dropMeasurement()", () => {
            expectQuery("json", {
                db: "my_db",
                q: 'drop measurement "series_1"',
            });
            return influx.dropMeasurement("series_1", "my_db");
        });
        describe(".dropSeries()", () => {
            beforeEach(() => setDefaultDB("my_db"));
            it("drops with only from clause by string", () => {
                expectQuery("json", { db: "my_db", q: 'drop series from "series_0"' });
                influx.dropSeries({ measurement: '"series_0"' });
            });
            it("drops with only from clause by builder", () => {
                expectQuery("json", { db: "my_db", q: 'drop series from "series_0"' });
                influx.dropSeries({ measurement: (m) => m.name("series_0") });
            });
            it("drops with only where clause by string", () => {
                expectQuery("json", {
                    db: "my_db",
                    q: 'drop series where "my_tag" = 1',
                });
                influx.dropSeries({ where: '"my_tag" = 1' });
            });
            it("drops with only where clause by builder", () => {
                expectQuery("json", {
                    db: "my_db",
                    q: 'drop series where "my_tag" = 1',
                });
                influx.dropSeries({ where: (e) => e.tag("my_tag").equals.value(1) });
            });
            it("drops with both", () => {
                expectQuery("json", {
                    db: "my_db",
                    q: 'drop series from "series_0" where "my_tag" = 1',
                });
                influx.dropSeries({
                    measurement: (m) => m.name("series_0"),
                    where: (e) => e.tag("my_tag").equals.value(1),
                });
            });
        });
        it(".getUsers()", () => {
            expectQuery("json", "show users", "GET", dbFixture("showUsers"));
            return influx.getUsers().then((names) => {
                expect(names.slice()).to.deep.equal([
                    { user: "john", admin: true },
                    { user: "steve", admin: false },
                ]);
            });
        });
        describe(".createUser()", () => {
            it("works with admin specified == true", () => {
                expectQuery("json", "create user \"con\\\"nor\" with password 'pa55\\'word' with all privileges");
                return influx.createUser('con"nor', "pa55'word", true);
            });
            it("works with admin specified == false", () => {
                expectQuery("json", "create user \"con\\\"nor\" with password 'pa55\\'word'");
                return influx.createUser('con"nor', "pa55'word", false);
            });
            it("works with admin unspecified", () => {
                expectQuery("json", "create user \"con\\\"nor\" with password 'pa55\\'word'");
                return influx.createUser('con"nor', "pa55'word");
            });
        });
        describe(".grantPrivilege()", () => {
            it("queries correctly", () => {
                expectQuery("json", 'grant READ on "my_\\"_db" to "con\\"nor"');
                return influx.grantPrivilege('con"nor', "READ", 'my_"_db');
            });
            it("throws if DB unspecified", () => {
                expect(() => influx.grantPrivilege('con"nor', "READ")).to.throw(/default database/);
            });
            it("fills in default DB", () => {
                setDefaultDB('my_\\"_db');
                expectQuery("json", 'grant READ on "my_\\"_db" to "con\\"nor"');
                return influx.grantPrivilege('con"nor', "READ", 'my_"_db');
            });
        });
        describe(".revokePrivilege()", () => {
            it("queries correctly", () => {
                expectQuery("json", 'revoke READ on "my_\\"_db" from "con\\"nor"');
                return influx.revokePrivilege('con"nor', "READ", 'my_"_db');
            });
            it("throws if DB unspecified", () => {
                expect(() => influx.revokePrivilege('con"nor', "READ")).to.throw(/default database/);
            });
            it("fills in default DB", () => {
                setDefaultDB('my_\\"_db');
                expectQuery("json", 'revoke READ on "my_\\"_db" from "con\\"nor"');
                return influx.revokePrivilege('con"nor', "READ", 'my_"_db');
            });
        });
        it(".grantAdminPrivilege()", () => {
            expectQuery("json", 'grant all to "con\\"nor"');
            return influx.grantAdminPrivilege('con"nor');
        });
        it(".revokeAdminPrivilege()", () => {
            expectQuery("json", 'revoke all from "con\\"nor"');
            return influx.revokeAdminPrivilege('con"nor');
        });
        it(".dropUser()", () => {
            expectQuery("json", 'drop user "con\\"nor"');
            return influx.dropUser('con"nor');
        });
        describe(".createContinuousQuery()", () => {
            it("queries correctly no resample", () => {
                expectQuery("json", 'create continuous query "my_\\"q" on "my_\\"_db"  begin foo end');
                return influx.createContinuousQuery('my_"q', "foo", 'my_"_db');
            });
            it("queries correctly with resample", () => {
                expectQuery("json", 'create continuous query "my_\\"q" on "my_\\"_db" resample for 4m begin foo end');
                return influx.createContinuousQuery('my_"q', "foo", 'my_"_db', "resample for 4m");
            });
            it("throws if DB unspecified", () => {
                expect(() => influx.createContinuousQuery('my_"q', "foo")).to.throw(/default database/);
            });
            it("fills in default DB", () => {
                setDefaultDB('my_"_db');
                expectQuery("json", 'create continuous query "my_\\"q" on "my_\\"_db"  begin foo end');
                return influx.createContinuousQuery('my_"q', "foo");
            });
        });
        describe(".dropContinuousQuery()", () => {
            it("queries correctly", () => {
                expectQuery("json", 'drop continuous query "my_\\"q" on "my_\\"_db"');
                return influx.dropContinuousQuery('my_"q', 'my_"_db');
            });
            it("throws if DB unspecified", () => {
                expect(() => influx.dropContinuousQuery('my_"q')).to.throw(/default database/);
            });
            it("fills in default DB", () => {
                setDefaultDB('my_"_db');
                expectQuery("json", 'drop continuous query "my_\\"q" on "my_\\"_db"');
                return influx.dropContinuousQuery('my_"q');
            });
        });
        describe(".showContinousQueries()", () => {
            it("queries correctly", () => {
                expectQuery("json", { q: "show continuous queries", db: "my_db" }, "GET");
                return influx.showContinousQueries("my_db");
            });
            it("throws if DB unspecified", () => {
                expect(() => influx.showContinousQueries()).to.throw(/default database/);
            });
            it("fills in default DB", () => {
                setDefaultDB("my_db");
                expectQuery("json", { q: "show continuous queries", db: "my_db" }, "GET");
                return influx.showContinousQueries();
            });
        });
        describe(".writePoints()", () => {
            it("writes with all options specified without a schema", () => {
                expectWrite("mymeas,my_tag=1 myfield=90 1463683075", {
                    precision: "s",
                    rp: "1day",
                    db: "my_db",
                });
                return influx.writePoints([
                    {
                        measurement: "mymeas",
                        tags: { my_tag: "1" },
                        fields: { myfield: 90 },
                        timestamp: new Date(1463683075000),
                    },
                ], {
                    database: "my_db",
                    precision: "s",
                    retentionPolicy: "1day",
                });
            });
            it("writes using default options without a schema", () => {
                setDefaultDB("my_db");
                expectWrite("mymeas,my_tag=1 myfield=90 1463683075000000000", {
                    precision: "n",
                    rp: undefined,
                    db: "my_db",
                });
                return influx.writePoints([
                    {
                        measurement: "mymeas",
                        tags: { my_tag: "1" },
                        fields: { myfield: 90 },
                        timestamp: new Date(1463683075000),
                    },
                ]);
            });
            it("uses a schema to coerce", () => {
                setDefaultDB("my_db");
                expectWrite("my_schemed_measure,my_tag=1 bool=T,float=43,int=42i", {
                    precision: "n",
                    rp: undefined,
                    db: "my_db",
                });
                return influx.writePoints([
                    {
                        measurement: "my_schemed_measure",
                        tags: { my_tag: "1" },
                        fields: {
                            int: 42,
                            float: 43,
                            bool: true,
                        },
                    },
                ]);
            });
            it("can accept a schema at runtime", () => {
                setDefaultDB("my_db");
                expectWrite("my_runtime_schema_measure,my_tag=1 bool=T,float=43,int=42i", {
                    precision: "n",
                    rp: undefined,
                    db: "my_db",
                });
                influx.addSchema({
                    database: "my_db",
                    measurement: "my_runtime_schema_measure",
                    fields: {
                        bool: FieldType.BOOLEAN,
                        float: FieldType.FLOAT,
                        int: FieldType.INTEGER,
                    },
                    tags: ["my_tag"],
                });
                return influx.writePoints([
                    {
                        measurement: "my_runtime_schema_measure",
                        tags: { my_tag: "1" },
                        fields: {
                            int: 42,
                            float: 43,
                            bool: true,
                        },
                    },
                ]);
            });
            it("handles lack of tags", () => {
                expectWrite("mymeas myfield=90", {
                    precision: "n",
                    rp: undefined,
                    db: "my_db",
                });
                return influx.writePoints([
                    {
                        measurement: "mymeas",
                        fields: { myfield: 90 },
                    },
                ], { database: "my_db" });
            });
            it("handles lack of fields", () => {
                expectWrite("mymeas,my_tag=90", {
                    precision: "n",
                    rp: undefined,
                    db: "my_db",
                });
                return influx.writePoints([
                    {
                        measurement: "mymeas",
                        tags: { my_tag: "90" },
                    },
                ], { database: "my_db" });
            });
            it("handles multiple tags", () => {
                expectWrite("mymeas,my_tag1=90,my_tag2=45", {
                    precision: "n",
                    rp: undefined,
                    db: "my_db",
                });
                return influx.writePoints([
                    {
                        measurement: "mymeas",
                        tags: { my_tag1: "90", my_tag2: "45" },
                    },
                ], { database: "my_db" });
            });
            it("writes with the .writeMeasurement method", () => {
                setDefaultDB("my_db");
                expectWrite("mymeas,my_tag=1 myfield=90 1463683075000000000", {
                    precision: "n",
                    rp: undefined,
                    db: "my_db",
                });
                return influx.writeMeasurement("mymeas", [
                    {
                        tags: { my_tag: "1" },
                        fields: { myfield: 90 },
                        timestamp: new Date(1463683075000),
                    },
                ]);
            });
            it("accepts nanoseconds (as ms)", () => {
                setDefaultDB("my_db");
                expectWrite("mymeas,my_tag=1 myfield=90 1463683075000000000", {
                    precision: "n",
                    rp: undefined,
                    db: "my_db",
                });
                return influx.writeMeasurement("mymeas", [
                    {
                        tags: { my_tag: "1" },
                        fields: { myfield: 90 },
                        timestamp: toNanoDate("1463683075000000000"),
                    },
                ]);
            });
            it("accepts timestamp overriding", () => {
                setDefaultDB("my_db");
                expectWrite("mymeas,my_tag=1 myfield=90 1463683075000", {
                    precision: "ms",
                    rp: undefined,
                    db: "my_db",
                });
                return influx.writeMeasurement("mymeas", [
                    {
                        tags: { my_tag: "1" },
                        fields: { myfield: 90 },
                        timestamp: toNanoDate("1463683075000000000"),
                    },
                ], { precision: "ms" });
            });
        });
        describe(".parsePoint()", () => {
            it("parses a minimal valid point with default options", () => {
                setDefaultDB("my_db");
                let point = {
                    measurement: "mymeas",
                    fields: { myfield: 90 },
                };
                let parsedPoint = influx.parsePoint(point);
                expect(parsedPoint.measurement).to.equal(point.measurement);
                expect(parsedPoint.fields).to.equal(point.fields);
                expect(parsedPoint.tags).to.deep.equals({});
                expect(parsedPoint.fieldsPairs).to.deep.equals([["myfield", "90"]]);
                expect(parsedPoint.tagsNames).to.deep.equals([]);
                expect(parsedPoint.castedTimestamp).to.be.undefined;
            });
            it("parses a point with fields, tags, and timestamp", () => {
                setDefaultDB("my_db");
                let date = new Date();
                let point = {
                    measurement: "mymeas",
                    fields: { myfield: 90 },
                    tags: { my_tag: "2" },
                    timestamp: date,
                };
                let parsedPoint = influx.parsePoint(point);
                expect(parsedPoint.measurement).to.equal(point.measurement);
                expect(parsedPoint.fields).to.equal(point.fields);
                expect(parsedPoint.tags).to.equals(point.tags);
                expect(parsedPoint.fieldsPairs).to.deep.equals([["myfield", "90"]]);
                expect(parsedPoint.tagsNames).to.deep.equals(["my_tag"]);
                expect(parsedPoint.castedTimestamp).not.to.be.undefined;
            });
            it("accepts custom precision option", () => {
                setDefaultDB("my_db");
                let date = new Date();
                let point = {
                    measurement: "mymeas",
                    fields: { myfield: 90 },
                    timestamp: date,
                };
                let parsedPoint = influx.parsePoint(point, { precision: "ms" });
                expect(parsedPoint.castedTimestamp).to.equal(date.getTime().toString());
            });
            it("accepts custom database option", () => {
                let date = new Date();
                let point = {
                    measurement: "mymeas",
                    fields: { myfield: 90 },
                    timestamp: date,
                };
                let parsedPoint = influx.parsePoint(point, { database: "my_db" });
                expect(parsedPoint).to.exist;
            });
            it("uses a schema to coerce", () => {
                setDefaultDB("my_db");
                let date = new Date();
                let point = {
                    measurement: "my_schemed_measure",
                    fields: { bool: true, float: 43, int: 42 },
                    tags: { my_tag: "2" },
                    timestamp: date,
                };
                let parsedPoint = influx.parsePoint(point);
                expect(parsedPoint.measurement).to.equal(point.measurement);
                expect(parsedPoint.fields).to.equal(point.fields);
                expect(parsedPoint.tags).to.equals(point.tags);
                expect(parsedPoint.fieldsPairs).to.deep.equals([
                    ["bool", "T"],
                    ["float", "43"],
                    ["int", "42i"],
                ]);
                expect(parsedPoint.tagsNames).to.deep.equals(["my_tag"]);
                expect(parsedPoint.castedTimestamp).not.to.be.undefined;
            });
            it("should throw an error if extraneous tags are given", () => {
                setDefaultDB("my_db");
                expect(() => {
                    let point = {
                        measurement: "my_schemed_measure",
                        tags: { not_a_tag: "1" },
                    };
                    influx.parsePoint(point);
                }).to.throw(/extraneous tags/i);
            });
            it("should throw an error if extraneous fields are given", () => {
                setDefaultDB("my_db");
                expect(() => {
                    let point = {
                        measurement: "my_schemed_measure",
                        fields: { not_a_field: "1" },
                    };
                    influx.parsePoint(point);
                }).to.throw(/extraneous fields/i);
            });
            it("should throw an error if invalid value for field type given", () => {
                setDefaultDB("my_db");
                expect(() => {
                    let point = {
                        measurement: "my_schemed_measure",
                        fields: { bool: "lol, not a bool" },
                    };
                    influx.parsePoint(point);
                }).to.throw(/expected bool/i);
            });
        });
        describe(".query", () => {
            beforeEach(() => setDefaultDB("my_db"));
            it("runs raw queries", () => {
                expectQuery("json", {
                    q: "select * from series_0",
                    epoch: undefined,
                    rp: undefined,
                    db: "my_db",
                    params: "{}",
                }, "GET", dbFixture("selectFromOne"));
                return influx.queryRaw("select * from series_0").then((res) => {
                    expect(res).to.deep.equal(dbFixture("selectFromOne"));
                });
            });
            it("parses query output", () => {
                expectQuery("json", {
                    q: "select * from series_0",
                    epoch: undefined,
                    rp: undefined,
                    db: "my_db",
                    params: "{}",
                }, "GET", dbFixture("selectFromOne"));
                return influx.query("select * from series_0").then((res) => {
                    expect(res.slice()).to.deep.equal([
                        {
                            time: new Date("2016-09-29T02:19:09.38Z"),
                            my_tag: "1",
                            my_value: 67,
                        },
                        {
                            time: new Date("2016-09-29T02:19:09.379Z"),
                            my_tag: "1",
                            my_value: 32,
                        },
                    ]);
                });
            });
            it("selects from multiple", () => {
                expectQuery("json", {
                    q: "select * from series_0;select * from series_1",
                    epoch: undefined,
                    rp: undefined,
                    db: "my_db",
                    params: "{}",
                }, "GET", dbFixture("selectFromOne"));
                return influx.query([
                    "select * from series_0",
                    "select * from series_1",
                ]);
            });
            it("passes in options", () => {
                expectQuery("json", {
                    q: "select * from series_0",
                    epoch: "ms",
                    rp: "asdf",
                    db: "my_db",
                    params: "{}",
                }, "GET", dbFixture("selectFromOne"));
                return influx.query(["select * from series_0"], {
                    precision: "ms",
                    retentionPolicy: "asdf",
                });
            });
            it("rewrites nanosecond precisions", () => {
                expectQuery("json", {
                    q: "select * from series_0",
                    epoch: undefined,
                    rp: "asdf",
                    db: "my_db",
                    params: "{}",
                }, "GET", dbFixture("selectFromOne"));
                return influx.query(["select * from series_0"], {
                    precision: "n",
                    retentionPolicy: "asdf",
                });
            });
            it("uses placeholders", () => {
                expectQuery("json", {
                    q: "select * from series_0 WHERE time > now() - $<since> AND value >= $<minimumValue>",
                    epoch: undefined,
                    rp: "asdf",
                    db: "my_db",
                    params: '{"since":"10s","minimumValue":12}',
                }, "GET", dbFixture("selectFromOne"));
                return influx.query([
                    "select * from series_0 WHERE time > now() - $<since> AND value >= $<minimumValue>",
                ], {
                    precision: "n",
                    retentionPolicy: "asdf",
                    placeholders: {
                        since: "10s",
                        minimumValue: 12,
                    },
                });
            });
        });
        describe(".createRetentionPolicy", () => {
            beforeEach(() => setDefaultDB("my_db"));
            it("creates non-default policies", () => {
                expectQuery("json", 'create retention policy "7d\\"" on "test" duration 7d replication 1');
                return influx.createRetentionPolicy('7d"', {
                    database: "test",
                    duration: "7d",
                    replication: 1,
                });
            });
            it("creates default policies", () => {
                expectQuery("json", 'create retention policy "7d\\"" on "my_db" duration 7d replication 1 default');
                return influx.createRetentionPolicy('7d"', {
                    duration: "7d",
                    replication: 1,
                    isDefault: true,
                });
            });
        });
        describe(".alterRetentionPolicy", () => {
            beforeEach(() => setDefaultDB("my_db"));
            it("creates non-default policies", () => {
                expectQuery("json", 'alter retention policy "7d\\"" on "test" duration 7d replication 1');
                return influx.alterRetentionPolicy('7d"', {
                    database: "test",
                    duration: "7d",
                    replication: 1,
                });
            });
            it("creates default policies", () => {
                expectQuery("json", 'alter retention policy "7d\\"" on "my_db" duration 7d replication 1 default');
                return influx.alterRetentionPolicy('7d"', {
                    duration: "7d",
                    replication: 1,
                    isDefault: true,
                });
            });
        });
        it("drops retention policies", () => {
            setDefaultDB("my_db");
            expectQuery("json", 'drop retention policy "7d\\"" on "my_db"');
            return influx.dropRetentionPolicy('7d"');
        });
        it("shows retention policies", () => {
            const data = dbFixture("showRetentionPolicies");
            expectQuery("json", 'show retention policies on "my\\"db"', "GET", data);
            influx.showRetentionPolicies('my"db');
            setDefaultDB("my_db");
            expectQuery("json", 'show retention policies on "my_db"', "GET", data);
            return influx.showRetentionPolicies().then((res) => {
                expect(res.slice()).to.deep.equal([
                    {
                        name: "autogen",
                        duration: "0s",
                        shardGroupDuration: "168h0m0s",
                        replicaN: 1,
                        default: true,
                    },
                    {
                        name: "7d",
                        duration: "168h0m0s",
                        shardGroupDuration: "24h0m0s",
                        replicaN: 1,
                        default: false,
                    },
                ]);
            });
        });
        it("shows shards", () => {
            setDefaultDB("_internal");
            expectQuery("json", "show shards ", "GET", dbFixture("showShards"));
            return influx.showShards().then((res) => {
                expect(res.slice()).to.deep.equal([
                    {
                        id: 1,
                        database: "_internal",
                        retention_policy: "monitor",
                        shard_group: 1,
                        start_time: "2019-06-13T00:00:00Z",
                        end_time: "2019-06-14T00:00:00Z",
                        expiry_time: "2019-06-21T00:00:00Z",
                        owners: "",
                    },
                ]);
            });
        });
    });
});