@quenty/influxdbclient 7.37.0 → 7.39.0

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/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/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