@quenty/influxdbclient 7.36.0 → 7.38.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [7.38.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/influxdbclient@7.37.0...@quenty/influxdbclient@7.38.0) (2026-07-21)
+
+**Note:** Version bump only for package @quenty/influxdbclient
+
+# [7.37.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/influxdbclient@7.36.0...@quenty/influxdbclient@7.37.0) (2026-07-18)
+
+### Bug Fixes
+
+- pin translation behavior with tests and fix camelCase key generation ([#737](https://github.com/Quenty/NevermoreEngine/issues/737)) ([1b7a536](https://github.com/Quenty/NevermoreEngine/commit/1b7a536dde7e124f8432e57612ec8138dd835d75))
+
 # [7.36.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/influxdbclient@7.35.1...@quenty/influxdbclient@7.36.0) (2026-07-18)
 
 **Note:** Version bump only for package @quenty/influxdbclient

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/influxdbclient",
-  "version": "7.36.0",
+  "version": "7.38.0",
   "description": "Provides a Roblox Lua InfluxDB client",
   "keywords": [
     "Roblox",
@@ -28,24 +28,24 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/baseobject": "10.13.0",
-    "@quenty/httppromise": "10.19.0",
-    "@quenty/jsonutils": "10.19.0",
+    "@quenty/baseobject": "10.14.0",
+    "@quenty/httppromise": "10.20.0",
+    "@quenty/jsonutils": "10.20.0",
     "@quenty/loader": "10.11.0",
-    "@quenty/maid": "3.9.0",
+    "@quenty/maid": "3.10.0",
     "@quenty/math": "2.7.5",
     "@quenty/nevermore-test-runner": "1.4.0",
-    "@quenty/promise": "10.19.0",
-    "@quenty/rx": "13.29.0",
-    "@quenty/servicebag": "11.18.1",
+    "@quenty/promise": "10.20.0",
+    "@quenty/rx": "13.30.0",
+    "@quenty/servicebag": "11.19.0",
     "@quenty/signal": "7.13.1",
     "@quenty/string": "3.3.7",
     "@quenty/table": "3.9.2",
-    "@quenty/valueobject": "13.32.0",
+    "@quenty/valueobject": "13.33.0",
     "@quentystudios/jest-lua": "3.10.0-quenty.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cbbb89635bfdcbf32f26a40422ac736292917cca"
+  "gitHead": "b7e59984e586064ea3cec6176e79b3f7451ecdc5"
 }

package/src/Server/Config/InfluxDBClientConfigUtils.spec.lua

@@ -0,0 +1,86 @@
+--!strict
+--[[
+	@class InfluxDBClientConfigUtils.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBClientConfigUtils = require("InfluxDBClientConfigUtils")
+local Jest = require("Jest")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+describe("InfluxDBClientConfigUtils.isClientConfig", function()
+	it("should be true for a config with a string token", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			url = "https://us-east-1-1.aws.cloud2.influxdata.com",
+			token = "my-token",
+		})).toEqual(true)
+	end)
+
+	it("should be false for a non-table", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig(nil)).toEqual(false)
+		expect(InfluxDBClientConfigUtils.isClientConfig("str")).toEqual(false)
+		expect(InfluxDBClientConfigUtils.isClientConfig(5)).toEqual(false)
+	end)
+
+	it("should be false when url is missing", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			token = "my-token",
+		})).toEqual(false)
+	end)
+
+	it("should be false when url is not a string", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			url = 5,
+			token = "my-token",
+		})).toEqual(false)
+	end)
+
+	it("should be false when token is missing", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			url = "https://example.com",
+		})).toEqual(false)
+	end)
+
+	it("should be false when token is a number", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			url = "https://example.com",
+			token = 5,
+		})).toEqual(false)
+	end)
+end)
+
+describe("InfluxDBClientConfigUtils.createClientConfig", function()
+	it("should return a config with only url and token fields", function()
+		local config = InfluxDBClientConfigUtils.createClientConfig({
+			url = "https://example.com",
+			token = "my-token",
+			extra = "ignored",
+		} :: any)
+
+		expect(config.url).toEqual("https://example.com")
+		expect(config.token).toEqual("my-token")
+		expect((config :: any).extra).toEqual(nil)
+	end)
+
+	it("should return a fresh table, not the same reference", function()
+		local input = {
+			url = "https://example.com",
+			token = "my-token",
+		}
+		local config = InfluxDBClientConfigUtils.createClientConfig(input)
+
+		expect(config).never.toBe(input)
+	end)
+
+	it("should throw on an invalid config", function()
+		expect(function()
+			InfluxDBClientConfigUtils.createClientConfig({
+				token = "my-token",
+			} :: any)
+		end).toThrow("Bad config")
+	end)
+end)

