@quenty/influxdbclient 7.37.0 → 7.39.0

package/src/Server/Write/InfluxDBWriteAPI.spec.lua

@@ -0,0 +1,322 @@
+--!strict
+--[[
+	@class InfluxDBWriteAPI.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBPoint = require("InfluxDBPoint")
+local InfluxDBRequestHandlerMock = require("InfluxDBRequestHandlerMock")
+local InfluxDBWriteAPI = require("InfluxDBWriteAPI")
+local Jest = require("Jest")
+local Promise = require("Promise")
+local PromiseTestUtils = require("PromiseTestUtils")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+-- A fixed timestamp keeps the emitted line protocol (and therefore the request body) deterministic.
+local FIXED_TIMESTAMP = DateTime.fromUnixTimestampMillis(1600000000000)
+
+local function newPoint(): InfluxDBPoint.InfluxDBPoint
+	local point = InfluxDBPoint.new("temperature")
+	point:SetTimestamp(FIXED_TIMESTAMP)
+	point:AddFloatField("value", 23.5)
+	return point
+end
+
+-- Line protocol produced by newPoint() with default (empty) point settings.
+local POINT_LINE = "temperature value=23.5 1600000000000"
+
+-- Builds a write API wired to a request mock (so nothing hits the network) with a client config set.
+local function newConfiguredAPI(configOverrides: { [string]: any }?)
+	local mock = InfluxDBRequestHandlerMock.new()
+	local api = InfluxDBWriteAPI.new("my-org", "my-bucket", nil, mock.Handler)
+
+	local config = {
+		url = "https://example.com",
+		token = "my-token",
+	}
+	for key, value in configOverrides or ({} :: { [string]: any }) do
+		config[key] = value
+	end
+	api:SetClientConfig(config)
+
+	return api, mock
+end
+
+describe("InfluxDBWriteAPI.new", function()
+	it("should default the precision to ms in the write url", function()
+		local api, mock = newConfiguredAPI()
+		api:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(api:PromiseFlush())).toEqual(true)
+
+		expect((mock:GetLastRequest() :: any).Url).toEqual(
+			"https://example.com/api/v2/write?org=my-org&bucket=my-bucket&precision=ms"
+		)
+
+		api:Destroy()
+	end)
+
+	it("should use a provided precision in the write url", function()
+		local mock = InfluxDBRequestHandlerMock.new()
+		local api = InfluxDBWriteAPI.new("my-org", "my-bucket", "ns", mock.Handler)
+		api:SetClientConfig({ url = "https://example.com", token = "my-token" })
+		api:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(api:PromiseFlush())).toEqual(true)
+
+		expect((mock:GetLastRequest() :: any).Url).toEqual(
+			"https://example.com/api/v2/write?org=my-org&bucket=my-bucket&precision=ns"
+		)
+
+		api:Destroy()
+	end)
+
+	it("should throw on a non-string org", function()
+		expect(function()
+			InfluxDBWriteAPI.new(5 :: any, "my-bucket")
+		end).toThrow("Bad org")
+	end)
+
+	it("should throw on a non-string bucket", function()
+		expect(function()
+			InfluxDBWriteAPI.new("my-org", 5 :: any)
+		end).toThrow("Bad bucket")
+	end)
+
+	it("should throw on a non-string, non-nil precision", function()
+		expect(function()
+			InfluxDBWriteAPI.new("my-org", "my-bucket", 5 :: any)
+		end).toThrow("Bad precision")
+	end)
+
+	it("should throw on a non-function, non-nil request handler", function()
+		expect(function()
+			InfluxDBWriteAPI.new("my-org", "my-bucket", nil, 5 :: any)
+		end).toThrow("Bad requestHandler")
+	end)
+end)
+
+describe("InfluxDBWriteAPI.SetClientConfig", function()
+	it("should throw on an invalid config", function()
+		local api = InfluxDBWriteAPI.new("my-org", "my-bucket")
+
+		expect(function()
+			api:SetClientConfig({ url = "https://example.com" } :: any)
+		end).toThrow("Bad clientConfig")
+
+		api:Destroy()
+	end)
+end)
+
+describe("InfluxDBWriteAPI.SetPrintDebugWriteEnabled", function()
+	it("should throw on a non-boolean value", function()
+		local api = InfluxDBWriteAPI.new("my-org", "my-bucket")
+
+		expect(function()
+			api:SetPrintDebugWriteEnabled("yes" :: any)
+		end).toThrow("Bad printDebugEnabled")
+
+		api:Destroy()
+	end)
+end)
+
+describe("InfluxDBWriteAPI.QueuePoint", function()
+	it("should throw on a non-point", function()
+		local api = InfluxDBWriteAPI.new("my-org", "my-bucket")
+
+		expect(function()
+			api:QueuePoint({} :: any)
+		end).toThrow("Bad point")
+
+		api:Destroy()
+	end)
+
+	it("should not send a request until flushed", function()
+		local api, mock = newConfiguredAPI()
+		api:QueuePoint(newPoint())
+
+		expect(#mock:GetRequests()).toEqual(0)
+
+		api:Destroy()
+	end)
+end)
+
+describe("InfluxDBWriteAPI.QueuePoints", function()
+	it("should throw on a non-table", function()
+		local api = InfluxDBWriteAPI.new("my-org", "my-bucket")
+
+		expect(function()
+			api:QueuePoints("nope" :: any)
+		end).toThrow("Bad points")
+
+		api:Destroy()
+	end)
+
+	it("should throw on a non-point entry in the list", function()
+		local api = InfluxDBWriteAPI.new("my-org", "my-bucket")
+
+		expect(function()
+			api:QueuePoints({ {} :: any })
+		end).toThrow("Bad point")
+
+		api:Destroy()
+	end)
+
+	it("should batch every queued point into a single newline-joined body", function()
+		local api, mock = newConfiguredAPI()
+		api:QueuePoints({ newPoint(), newPoint() })
+		expect(PromiseTestUtils.awaitSettled(api:PromiseFlush())).toEqual(true)
+
+		expect(#mock:GetRequests()).toEqual(1)
+		expect((mock:GetLastRequest() :: any).Body).toEqual(POINT_LINE .. "\n" .. POINT_LINE)
+
+		api:Destroy()
+	end)
+end)
+
+describe("InfluxDBWriteAPI.PromiseFlush", function()
+	it("should reject with no client configuration when none is set", function()
+		local mock = InfluxDBRequestHandlerMock.new()
+		local api = InfluxDBWriteAPI.new("my-org", "my-bucket", nil, mock.Handler)
+		api:QueuePoint(newPoint())
+
+		local outcome, payload = PromiseTestUtils.awaitOutcome(api:PromiseFlush())
+		expect(outcome).toEqual("rejected")
+		expect(payload).toEqual("No client configuration")
+		-- The batch is abandoned before a request is ever built.
+		expect(#mock:GetRequests()).toEqual(0)
+
+		api:Destroy()
+	end)
+
+	it("should send the buffered line protocol as the request body", function()
+		local api, mock = newConfiguredAPI()
+		api:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(api:PromiseFlush())).toEqual(true)
+
+		expect((mock:GetLastRequest() :: any).Method).toEqual("POST")
+		expect((mock:GetLastRequest() :: any).Body).toEqual(POINT_LINE)
+
+		api:Destroy()
+	end)
+
+	it("should send a Token-prefixed authorization header for a string token", function()
+		local api, mock = newConfiguredAPI()
+		api:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(api:PromiseFlush())).toEqual(true)
+
+		expect((mock:GetLastRequest() :: any).Headers.Authorization).toEqual("Token my-token")
+
+		api:Destroy()
+	end)
+
+	it("should strip a trailing slash from the configured url", function()
+		local api, mock = newConfiguredAPI({ url = "https://example.com/" })
+		api:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(api:PromiseFlush())).toEqual(true)
+
+		expect((mock:GetLastRequest() :: any).Url).toEqual(
+			"https://example.com/api/v2/write?org=my-org&bucket=my-bucket&precision=ms"
+		)
+
+		api:Destroy()
+	end)
+
+	it("should resolve and fire RequestFinished on a successful response", function()
+		local api, mock = newConfiguredAPI()
+
+		local response = {
+			Success = true,
+			StatusCode = 204,
+			StatusMessage = "No Content",
+			Headers = {},
+			Body = "",
+		}
+		mock:SetResponder(function()
+			return Promise.resolved(response)
+		end)
+
+		local finished = {}
+		api.RequestFinished:Connect(function(result)
+			table.insert(finished, result)
+		end)
+
+		api:QueuePoint(newPoint())
+		local outcome = PromiseTestUtils.awaitOutcome(api:PromiseFlush())
+
+		expect(outcome).toEqual("resolved")
+		expect(finished[1]).toBe(response)
+
+		api:Destroy()
+	end)
+
+	it("should reject with the parsed InfluxDB error when the body is a known error", function()
+		local api, mock = newConfiguredAPI()
+		mock:SetResponder(function()
+			return Promise.rejected({
+				Success = false,
+				StatusCode = 401,
+				StatusMessage = "Unauthorized",
+				Headers = {},
+				Body = '{"code":"unauthorized","message":"token required"}',
+			})
+		end)
+
+		api:QueuePoint(newPoint())
+
+		local outcome, payload = PromiseTestUtils.awaitOutcome(api:PromiseFlush())
+		expect(outcome).toEqual("rejected")
+		expect(payload.code).toEqual("unauthorized")
+		expect(payload.message).toEqual("token required")
+
+		api:Destroy()
+	end)
+
+	it("should reject with a formatted string when the error body is not a known error", function()
+		local api, mock = newConfiguredAPI()
+		mock:SetResponder(function()
+			return Promise.rejected({
+				Success = false,
+				StatusCode = 500,
+				StatusMessage = "Internal Server Error",
+				Headers = {},
+				Body = "not json",
+			})
+		end)
+
+		api:QueuePoint(newPoint())
+
+		local outcome, payload = PromiseTestUtils.awaitOutcome(api:PromiseFlush())
+		expect(outcome).toEqual("rejected")
+		expect(type(payload)).toEqual("string")
+		expect(string.find(payload, "500", 1, true) ~= nil).toEqual(true)
+
+		api:Destroy()
+	end)
+
+	it("should reject with the raw error when it is not an http response", function()
+		local api, mock = newConfiguredAPI()
+		mock:SetResponder(function()
+			return Promise.rejected("connection refused")
+		end)
+
+		api:QueuePoint(newPoint())
+
+		local outcome, payload = PromiseTestUtils.awaitOutcome(api:PromiseFlush())
+		expect(outcome).toEqual("rejected")
+		expect(payload).toEqual("connection refused")
+
+		api:Destroy()
+	end)
+
+	it("should resolve without a request when nothing is buffered", function()
+		local api, mock = newConfiguredAPI()
+
+		expect(PromiseTestUtils.awaitSettled(api:PromiseFlush())).toEqual(true)
+		expect(#mock:GetRequests()).toEqual(0)
+
+		api:Destroy()
+	end)
+end)

package/src/Server/Write/InfluxDBWriteBuffer.spec.lua

@@ -0,0 +1,144 @@
+--!strict
+--[[
+	@class InfluxDBWriteBuffer.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBWriteBuffer = require("InfluxDBWriteBuffer")
+local InfluxDBWriteOptionUtils = require("InfluxDBWriteOptionUtils")
+local Jest = require("Jest")
+local Promise = require("Promise")
+local PromiseTestUtils = require("PromiseTestUtils")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+-- Records each flush so tests can assert what was handed to the flush handler and when.
+local function newRecordingBuffer(options: InfluxDBWriteOptionUtils.InfluxDBWriteOptions)
+	local flushes: { { string } } = {}
+	local buffer = InfluxDBWriteBuffer.new(options, function(entries)
+		table.insert(flushes, entries)
+		return Promise.resolved()
+	end)
+
+	return buffer, flushes
+end
+
+-- A large flush interval keeps the time-based flush from firing during a test; Destroy cancels it.
+local function options(overrides: { [string]: number })
+	return InfluxDBWriteOptionUtils.createWriteOptions({
+		batchSize = overrides.batchSize or 1000,
+		maxBatchBytes = overrides.maxBatchBytes or 50_000_000,
+		flushIntervalSeconds = overrides.flushIntervalSeconds or 9999,
+	})
+end
+
+describe("InfluxDBWriteBuffer.Add", function()
+	it("should not flush before the batch size is reached", function()
+		local buffer, flushes = newRecordingBuffer(options({ batchSize = 3 }))
+
+		buffer:Add("a")
+		buffer:Add("b")
+
+		expect(#flushes).toEqual(0)
+
+		buffer:Destroy()
+	end)
+
+	it("should flush once the batch size is reached", function()
+		local buffer, flushes = newRecordingBuffer(options({ batchSize = 2 }))
+
+		buffer:Add("a")
+		buffer:Add("b")
+
+		expect(#flushes).toEqual(1)
+		expect(flushes[1]).toEqual({ "a", "b" })
+
+		buffer:Destroy()
+	end)
+
+	it("should preserve entry order across a flush", function()
+		local buffer, flushes = newRecordingBuffer(options({ batchSize = 3 }))
+
+		buffer:Add("first")
+		buffer:Add("second")
+		buffer:Add("third")
+
+		expect(flushes[1]).toEqual({ "first", "second", "third" })
+
+		buffer:Destroy()
+	end)
+
+	it("should reset after a flush so a later flush is empty", function()
+		local buffer, flushes = newRecordingBuffer(options({ batchSize = 2 }))
+
+		buffer:Add("a")
+		buffer:Add("b")
+		expect(#flushes).toEqual(1)
+
+		-- Nothing buffered now, so an explicit flush must not re-send the batch.
+		local promise = buffer:PromiseFlush()
+		expect(PromiseTestUtils.awaitSettled(promise)).toEqual(true)
+		expect(#flushes).toEqual(1)
+
+		buffer:Destroy()
+	end)
+
+	it("should flush when the byte ceiling is exceeded", function()
+		local buffer, flushes = newRecordingBuffer(options({ maxBatchBytes = 10 }))
+
+		-- 12 bytes + 1 newline separator clears the 10-byte ceiling on its own.
+		buffer:Add("abcdefghijkl")
+
+		expect(#flushes).toEqual(1)
+		expect(flushes[1]).toEqual({ "abcdefghijkl" })
+
+		buffer:Destroy()
+	end)
+
+	it("should throw on a non-string entry", function()
+		local buffer = newRecordingBuffer(options({}))
+
+		expect(function()
+			buffer:Add(5 :: any)
+		end).toThrow("Bad entry")
+
+		buffer:Destroy()
+	end)
+end)
+
+describe("InfluxDBWriteBuffer.PromiseFlush", function()
+	it("should flush pending entries below the batch size", function()
+		local buffer, flushes = newRecordingBuffer(options({ batchSize = 100 }))
+
+		buffer:Add("a")
+		buffer:Add("b")
+		expect(#flushes).toEqual(0)
+
+		local promise = buffer:PromiseFlush()
+		expect(PromiseTestUtils.awaitSettled(promise)).toEqual(true)
+		expect(flushes[1]).toEqual({ "a", "b" })
+
+		buffer:Destroy()
+	end)
+
+	it("should resolve without calling the handler when empty", function()
+		local buffer, flushes = newRecordingBuffer(options({}))
+
+		local promise = buffer:PromiseFlush()
+		expect(PromiseTestUtils.awaitSettled(promise)).toEqual(true)
+		expect(#flushes).toEqual(0)
+
+		buffer:Destroy()
+	end)
+end)
+
+describe("InfluxDBWriteBuffer.new", function()
+	it("should throw without a flush handler", function()
+		expect(function()
+			InfluxDBWriteBuffer.new(options({}), nil :: any)
+		end).toThrow("No promiseHandleFlush")
+	end)
+end)

package/src/Shared/Config/InfluxDBPointSettings.spec.lua

@@ -0,0 +1,87 @@
+--!strict
+--[[
+	@class InfluxDBPointSettings.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBPointSettings = require("InfluxDBPointSettings")
+local Jest = require("Jest")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+describe("InfluxDBPointSettings.new", function()
+	it("should start with no default tags", function()
+		local settings = InfluxDBPointSettings.new()
+
+		expect(next(settings:GetDefaultTags())).toEqual(nil)
+	end)
+
+	it("should start with no convert time", function()
+		local settings = InfluxDBPointSettings.new()
+
+		expect(settings:GetConvertTime()).toEqual(nil)
+	end)
+end)
+
+describe("InfluxDBPointSettings.SetDefaultTags", function()
+	it("should store and return the tags", function()
+		local settings = InfluxDBPointSettings.new()
+		settings:SetDefaultTags({
+			host = "server1",
+			region = "us-east",
+		})
+
+		local tags = settings:GetDefaultTags()
+		expect(tags.host).toEqual("server1")
+		expect(tags.region).toEqual("us-east")
+	end)
+
+	it("should throw on a non-table", function()
+		local settings = InfluxDBPointSettings.new()
+
+		expect(function()
+			settings:SetDefaultTags(5 :: any)
+		end).toThrow("Bad tags")
+	end)
+
+	it("should throw when a tag value is not a string", function()
+		local settings = InfluxDBPointSettings.new()
+
+		expect(function()
+			settings:SetDefaultTags({ host = 5 :: any })
+		end).toThrow("Bad value")
+	end)
+end)
+
+describe("InfluxDBPointSettings.SetConvertTime", function()
+	it("should store and return the convert time function", function()
+		local settings = InfluxDBPointSettings.new()
+		local function convertTime(_value)
+			return 42
+		end
+		settings:SetConvertTime(convertTime)
+
+		expect(settings:GetConvertTime()).toBe(convertTime)
+	end)
+
+	it("should allow clearing the convert time with nil", function()
+		local settings = InfluxDBPointSettings.new()
+		settings:SetConvertTime(function(_value)
+			return 42
+		end)
+		settings:SetConvertTime(nil)
+
+		expect(settings:GetConvertTime()).toEqual(nil)
+	end)
+
+	it("should throw on a non-function", function()
+		local settings = InfluxDBPointSettings.new()
+
+		expect(function()
+			settings:SetConvertTime(5 :: any)
+		end).toThrow("Bad convertTime")
+	end)
+end)

package/src/Shared/Utils/InfluxDBEscapeUtils.spec.lua

@@ -34,6 +34,30 @@ describe("InfluxDBEscapeUtils.quoted", function()
 	end)
 end)
 
+describe("InfluxDBEscapeUtils.measurement", function()
+	it("should escape commas", function()
+		expect(InfluxDBEscapeUtils.measurement("a,b")).toBe("a\\,b")
+	end)
+
+	it("should escape spaces", function()
+		expect(InfluxDBEscapeUtils.measurement("a b")).toBe("a\\ b")
+	end)
+
+	it("should not escape equals signs", function()
+		expect(InfluxDBEscapeUtils.measurement("a=b")).toBe("a=b")
+	end)
+end)
+
+describe("InfluxDBEscapeUtils.quoted", function()
+	it("should escape backslashes", function()
+		expect(InfluxDBEscapeUtils.quoted("a\\b")).toBe('"a\\\\b"')
+	end)
+
+	it("should wrap an empty string in quotes", function()
+		expect(InfluxDBEscapeUtils.quoted("")).toBe('""')
+	end)
+end)
+
 describe("InfluxDBEscapeUtils.tag", function()
 	it("should pass through fine", function()
 		local tag = InfluxDBEscapeUtils.tag("hi")
@@ -59,4 +83,50 @@ describe("InfluxDBEscapeUtils.tag", function()
 		local tag = InfluxDBEscapeUtils.tag("\nhi")
 		expect(tag).toBe("\\nhi")
 	end)
+
+	it("should escape commas and spaces", function()
+		expect(InfluxDBEscapeUtils.tag("a, b")).toBe("a\\,\\ b")
+	end)
+end)
+
+describe("InfluxDBEscapeUtils.createEscaper", function()
+	it("should replace only the characters in the sub table", function()
+		local escaper = InfluxDBEscapeUtils.createEscaper({
+			["#"] = "\\#",
+		})
+
+		expect(escaper("a#b#c")).toBe("a\\#b\\#c")
+		expect(escaper("abc")).toBe("abc")
+	end)
+
+	it("should escape Lua pattern magic characters used as keys", function()
+		local escaper = InfluxDBEscapeUtils.createEscaper({
+			["."] = "\\.",
+			["%"] = "\\%",
+		})
+
+		expect(escaper("a.b%c")).toBe("a\\.b\\%c")
+	end)
+
+	it("should throw on a non-table sub table", function()
+		expect(function()
+			InfluxDBEscapeUtils.createEscaper(5 :: any)
+		end).toThrow("Bad subTable")
+	end)
+
+	it("should throw on a multi-character key", function()
+		expect(function()
+			InfluxDBEscapeUtils.createEscaper({ ab = "x" })
+		end).toThrow("Bad char")
+	end)
+end)
+
+describe("InfluxDBEscapeUtils.createQuotedEscaper", function()
+	it("should wrap the escaped result in quotes", function()
+		local escaper = InfluxDBEscapeUtils.createQuotedEscaper({
+			["#"] = "\\#",
+		})
+
+		expect(escaper("a#b")).toBe('"a\\#b"')
+	end)
 end)