@quenty/influxdbclient 7.38.0 → 7.39.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [7.39.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/influxdbclient@7.38.0...@quenty/influxdbclient@7.39.0) (2026-07-22)
+
+### Features
+
+- Add tests to InfluxDBClient package ([c2b138f](https://github.com/Quenty/NevermoreEngine/commit/c2b138f0c0ed050dd6cb3541f644b766b5db6b10))
+
 # [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/influxdbclient",
-  "version": "7.38.0",
+  "version": "7.39.0",
   "description": "Provides a Roblox Lua InfluxDB client",
   "keywords": [
     "Roblox",
@@ -47,5 +47,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b7e59984e586064ea3cec6176e79b3f7451ecdc5"
+  "gitHead": "93f15b200c0f465a0b5304fcf05f5cfe7fdcbd1d"
 }

package/src/Server/InfluxDBClient.lua

@@ -10,6 +10,7 @@ local require = require(script.Parent.loader).load(script)
 
 local BaseObject = require("BaseObject")
 local InfluxDBClientConfigUtils = require("InfluxDBClientConfigUtils")
+local InfluxDBRequestHandlerMock = require("InfluxDBRequestHandlerMock")
 local InfluxDBWriteAPI = require("InfluxDBWriteAPI")
 local Maid = require("Maid")
 local Promise = require("Promise")
@@ -26,6 +27,7 @@ export type InfluxDBClient =
 			_clientConfig: ValueObject.ValueObject<InfluxDBClientConfigUtils.InfluxDBClientConfig>,
 			_writeApis: { [string]: { [string]: InfluxDBWriteAPI.InfluxDBWriteAPI } },
 			_flushAllPromises: Promise.Promise<()>,
+			_requestHandler: InfluxDBWriteAPI.InfluxDBRequestHandler?,
 		},
 		{} :: typeof({ __index = InfluxDBClient })
 	))
@@ -35,11 +37,20 @@ export type InfluxDBClient =
 	Creates a new InfluxDB client
 
 	@param clientConfig InfluxDBClientConfig?
+	@param requestHandler InfluxDBRequestHandler? -- Defaults to [HttpPromise.request]. Inject a mock to avoid real HTTP.
 	@return InfluxDBClient
 ]=]
-function InfluxDBClient.new(clientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig?): InfluxDBClient
+function InfluxDBClient.new(
+	clientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig?,
+	requestHandler: InfluxDBWriteAPI.InfluxDBRequestHandler?
+): InfluxDBClient
 	local self: InfluxDBClient = setmetatable(BaseObject.new() :: any, InfluxDBClient)
 
+	assert(type(requestHandler) == "function" or requestHandler == nil, "Bad requestHandler")
+
+	-- Threaded down into each write API created by GetWriteAPI so all of them share the same seam.
+	self._requestHandler = requestHandler
+
 	self._clientConfig = self._maid:Add(ValueObject.new(nil))
 
 	if clientConfig then