package/src/Server/Config/InfluxDBWriteOptionUtils.spec.lua

@@ -0,0 +1,94 @@
+--!strict
+--[[
+	@class InfluxDBWriteOptionUtils.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBWriteOptionUtils = require("InfluxDBWriteOptionUtils")
+local Jest = require("Jest")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+describe("InfluxDBWriteOptionUtils.getDefaultOptions", function()
+	it("should return the documented defaults", function()
+		local options = InfluxDBWriteOptionUtils.getDefaultOptions()
+
+		expect(options.batchSize).toEqual(1000)
+		expect(options.maxBatchBytes).toEqual(50_000_000)
+		expect(options.flushIntervalSeconds).toEqual(60)
+	end)
+
+	it("should return a readonly table", function()
+		local options = InfluxDBWriteOptionUtils.getDefaultOptions()
+
+		expect(function()
+			(options :: any).batchSize = 5
+		end).toThrow()
+	end)
+end)
+
+describe("InfluxDBWriteOptionUtils.isWriteOptions", function()
+	it("should be true for a fully specified options table", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions({
+			batchSize = 10,
+			maxBatchBytes = 1000,
+			flushIntervalSeconds = 5,
+		})).toEqual(true)
+	end)
+
+	it("should be false for a non-table", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions(nil)).toEqual(false)
+		expect(InfluxDBWriteOptionUtils.isWriteOptions("str")).toEqual(false)
+	end)
+
+	it("should be false when batchSize is missing", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions({
+			maxBatchBytes = 1000,
+			flushIntervalSeconds = 5,
+		})).toEqual(false)
+	end)
+
+	it("should be false when maxBatchBytes is not a number", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions({
+			batchSize = 10,
+			maxBatchBytes = "1000",
+			flushIntervalSeconds = 5,
+		})).toEqual(false)
+	end)
+
+	it("should be false when flushIntervalSeconds is missing", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions({
+			batchSize = 10,
+			maxBatchBytes = 1000,
+		})).toEqual(false)
+	end)
+end)
+
+describe("InfluxDBWriteOptionUtils.createWriteOptions", function()
+	it("should return a readonly copy of valid options", function()
+		local options = InfluxDBWriteOptionUtils.createWriteOptions({
+			batchSize = 10,
+			maxBatchBytes = 1000,
+			flushIntervalSeconds = 5,
+		})
+
+		expect(options.batchSize).toEqual(10)
+		expect(options.maxBatchBytes).toEqual(1000)
+		expect(options.flushIntervalSeconds).toEqual(5)
+
+		expect(function()
+			(options :: any).batchSize = 20
+		end).toThrow()
+	end)
+
+	it("should throw on invalid options", function()
+		expect(function()
+			InfluxDBWriteOptionUtils.createWriteOptions({
+				batchSize = 10,
+			} :: any)
+		end).toThrow("Bad options")
+	end)
+end)

package/src/Server/Utils/InfluxDBErrorUtils.spec.lua

@@ -0,0 +1,69 @@
+--!strict
+--[[
+	@class InfluxDBErrorUtils.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBErrorUtils = require("InfluxDBErrorUtils")
+local Jest = require("Jest")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+describe("InfluxDBErrorUtils.isInfluxDBError", function()
+	it("should be true for a table with string code and message", function()
+		expect(InfluxDBErrorUtils.isInfluxDBError({
+			code = "unauthorized",
+			message = "unauthorized access",
+		})).toEqual(true)
+	end)
+
+	it("should be false for a non-table", function()
+		expect(InfluxDBErrorUtils.isInfluxDBError(nil)).toEqual(false)
+		expect(InfluxDBErrorUtils.isInfluxDBError("str")).toEqual(false)
+		expect(InfluxDBErrorUtils.isInfluxDBError(5)).toEqual(false)
+	end)
+
+	it("should be false when code is missing", function()
+		expect(InfluxDBErrorUtils.isInfluxDBError({
+			message = "unauthorized access",
+		})).toEqual(false)
+	end)
+
+	it("should be false when message is not a string", function()
+		expect(InfluxDBErrorUtils.isInfluxDBError({
+			code = "unauthorized",
+			message = 5,
+		})).toEqual(false)
+	end)
+end)
+
+describe("InfluxDBErrorUtils.tryParseErrorBody", function()
+	it("should parse a valid InfluxDB error body", function()
+		local errorBody =
+			InfluxDBErrorUtils.tryParseErrorBody('{"code":"unauthorized","message":"unauthorized access"}')
+
+		expect(errorBody).never.toEqual(nil)
+		assert(errorBody, "no errorBody")
+		expect(errorBody.code).toEqual("unauthorized")
+		expect(errorBody.message).toEqual("unauthorized access")
+	end)
+
+	it("should return nil for a body that is not valid JSON", function()
+		expect(InfluxDBErrorUtils.tryParseErrorBody("not json")).toEqual(nil)
+	end)
+
+	it("should return nil for valid JSON that is not an InfluxDB error", function()
+		expect(InfluxDBErrorUtils.tryParseErrorBody('{"foo":"bar"}')).toEqual(nil)
+	end)
+
+	it("should return nil for a JSON array", function()
+		expect(InfluxDBErrorUtils.tryParseErrorBody("[1, 2, 3]")).toEqual(nil)
+	end)
+
+	it("should return nil for an empty string", function()
+		expect(InfluxDBErrorUtils.tryParseErrorBody("")).toEqual(nil)
+	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

@@ -1,11 +1,9 @@
---!nonstrict
+--!strict
 --[[
 	@class InfluxDBEscapeUtils.spec.lua
 ]]
 
-local require = (require :: any)(
-		game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent
-	).bootstrapStory(script) :: typeof(require(script.Parent.loader).load(script))
+local require = require(script.Parent.loader).load(script)
 
 local InfluxDBEscapeUtils = require("InfluxDBEscapeUtils")
 local Jest = require("Jest")
@@ -36,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")
@@ -61,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)

package/src/Shared/Write/InfluxDBPoint.spec.lua

@@ -0,0 +1,373 @@
+--!strict
+--[[
+	@class InfluxDBPoint.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBPoint = require("InfluxDBPoint")
+local InfluxDBPointSettings = require("InfluxDBPointSettings")
+local Jest = require("Jest")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+-- A fixed timestamp keeps line protocol output deterministic across tests.
+local FIXED_TIMESTAMP = DateTime.fromUnixTimestampMillis(1600000000000)
+
+local function newFixedPoint(measurementName: string?): InfluxDBPoint.InfluxDBPoint
+	local point = InfluxDBPoint.new(measurementName)
+	point:SetTimestamp(FIXED_TIMESTAMP)
+	return point
+end
+
+describe("InfluxDBPoint.new", function()
+	it("should default to an empty set of tags and fields", function()
+		local point = InfluxDBPoint.new("temperature")
+		local data = point:ToTableData()
+
+		expect(next(data.tags)).toEqual(nil)
+		expect(next(data.fields)).toEqual(nil)
+	end)
+
+	it("should allow a nil measurement name", function()
+		local point = InfluxDBPoint.new()
+		expect(point:GetMeasurementName()).toEqual(nil)
+	end)
+
+	it("should default the timestamp to a numeric millisecond string", function()
+		local point = InfluxDBPoint.new("temperature")
+		local timestamp = point:ToTableData().timestamp
+
+		expect(type(timestamp)).toEqual("string")
+		expect(tonumber(timestamp)).never.toEqual(nil)
+	end)
+
+	it("should throw on a non-string measurement name", function()
+		expect(function()
+			InfluxDBPoint.new(5 :: any)
+		end).toThrow("Bad measurementName")
+	end)
+end)
+
+describe("InfluxDBPoint.isInfluxDBPoint", function()
+	it("should be true for a point", function()
+		expect(InfluxDBPoint.isInfluxDBPoint(InfluxDBPoint.new("temperature"))).toEqual(true)
+	end)
+
+	it("should be false for a plain table", function()
+		expect(InfluxDBPoint.isInfluxDBPoint({})).toEqual(false)
+	end)
+
+	it("should be false for nil and primitives", function()
+		expect(InfluxDBPoint.isInfluxDBPoint(nil)).toEqual(false)
+		expect(InfluxDBPoint.isInfluxDBPoint(5)).toEqual(false)
+		expect(InfluxDBPoint.isInfluxDBPoint("str")).toEqual(false)
+	end)
+end)
+
+describe("InfluxDBPoint measurement name", function()
+	it("should get and set the measurement name", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(point:GetMeasurementName()).toEqual("temperature")
+
+		point:SetMeasurementName("humidity")
+		expect(point:GetMeasurementName()).toEqual("humidity")
+	end)
+end)
+
+describe("InfluxDBPoint.AddTag", function()
+	it("should throw on a non-string key", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:AddTag(5 :: any, "value")
+		end).toThrow("Bad tagKey")
+	end)
+
+	it("should throw on a non-string value", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:AddTag("key", 5 :: any)
+		end).toThrow("Bad tagValue")
+	end)
+end)
+
+describe("InfluxDBPoint field setters", function()
+	it("should add an int field with an 'i' suffix", function()
+		local point = newFixedPoint("temperature")
+		point:AddIntField("count", 5)
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual("temperature count=5i 1600000000000")
+	end)
+
+	it("should add a uint field with a 'u' suffix", function()
+		local point = newFixedPoint("temperature")
+		point:AddUintField("count", 5)
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual("temperature count=5u 1600000000000")
+	end)
+
+	it("should add a float field verbatim", function()
+		local point = newFixedPoint("temperature")
+		point:AddFloatField("value", 23.5)
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual("temperature value=23.5 1600000000000")
+	end)
+
+	it("should add a boolean field as T or F", function()
+		local truePoint = newFixedPoint("temperature")
+		truePoint:AddBooleanField("active", true)
+		expect(truePoint:ToLineProtocol(InfluxDBPointSettings.new())).toEqual("temperature active=T 1600000000000")
+
+		local falsePoint = newFixedPoint("temperature")
+		falsePoint:AddBooleanField("active", false)
+		expect(falsePoint:ToLineProtocol(InfluxDBPointSettings.new())).toEqual("temperature active=F 1600000000000")
+	end)
+
+	it("should add a quoted string field", function()
+		local point = newFixedPoint("temperature")
+		point:AddStringField("message", "hello")
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual('temperature message="hello" 1600000000000')
+	end)
+
+	it("should escape quotes in a string field value", function()
+		local point = newFixedPoint("temperature")
+		point:AddStringField("message", 'he said "hi"')
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual(
+			'temperature message="he said \\"hi\\"" 1600000000000'
+		)
+	end)
+
+	it("should throw on a non-number int value", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:AddIntField("count", "5" :: any)
+		end).toThrow("Bad value")
+	end)
+
+	it("should throw on a NaN int value", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:AddIntField("count", 0 / 0)
+		end).toThrow("invalid integer value")
+	end)
+
+	it("should throw on an out-of-range int value", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:AddIntField("count", 1e30)
+		end).toThrow("invalid integer value")
+	end)
+
+	it("should throw on a negative uint value", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:AddUintField("count", -1)
+		end).toThrow("invalid uint value")
+	end)
+
+	it("should throw on an out-of-range uint value", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:AddUintField("count", 9007199254740991)
+		end).toThrow("invalid uint value")
+	end)
+
+	it("should throw on an infinite float value", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:AddFloatField("value", math.huge)
+		end).toThrow("invalid float value")
+	end)
+
+	it("should throw on a non-boolean boolean value", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:AddBooleanField("active", "true" :: any)
+		end).toThrow("Bad value")
+	end)
+end)
+
+describe("InfluxDBPoint.ToLineProtocol", function()
+	it("should return nil without a measurement name", function()
+		local point = newFixedPoint()
+		point:AddIntField("count", 5)
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual(nil)
+	end)
+
+	it("should return nil without any fields", function()
+		local point = newFixedPoint("temperature")
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual(nil)
+	end)
+
+	it("should render tags before the field set", function()
+		local point = newFixedPoint("temperature")
+		point:AddTag("location", "office")
+		point:AddFloatField("value", 23.5)
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual(
+			"temperature,location=office value=23.5 1600000000000"
+		)
+	end)
+
+	it("should sort field keys alphabetically", function()
+		local point = newFixedPoint("temperature")
+		point:AddIntField("zeta", 1)
+		point:AddIntField("alpha", 2)
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual("temperature alpha=2i,zeta=1i 1600000000000")
+	end)
+
+	it("should sort tag keys alphabetically", function()
+		local point = newFixedPoint("temperature")
+		point:AddTag("zeta", "z")
+		point:AddTag("alpha", "a")
+		point:AddFloatField("value", 1)
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual(
+			"temperature,alpha=a,zeta=z value=1 1600000000000"
+		)
+	end)
+
+	it("should escape spaces in the measurement name", function()
+		local point = newFixedPoint("my measurement")
+		point:AddFloatField("value", 1)
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual("my\\ measurement value=1 1600000000000")
+	end)
+
+	it("should escape special characters in tag keys and values", function()
+		local point = newFixedPoint("temperature")
+		point:AddTag("my tag", "a,b")
+		point:AddFloatField("value", 1)
+
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual(
+			"temperature,my\\ tag=a\\,b value=1 1600000000000"
+		)
+	end)
+
+	it("should merge default tags from the point settings", function()
+		local point = newFixedPoint("temperature")
+		point:AddTag("location", "office")
+		point:AddFloatField("value", 1)
+
+		local settings = InfluxDBPointSettings.new()
+		settings:SetDefaultTags({ host = "server1" })
+
+		expect(point:ToLineProtocol(settings)).toEqual("temperature,host=server1,location=office value=1 1600000000000")
+	end)
+
+	it("should prefer the point's own tag over a default tag of the same key", function()
+		local point = newFixedPoint("temperature")
+		point:AddTag("host", "override")
+		point:AddFloatField("value", 1)
+
+		local settings = InfluxDBPointSettings.new()
+		settings:SetDefaultTags({ host = "default" })
+
+		expect(point:ToLineProtocol(settings)).toEqual("temperature,host=override value=1 1600000000000")
+	end)
+
+	it("should apply the convert time function to the timestamp", function()
+		local point = newFixedPoint("temperature")
+		point:AddFloatField("value", 1)
+
+		local settings = InfluxDBPointSettings.new()
+		settings:SetConvertTime(function(_timestamp)
+			return 999
+		end)
+
+		expect(point:ToLineProtocol(settings)).toEqual("temperature value=1 999")
+	end)
+end)
+
+describe("InfluxDBPoint.SetTimestamp", function()
+	it("should throw on a non-DateTime, non-nil timestamp", function()
+		local point = InfluxDBPoint.new("temperature")
+		expect(function()
+			point:SetTimestamp(5 :: any)
+		end).toThrow("Bad timestamp")
+	end)
+end)
+
+describe("InfluxDBPoint.ToTableData", function()
+	it("should round-trip through fromTableData", function()
+		local point = newFixedPoint("temperature")
+		point:AddTag("location", "office")
+		point:AddIntField("count", 5)
+
+		local copy = InfluxDBPoint.fromTableData(point:ToTableData())
+
+		expect(copy:GetMeasurementName()).toEqual("temperature")
+		expect(copy:ToLineProtocol(InfluxDBPointSettings.new())).toEqual(
+			point:ToLineProtocol(InfluxDBPointSettings.new())
+		)
+	end)
+
+	it("should return clones that do not mutate the source point", function()
+		local point = InfluxDBPoint.new("temperature")
+		point:AddTag("location", "office")
+
+		local data = point:ToTableData()
+		data.tags.location = "mutated"
+
+		expect(point:ToTableData().tags.location).toEqual("office")
+	end)
+end)
+
+describe("InfluxDBPoint.fromTableData", function()
+	it("should build a point from table data", function()
+		local point = InfluxDBPoint.fromTableData({
+			measurementName = "temperature",
+			timestamp = 1600000000000,
+			tags = { location = "office" },
+			fields = { count = "5i" },
+		})
+
+		expect(point:GetMeasurementName()).toEqual("temperature")
+		expect(point:ToLineProtocol(InfluxDBPointSettings.new())).toEqual(
+			"temperature,location=office count=5i 1600000000000"
+		)
+	end)
+
+	it("should throw on non-table data", function()
+		expect(function()
+			InfluxDBPoint.fromTableData(5 :: any)
+		end).toThrow("Bad data")
+	end)
+
+	it("should throw on a non-string measurement name", function()
+		expect(function()
+			InfluxDBPoint.fromTableData({
+				measurementName = 5 :: any,
+				tags = {},
+				fields = {},
+			})
+		end).toThrow("Bad data.measurementName")
+	end)
+
+	it("should throw on a non-string tag value", function()
+		expect(function()
+			InfluxDBPoint.fromTableData({
+				measurementName = "temperature",
+				tags = { location = 5 :: any },
+				fields = {},
+			})
+		end).toThrow("Bad tagValue")
+	end)
+
+	it("should throw on a non-string field value", function()
+		expect(function()
+			InfluxDBPoint.fromTableData({
+				measurementName = "temperature",
+				tags = {},
+				fields = { count = 5 :: any },
+			})
+		end).toThrow("Bad fieldValue")
+	end)
+end)