@@ -51,6 +62,33 @@ function InfluxDBClient.new(clientConfig: InfluxDBClientConfigUtils.InfluxDBClie
 	return self
 end
 
+--[=[
+	Creates a new InfluxDB client wired to an [InfluxDBRequestHandlerMock] so no real HTTP calls are
+	made. Returns both the client and the mock, so a test can inspect the requests it would have sent.
+
+	```lua
+	local client, requestMock = InfluxDBClient.newMock()
+	client:SetClientConfig({ url = "https://example.com", token = "token" })
+
+	local writeAPI = client:GetWriteAPI("org", "bucket")
+	writeAPI:QueuePoint(point)
+	writeAPI:PromiseFlush():Wait()
+
+	print(#requestMock:GetRequests()) --> 1
+	```
+
+	@param clientConfig InfluxDBClientConfig?
+	@return (InfluxDBClient, InfluxDBRequestHandlerMock)
+]=]
+function InfluxDBClient.newMock(
+	clientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig?
+): (InfluxDBClient, InfluxDBRequestHandlerMock.InfluxDBRequestHandlerMock)
+	local requestMock = InfluxDBRequestHandlerMock.new()
+	local client = InfluxDBClient.new(clientConfig, requestMock.Handler)
+
+	return client, requestMock
+end
+
 --[=[
 	Sets the client config for this client
 
@@ -83,10 +121,14 @@ function InfluxDBClient.GetWriteAPI(
 
 	local maid = Maid.new()
 
-	local writeAPI = maid:Add(InfluxDBWriteAPI.new(org, bucket, precision))
+	local writeAPI = maid:Add(InfluxDBWriteAPI.new(org, bucket, precision, self._requestHandler))
 
 	maid:GiveTask(self._clientConfig:Observe():Subscribe(function(clientConfig)
-		writeAPI:SetClientConfig(clientConfig)
+		-- The observable fires the current value immediately, which is nil until a config is set. Guard
+		-- so GetWriteAPI can be called before SetClientConfig; the later config is pushed through here.
+		if clientConfig then
+			writeAPI:SetClientConfig(clientConfig)
+		end
 	end))
 
 	maid:GiveTask(writeAPI.Destroying:Connect(function()

package/src/Server/InfluxDBClient.spec.lua

@@ -0,0 +1,227 @@
+--!strict
+--[[
+	@class InfluxDBClient.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBClient = require("InfluxDBClient")
+local InfluxDBPoint = require("InfluxDBPoint")
+local InfluxDBRequestHandlerMock = require("InfluxDBRequestHandlerMock")
+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
+
+local FIXED_TIMESTAMP = DateTime.fromUnixTimestampMillis(1600000000000)
+
+local CONFIG = {
+	url = "https://example.com",
+	token = "my-token",
+}
+
+local function newPoint(): InfluxDBPoint.InfluxDBPoint
+	local point = InfluxDBPoint.new("temperature")
+	point:SetTimestamp(FIXED_TIMESTAMP)
+	point:AddFloatField("value", 23.5)
+	return point
+end
+
+describe("InfluxDBClient.new", function()
+	it("should construct without a config", function()
+		local client = InfluxDBClient.new()
+		expect(client.ClassName).toEqual("InfluxDBClient")
+		client:Destroy()
+	end)
+
+	it("should construct with a config", function()
+		local client = InfluxDBClient.new(CONFIG)
+		expect(client.ClassName).toEqual("InfluxDBClient")
+		client:Destroy()
+	end)
+
+	it("should throw when constructed with an invalid config", function()
+		expect(function()
+			InfluxDBClient.new({ url = "https://example.com" } :: any)
+		end).toThrow("Bad clientConfig")
+	end)
+
+	it("should throw on a non-function, non-nil request handler", function()
+		expect(function()
+			InfluxDBClient.new(nil, 5 :: any)
+		end).toThrow("Bad requestHandler")
+	end)
+end)
+
+describe("InfluxDBClient.newMock", function()
+	it("should return a client and a request handler mock", function()
+		local client, requestMock = InfluxDBClient.newMock()
+
+		expect(client.ClassName).toEqual("InfluxDBClient")
+		expect(InfluxDBRequestHandlerMock.isInfluxDBRequestHandlerMock(requestMock)).toEqual(true)
+
+		client:Destroy()
+	end)
+
+	it("should route write API traffic through the mock instead of the network", function()
+		local client, requestMock = InfluxDBClient.newMock(CONFIG)
+
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+		writeAPI:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(writeAPI:PromiseFlush())).toEqual(true)
+
+		expect(#requestMock:GetRequests()).toEqual(1)
+		expect((requestMock:GetLastRequest() :: any).Headers.Authorization).toEqual("Token my-token")
+
+		client:Destroy()
+	end)
+end)
+
+describe("InfluxDBClient.SetClientConfig", function()
+	it("should throw on an invalid config", function()
+		local client = InfluxDBClient.new()
+
+		expect(function()
+			client:SetClientConfig({ token = "my-token" } :: any)
+		end).toThrow("Bad clientConfig")
+
+		client:Destroy()
+	end)
+end)
+
+describe("InfluxDBClient.GetWriteAPI", function()
+	it("should throw on a non-string org", function()
+		local client = InfluxDBClient.new()
+		expect(function()
+			client:GetWriteAPI(5 :: any, "my-bucket")
+		end).toThrow("Bad org")
+		client:Destroy()
+	end)
+
+	it("should throw on a non-string bucket", function()
+		local client = InfluxDBClient.new()
+		expect(function()
+			client:GetWriteAPI("my-org", 5 :: any)
+		end).toThrow("Bad bucket")
+		client:Destroy()
+	end)
+
+	it("should throw on a non-string, non-nil precision", function()
+		local client = InfluxDBClient.new()
+		expect(function()
+			client:GetWriteAPI("my-org", "my-bucket", 5 :: any)
+		end).toThrow("Bad precision")
+		client:Destroy()
+	end)
+
+	-- Regression: GetWriteAPI must work before a config is set. Its ValueObject:Observe() subscription
+	-- fires the current value (nil) immediately; without a nil guard in GetWriteAPI this would call
+	-- writeAPI:SetClientConfig(nil) and throw "Bad clientConfig".
+	it("should return a write API", function()
+		local client = InfluxDBClient.new()
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+		expect(writeAPI.ClassName).toEqual("InfluxDBWriteAPI")
+		client:Destroy()
+	end)
+
+	it("should return the same write API for the same org and bucket", function()
+		local client = InfluxDBClient.new()
+		local first = client:GetWriteAPI("my-org", "my-bucket")
+		local second = client:GetWriteAPI("my-org", "my-bucket")
+		expect(second).toBe(first)
+		client:Destroy()
+	end)
+
+	it("should return a different write API for a different bucket", function()
+		local client = InfluxDBClient.new()
+		local first = client:GetWriteAPI("my-org", "bucket-a")
+		local second = client:GetWriteAPI("my-org", "bucket-b")
+		expect(second).never.toBe(first)
+		client:Destroy()
+	end)
+
+	it("should return a different write API for a different org", function()
+		local client = InfluxDBClient.new()
+		local first = client:GetWriteAPI("org-a", "my-bucket")
+		local second = client:GetWriteAPI("org-b", "my-bucket")
+		expect(second).never.toBe(first)
+		client:Destroy()
+	end)
+
+	it("should propagate the client config set before GetWriteAPI to the write API", function()
+		local client, requestMock = InfluxDBClient.newMock(CONFIG)
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+
+		-- If the config had not reached the write API, the flush would reject with "No client configuration".
+		writeAPI:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(writeAPI:PromiseFlush())).toEqual(true)
+
+		expect(#requestMock:GetRequests()).toEqual(1)
+
+		client:Destroy()
+	end)
+
+	it("should propagate a client config set after GetWriteAPI to the write API", function()
+		local client, requestMock = InfluxDBClient.newMock()
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+
+		client:SetClientConfig(CONFIG)
+
+		writeAPI:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(writeAPI:PromiseFlush())).toEqual(true)
+
+		expect(#requestMock:GetRequests()).toEqual(1)
+
+		client:Destroy()
+	end)
+end)
+
+describe("InfluxDBClient.PromiseFlushAll", function()
+	it("should resolve when there are no write APIs", function()
+		local client = InfluxDBClient.new()
+
+		expect(PromiseTestUtils.awaitSettled(client:PromiseFlushAll())).toEqual(true)
+
+		client:Destroy()
+	end)
+
+	it("should flush buffered points across every write API", function()
+		local client, requestMock = InfluxDBClient.newMock(CONFIG)
+
+		local apiA = client:GetWriteAPI("my-org", "bucket-a")
+		local apiB = client:GetWriteAPI("my-org", "bucket-b")
+		apiA:QueuePoint(newPoint())
+		apiB:QueuePoint(newPoint())
+
+		expect(PromiseTestUtils.awaitSettled(client:PromiseFlushAll())).toEqual(true)
+		expect(#requestMock:GetRequests()).toEqual(2)
+
+		client:Destroy()
+	end)
+
+	it("should reuse the pending flush promise while one is in flight", function()
+		local client, requestMock = InfluxDBClient.newMock(CONFIG)
+
+		-- A request that never settles keeps the flush pending, so both calls observe the same promise.
+		requestMock:SetResponder(function()
+			return Promise.new(function() end)
+		end)
+
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+		writeAPI:QueuePoint(newPoint())
+
+		local first = client:PromiseFlushAll()
+		local second = client:PromiseFlushAll()
+
+		expect(second).toBe(first)
+
+		-- Destroy cancels the in-flight request, rejecting this promise; consume it so the cancellation
+		-- does not surface as an unhandled rejection.
+		first:Catch(function() end)
+
+		client:Destroy()
+	end)
+end)

package/src/Server/InfluxDBService.lua

@@ -0,0 +1,147 @@
+--!strict
+--[=[
+	Centralized service using serviceBag. Lets other packages share a single [InfluxDBClient] and, in
+	tests, swap the underlying request implementation for an [InfluxDBRequestHandlerMock] at the
+	ServiceBag layer -- the same pattern as [PlayerDataStoreService.SetRobloxDataStore].
+
+	```lua
+	-- Production
+	local influxDBService = serviceBag:GetService(require("InfluxDBService"))
+	-- ...after Init, before first use...
+	influxDBService:SetClientConfig({ url = "https://example.com", token = "token" })
+
+	local writeAPI = influxDBService:GetWriteAPI("org", "bucket")
+	writeAPI:QueuePoint(point)
+	```
+
+	```lua
+	-- Tests: inject a mock so nothing hits the network
+	local requestMock = InfluxDBRequestHandlerMock.new()
+	influxDBService:SetRequestHandler(requestMock.Handler)
+	```
+
+	@server
+	@class InfluxDBService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBClient = require("InfluxDBClient")
+local InfluxDBClientConfigUtils = require("InfluxDBClientConfigUtils")
+local InfluxDBWriteAPI = require("InfluxDBWriteAPI")
+local Maid = require("Maid")
+local Promise = require("Promise")
+local ServiceBag = require("ServiceBag")
+
+local InfluxDBService = {}
+InfluxDBService.ServiceName = "InfluxDBService"
+
+export type InfluxDBService = typeof(setmetatable(
+	{} :: {
+		_serviceBag: ServiceBag.ServiceBag,
+		_maid: Maid.Maid,
+		_client: InfluxDBClient.InfluxDBClient?,
+		_requestHandler: InfluxDBWriteAPI.InfluxDBRequestHandler?,
+		_pendingClientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig?,
+	},
+	{} :: typeof({ __index = InfluxDBService })
+))
+
+--[=[
+	Initializes the InfluxDBService. Should be done via [ServiceBag.Init].
+
+	@param serviceBag ServiceBag
+]=]
+function InfluxDBService.Init(self: InfluxDBService, serviceBag: ServiceBag.ServiceBag): ()
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._maid = Maid.new()
+end
+
+--[=[
+	Injects the request handler the underlying client uses to send data, instead of the real
+	[HttpPromise.request]. Pass an [InfluxDBRequestHandlerMock] handler so tests never hit the network.
+	Intended for testing; must be called before the client is first built.
+
+	@param requestHandler InfluxDBRequestHandler
+]=]
+function InfluxDBService.SetRequestHandler(
+	self: InfluxDBService,
+	requestHandler: InfluxDBWriteAPI.InfluxDBRequestHandler
+): ()
+	assert(type(requestHandler) == "function", "Bad requestHandler")
+	assert(not self._client, "Already built client, cannot override requestHandler")
+
+	self._requestHandler = requestHandler
+end
+
+--[=[
+	Sets the client config used to authenticate writes. May be called before or after the client is
+	built; a later config is forwarded to the existing client.
+
+	@param clientConfig InfluxDBClientConfig
+]=]
+function InfluxDBService.SetClientConfig(
+	self: InfluxDBService,
+	clientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig
+): ()
+	assert(InfluxDBClientConfigUtils.isClientConfig(clientConfig), "Bad clientConfig")
+
+	self._pendingClientConfig = clientConfig
+
+	if self._client then
+		self._client:SetClientConfig(clientConfig)
+	end
+end
+
+--[=[
+	Returns the shared [InfluxDBClient], building it on first use with any injected request handler and
+	client config.
+
+	@return InfluxDBClient
+]=]
+function InfluxDBService.GetClient(self: InfluxDBService): InfluxDBClient.InfluxDBClient
+	if self._client then
+		return self._client
+	end
+
+	local client = self._maid:Add(InfluxDBClient.new(self._pendingClientConfig, self._requestHandler))
+	self._client = client
+
+	return client
+end
+
+--[=[
+	Returns the write API for the given org and bucket from the shared client.
+
+	@param org string
+	@param bucket string
+	@param precision string?
+	@return InfluxDBWriteAPI
+]=]
+function InfluxDBService.GetWriteAPI(
+	self: InfluxDBService,
+	org: string,
+	bucket: string,
+	precision: string?
+): InfluxDBWriteAPI.InfluxDBWriteAPI
+	return self:GetClient():GetWriteAPI(org, bucket, precision)
+end
+
+--[=[
+	Flushes every write API on the shared client. Resolves immediately if the client was never built.
+
+	@return Promise<()>
+]=]
+function InfluxDBService.PromiseFlushAll(self: InfluxDBService): Promise.Promise<()>
+	if not self._client then
+		return Promise.resolved()
+	end
+
+	return self._client:PromiseFlushAll()
+end
+
+function InfluxDBService.Destroy(self: InfluxDBService): ()
+	self._maid:DoCleaning()
+end
+
+return InfluxDBService

package/src/Server/InfluxDBService.spec.lua

@@ -0,0 +1,151 @@
+--!strict
+--[[
+	@class InfluxDBService.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBPoint = require("InfluxDBPoint")
+local InfluxDBRequestHandlerMock = require("InfluxDBRequestHandlerMock")
+local InfluxDBService = require("InfluxDBService")
+local Jest = require("Jest")
+local PromiseTestUtils = require("PromiseTestUtils")
+local ServiceBag = require("ServiceBag")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+local FIXED_TIMESTAMP = DateTime.fromUnixTimestampMillis(1600000000000)
+
+local CONFIG = {
+	url = "https://example.com",
+	token = "my-token",
+}
+
+local function newPoint(): InfluxDBPoint.InfluxDBPoint
+	local point = InfluxDBPoint.new("temperature")
+	point:SetTimestamp(FIXED_TIMESTAMP)
+	point:AddFloatField("value", 23.5)
+	return point
+end
+
+-- Boots a service through a ServiceBag with a request mock injected between Init and Start, mirroring
+-- how a consuming package would swap in the mock at the ServiceBag layer.
+local function setup()
+	local serviceBag = ServiceBag.new()
+	local influxDBService = (serviceBag:GetService(InfluxDBService) :: any) :: InfluxDBService.InfluxDBService
+	serviceBag:Init()
+
+	local requestMock = InfluxDBRequestHandlerMock.new()
+	influxDBService:SetRequestHandler(requestMock.Handler)
+
+	serviceBag:Start()
+
+	return serviceBag, influxDBService, requestMock
+end
+
+describe("InfluxDBService.SetRequestHandler", function()
+	it("should route write traffic through the injected mock", function()
+		local serviceBag, influxDBService, requestMock = setup()
+		influxDBService:SetClientConfig(CONFIG)
+
+		local writeAPI = influxDBService:GetWriteAPI("my-org", "my-bucket")
+		writeAPI:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(writeAPI:PromiseFlush())).toEqual(true)
+
+		expect(#requestMock:GetRequests()).toEqual(1)
+		expect((requestMock:GetLastRequest() :: any).Headers.Authorization).toEqual("Token my-token")
+
+		serviceBag:Destroy()
+	end)
+
+	it("should throw on a non-function handler", function()
+		local serviceBag = ServiceBag.new()
+		local influxDBService = (serviceBag:GetService(InfluxDBService) :: any) :: InfluxDBService.InfluxDBService
+		serviceBag:Init()
+
+		expect(function()
+			influxDBService:SetRequestHandler(5 :: any)
+		end).toThrow("Bad requestHandler")
+
+		serviceBag:Destroy()
+	end)
+
+	it("should throw once the client has been built", function()
+		local serviceBag = ServiceBag.new()
+		local influxDBService = (serviceBag:GetService(InfluxDBService) :: any) :: InfluxDBService.InfluxDBService
+		serviceBag:Init()
+		serviceBag:Start()
+
+		-- Building the client locks the seam.
+		influxDBService:GetClient()
+
+		expect(function()
+			influxDBService:SetRequestHandler(InfluxDBRequestHandlerMock.new().Handler)
+		end).toThrow("Already built client")
+
+		serviceBag:Destroy()
+	end)
+end)
+
+describe("InfluxDBService.SetClientConfig", function()
+	it("should throw on an invalid config", function()
+		local serviceBag, influxDBService = setup()
+
+		expect(function()
+			influxDBService:SetClientConfig({ url = "https://example.com" } :: any)
+		end).toThrow("Bad clientConfig")
+
+		serviceBag:Destroy()
+	end)
+
+	it("should apply a config set after the client is built", function()
+		local serviceBag, influxDBService, requestMock = setup()
+
+		-- Build the client and its write API before any config is set.
+		local writeAPI = influxDBService:GetWriteAPI("my-org", "my-bucket")
+
+		influxDBService:SetClientConfig(CONFIG)
+
+		writeAPI:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(writeAPI:PromiseFlush())).toEqual(true)
+
+		expect(#requestMock:GetRequests()).toEqual(1)
+
+		serviceBag:Destroy()
+	end)
+end)
+
+describe("InfluxDBService.GetClient", function()
+	it("should return the same client across calls", function()
+		local serviceBag, influxDBService = setup()
+
+		expect(influxDBService:GetClient()).toBe(influxDBService:GetClient())
+
+		serviceBag:Destroy()
+	end)
+end)
+
+describe("InfluxDBService.PromiseFlushAll", function()
+	it("should resolve when the client was never built", function()
+		local serviceBag, influxDBService = setup()
+
+		expect(PromiseTestUtils.awaitSettled(influxDBService:PromiseFlushAll())).toEqual(true)
+
+		serviceBag:Destroy()
+	end)
+
+	it("should flush buffered points once the client is built", function()
+		local serviceBag, influxDBService, requestMock = setup()
+		influxDBService:SetClientConfig(CONFIG)
+
+		local writeAPI = influxDBService:GetWriteAPI("my-org", "my-bucket")
+		writeAPI:QueuePoint(newPoint())
+
+		expect(PromiseTestUtils.awaitSettled(influxDBService:PromiseFlushAll())).toEqual(true)
+		expect(#requestMock:GetRequests()).toEqual(1)
+
+		serviceBag:Destroy()
+	end)
+end)

package/src/Server/Mocks/InfluxDBRequestHandlerMock.lua

@@ -0,0 +1,132 @@
+--!strict
+--[=[
+	In-memory stand-in for [HttpPromise.request] used to test InfluxDB writes without making real HTTP
+	calls. Inject its [InfluxDBRequestHandlerMock.Handler] wherever an [InfluxDBRequestHandler] is
+	expected -- into [InfluxDBClient.new], via [InfluxDBService.SetRequestHandler], or use
+	[InfluxDBClient.newMock], which wires one up for you.
+
+	Every request handed to the mock is recorded for inspection. By default each request resolves with a
+	204 success response; call [InfluxDBRequestHandlerMock.SetResponder] to control the response (for
+	example to simulate a failure).
+
+	```lua
+	local requestMock = InfluxDBRequestHandlerMock.new()
+	local client = InfluxDBClient.new(config, requestMock.Handler)
+	-- ...write some points...
+	print(#requestMock:GetRequests())
+	```
+
+	@server
+	@class InfluxDBRequestHandlerMock
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local HttpPromise = require("HttpPromise")
+local Promise = require("Promise")
+
+local InfluxDBRequestHandlerMock = {}
+InfluxDBRequestHandlerMock.ClassName = "InfluxDBRequestHandlerMock"
+InfluxDBRequestHandlerMock.__index = InfluxDBRequestHandlerMock
+
+--[=[
+	A responder controls how the mock answers a request, so a test can resolve or reject however it needs.
+
+	@type Responder (request: HttpPromise.HTTPRequest) -> Promise<HttpPromise.HTTPResponse>
+	@within InfluxDBRequestHandlerMock
+]=]
+export type Responder = (request: HttpPromise.HTTPRequest) -> Promise.Promise<HttpPromise.HTTPResponse>
+
+export type InfluxDBRequestHandlerMock = typeof(setmetatable(
+	{} :: {
+		-- The request handler function to inject; recording is done through it.
+		Handler: Responder,
+		_requests: { HttpPromise.HTTPRequest },
+		_responder: Responder?,
+	},
+	{} :: typeof({ __index = InfluxDBRequestHandlerMock })
+))
+
+local function defaultResponse(): HttpPromise.HTTPResponse
+	return {
+		Success = true,
+		StatusCode = 204,
+		StatusMessage = "No Content",
+		Headers = {},
+		Body = "",
+	}
+end
+
+--[=[
+	Returns whether the given value is an [InfluxDBRequestHandlerMock].
+
+	@param value any
+	@return boolean
+]=]
+function InfluxDBRequestHandlerMock.isInfluxDBRequestHandlerMock(value: any): boolean
+	return type(value) == "table" and getmetatable(value) == InfluxDBRequestHandlerMock
+end
+
+--[=[
+	Constructs a new InfluxDBRequestHandlerMock.
+
+	@return InfluxDBRequestHandlerMock
+]=]
+function InfluxDBRequestHandlerMock.new(): InfluxDBRequestHandlerMock
+	local self: InfluxDBRequestHandlerMock = setmetatable({} :: any, InfluxDBRequestHandlerMock)
+
+	self._requests = {}
+	self._responder = nil
+
+	-- Bound closure so it can be passed wherever a plain [InfluxDBRequestHandler] function is expected.
+	self.Handler = function(request)
+		return self:_handleRequest(request)
+	end
+
+	return self
+end
+
+function InfluxDBRequestHandlerMock._handleRequest(
+	self: InfluxDBRequestHandlerMock,
+	request: HttpPromise.HTTPRequest
+): Promise.Promise<HttpPromise.HTTPResponse>
+	table.insert(self._requests, request)
+
+	if self._responder then
+		return self._responder(request)
+	end
+
+	return Promise.resolved(defaultResponse())
+end
+
+--[=[
+	Sets a responder invoked for each subsequent request, letting a test resolve or reject however it
+	needs. Pass nil to restore the default 204 success response.
+
+	@param responder Responder?
+]=]
+function InfluxDBRequestHandlerMock.SetResponder(self: InfluxDBRequestHandlerMock, responder: Responder?): ()
+	assert(type(responder) == "function" or responder == nil, "Bad responder")
+
+	self._responder = responder
+end
+
+--[=[
+	Returns every request handed to the mock, in order.
+
+	@return { HttpPromise.HTTPRequest }
+]=]
+function InfluxDBRequestHandlerMock.GetRequests(self: InfluxDBRequestHandlerMock): { HttpPromise.HTTPRequest }
+	return self._requests
+end
+
+--[=[
+	Returns the most recent request handed to the mock, or nil if there have been none.
+
+	@return HttpPromise.HTTPRequest?
+]=]
+function InfluxDBRequestHandlerMock.GetLastRequest(self: InfluxDBRequestHandlerMock): HttpPromise.HTTPRequest?
+	return self._requests[#self._requests]
+end
+
+return InfluxDBRequestHandlerMock

package/src/Server/Mocks/InfluxDBRequestHandlerMock.spec.lua

@@ -0,0 +1,107 @@
+--!strict
+--[[
+	@class InfluxDBRequestHandlerMock.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBRequestHandlerMock = require("InfluxDBRequestHandlerMock")
+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
+
+local function request(url: string): any
+	return {
+		Method = "POST",
+		Url = url,
+		Headers = {},
+		Body = "",
+	}
+end
+
+describe("InfluxDBRequestHandlerMock.isInfluxDBRequestHandlerMock", function()
+	it("should be true for a mock", function()
+		expect(InfluxDBRequestHandlerMock.isInfluxDBRequestHandlerMock(InfluxDBRequestHandlerMock.new())).toEqual(true)
+	end)
+
+	it("should be false for other values", function()
+		expect(InfluxDBRequestHandlerMock.isInfluxDBRequestHandlerMock(nil)).toEqual(false)
+		expect(InfluxDBRequestHandlerMock.isInfluxDBRequestHandlerMock({})).toEqual(false)
+		expect(InfluxDBRequestHandlerMock.isInfluxDBRequestHandlerMock(5)).toEqual(false)
+	end)
+end)
+
+describe("InfluxDBRequestHandlerMock.Handler", function()
+	it("should record each request in order", function()
+		local mock = InfluxDBRequestHandlerMock.new()
+
+		mock.Handler(request("https://a.example.com"))
+		mock.Handler(request("https://b.example.com"))
+
+		local requests = mock:GetRequests()
+		expect(#requests).toEqual(2)
+		expect(requests[1].Url).toEqual("https://a.example.com")
+		expect(requests[2].Url).toEqual("https://b.example.com")
+	end)
+
+	it("should resolve with a default success response", function()
+		local mock = InfluxDBRequestHandlerMock.new()
+
+		local outcome, payload = PromiseTestUtils.awaitOutcome(mock.Handler(request("https://a.example.com")))
+		expect(outcome).toEqual("resolved")
+		expect(payload.Success).toEqual(true)
+		expect(payload.StatusCode).toEqual(204)
+	end)
+end)
+
+describe("InfluxDBRequestHandlerMock.GetLastRequest", function()
+	it("should return nil before any request", function()
+		local mock = InfluxDBRequestHandlerMock.new()
+		expect(mock:GetLastRequest()).toEqual(nil)
+	end)
+
+	it("should return the most recent request", function()
+		local mock = InfluxDBRequestHandlerMock.new()
+		mock.Handler(request("https://a.example.com"))
+		mock.Handler(request("https://b.example.com"))
+
+		expect((mock:GetLastRequest() :: any).Url).toEqual("https://b.example.com")
+	end)
+end)
+
+describe("InfluxDBRequestHandlerMock.SetResponder", function()
+	it("should route requests through a custom responder", function()
+		local mock = InfluxDBRequestHandlerMock.new()
+		mock:SetResponder(function()
+			return Promise.rejected("boom")
+		end)
+
+		local outcome, payload = PromiseTestUtils.awaitOutcome(mock.Handler(request("https://a.example.com")))
+		expect(outcome).toEqual("rejected")
+		expect(payload).toEqual("boom")
+		-- The request is still recorded even when the responder rejects.
+		expect(#mock:GetRequests()).toEqual(1)
+	end)
+
+	it("should restore the default response when set back to nil", function()
+		local mock = InfluxDBRequestHandlerMock.new()
+		mock:SetResponder(function()
+			return Promise.rejected("boom")
+		end)
+		mock:SetResponder(nil)
+
+		local outcome = PromiseTestUtils.awaitOutcome(mock.Handler(request("https://a.example.com")))
+		expect(outcome).toEqual("resolved")
+	end)
+
+	it("should throw on a non-function, non-nil responder", function()
+		local mock = InfluxDBRequestHandlerMock.new()
+		expect(function()
+			mock:SetResponder(5 :: any)
+		end).toThrow("Bad responder")
+	end)
+end)

package/src/Server/Write/InfluxDBWriteAPI.lua

@@ -24,6 +24,15 @@ local InfluxDBWriteAPI = setmetatable({}, BaseObject)
 InfluxDBWriteAPI.ClassName = "InfluxDBWriteAPI"
 InfluxDBWriteAPI.__index = InfluxDBWriteAPI
 
+--[=[
+	Function used to actually send a request. Defaults to [HttpPromise.request], but can be injected so
+	tests can stand in a mock (see [InfluxDBRequestHandlerMock]) instead of making real HTTP calls.
+
+	@type InfluxDBRequestHandler (request: HttpPromise.HTTPRequest) -> Promise<HttpPromise.HTTPResponse>
+	@within InfluxDBWriteAPI
+]=]
+export type InfluxDBRequestHandler = (request: HttpPromise.HTTPRequest) -> Promise.Promise<HttpPromise.HTTPResponse>
+
 export type InfluxDBWriteAPI =
 	typeof(setmetatable(
 		{} :: {
@@ -38,6 +47,7 @@ export type InfluxDBWriteAPI =
 			_pointSettings: InfluxDBPointSettings.InfluxDBPointSettings,
 			_writeOptions: InfluxDBWriteOptionUtils.InfluxDBWriteOptions,
 			_writeBuffer: InfluxDBWriteBuffer.InfluxDBWriteBuffer,
+			_requestHandler: InfluxDBRequestHandler,
 		},
 		{} :: typeof({ __index = InfluxDBWriteAPI })
 	))
@@ -49,14 +59,23 @@ export type InfluxDBWriteAPI =
 	@param org string
 	@param bucket string
 	@param precision string?
+	@param requestHandler InfluxDBRequestHandler? -- Defaults to [HttpPromise.request]. Inject a mock to avoid real HTTP.
 	@return InfluxDBWriteAPI
 ]=]
-function InfluxDBWriteAPI.new(org: string, bucket: string, precision: string?): InfluxDBWriteAPI
+function InfluxDBWriteAPI.new(
+	org: string,
+	bucket: string,
+	precision: string?,
+	requestHandler: InfluxDBRequestHandler?
+): InfluxDBWriteAPI
 	local self: InfluxDBWriteAPI = setmetatable(BaseObject.new() :: any, InfluxDBWriteAPI)
 
 	assert(type(org) == "string", "Bad org")
 	assert(type(bucket) == "string", "Bad bucket")
 	assert(type(precision) == "string" or precision == nil, "Bad precision")
+	assert(type(requestHandler) == "function" or requestHandler == nil, "Bad requestHandler")
+
+	self._requestHandler = requestHandler or (HttpPromise.request :: any)
 
 	self._clientConfig = self._maid:Add(ValueObject.new(nil))
 
@@ -193,7 +212,7 @@ function InfluxDBWriteAPI._promiseSendBatch(self: InfluxDBWriteAPI, toSend: { st
 	end
 
 	return self._maid
-		:GivePromise(HttpPromise.request(request))
+		:GivePromise(self._requestHandler(request))
 		:Then(function(result)
 			if result.Success then
 				if self.Destroy then

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)