317 lines
9.0 KiB
Swift
Executable File
317 lines
9.0 KiB
Swift
Executable File
import Dependencies
|
|
import Logging
|
|
import Models
|
|
import MQTTNIO
|
|
import NIO
|
|
import PsychrometricClientLive
|
|
@testable import SensorsService
|
|
import TopicDependencies
|
|
import XCTest
|
|
|
|
final class SensorsClientTests: XCTestCase {
|
|
|
|
static let hostname = ProcessInfo.processInfo.environment["MOSQUITTO_SERVER"] ?? "localhost"
|
|
|
|
static let logger: Logger = {
|
|
var logger = Logger(label: "SensorsClientTests")
|
|
logger.logLevel = .debug
|
|
return logger
|
|
}()
|
|
|
|
override func invokeTest() {
|
|
withDependencies {
|
|
$0.psychrometricClient = PsychrometricClient.liveValue
|
|
} operation: {
|
|
super.invokeTest()
|
|
}
|
|
}
|
|
|
|
func testWhatHappensIfClientDisconnectsWhileListening() async throws {
|
|
let client = createClient(identifier: "testWhatHappensIfClientDisconnectsWhileListening")
|
|
let listener = TopicListener.live(client: client)
|
|
try await client.connect()
|
|
|
|
let stream = try await listener.listen("/some/topic")
|
|
|
|
// try await Task.sleep(for: .seconds(1))
|
|
// try await client.disconnect()
|
|
//
|
|
// try await client.connect()
|
|
// try await Task.sleep(for: .seconds(1))
|
|
try await client.publish(
|
|
to: "/some/topic",
|
|
payload: ByteBufferAllocator().buffer(string: "Foo"),
|
|
qos: .atLeastOnce,
|
|
retain: true
|
|
)
|
|
try await Task.sleep(for: .seconds(1))
|
|
|
|
listener.shutdown()
|
|
try await client.shutdown()
|
|
}
|
|
|
|
// func testConnectAndShutdown() async throws {
|
|
// let client = createClient(identifier: "testConnectAndShutdown")
|
|
// await client.connect()
|
|
// await client.shutdown()
|
|
// }
|
|
|
|
// func testSensorService() async throws {
|
|
// let mqtt = createClient(identifier: "testSensorService")
|
|
// // let mqtt = await client.client
|
|
// let sensor = TemperatureAndHumiditySensor(location: .mixedAir)
|
|
// let publishInfo = PublishInfoContainer(topicFilters: [
|
|
// sensor.topics.dewPoint,
|
|
// sensor.topics.enthalpy
|
|
// ])
|
|
// let service = SensorsService(client: mqtt, sensors: [sensor])
|
|
//
|
|
// // fix to connect the mqtt client.
|
|
// try await mqtt.connect()
|
|
// let task = Task { try await service.run() }
|
|
//
|
|
// _ = try await mqtt.subscribe(to: [
|
|
// MQTTSubscribeInfo(topicFilter: sensor.topics.dewPoint, qos: .exactlyOnce),
|
|
// MQTTSubscribeInfo(topicFilter: sensor.topics.enthalpy, qos: .exactlyOnce)
|
|
// ])
|
|
//
|
|
// let listener = mqtt.createPublishListener()
|
|
// Task {
|
|
// for await result in listener {
|
|
// switch result {
|
|
// case let .failure(error):
|
|
// XCTFail("\(error)")
|
|
// case let .success(value):
|
|
// await publishInfo.addPublishInfo(value)
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// try await mqtt.publish(
|
|
// to: sensor.topics.temperature,
|
|
// payload: ByteBufferAllocator().buffer(string: "75.123"),
|
|
// qos: MQTTQoS.exactlyOnce,
|
|
// retain: true
|
|
// )
|
|
//
|
|
// try await Task.sleep(for: .seconds(1))
|
|
//
|
|
// // XCTAssert(client.sensors.first!.needsProcessed)
|
|
// // let firstSensor = await client.sensors.first!
|
|
// // XCTAssertEqual(firstSensor.temperature, .init(75.123, units: .celsius))
|
|
//
|
|
// try await mqtt.publish(
|
|
// to: sensor.topics.humidity,
|
|
// payload: ByteBufferAllocator().buffer(string: "50"),
|
|
// qos: MQTTQoS.exactlyOnce,
|
|
// retain: true
|
|
// )
|
|
//
|
|
// try await Task.sleep(for: .seconds(1))
|
|
//
|
|
// // not working for some reason
|
|
// // XCTAssertEqual(publishInfo.info.count, 2)
|
|
//
|
|
// XCTAssert(publishInfo.info.count > 1)
|
|
//
|
|
// // fix to shutdown the mqtt client.
|
|
// task.cancel()
|
|
// try await mqtt.shutdown()
|
|
// }
|
|
|
|
// func testCapturingSensorClient() async throws {
|
|
// class CapturedValues {
|
|
// var values = [(value: Double, topic: String)]()
|
|
// var didShutdown = false
|
|
//
|
|
// init() {}
|
|
// }
|
|
//
|
|
// let capturedValues = CapturedValues()
|
|
//
|
|
// try await withDependencies {
|
|
// $0.sensorsClient = .testing(
|
|
// yielding: [
|
|
// (value: 76, to: "not-listening"),
|
|
// (value: 75, to: "test")
|
|
// ]
|
|
// ) { value, topic in
|
|
// capturedValues.values.append((value, topic))
|
|
// } captureShutdownEvent: {
|
|
// capturedValues.didShutdown = $0
|
|
// }
|
|
// } operation: {
|
|
// @Dependency(\.sensorsClient) var client
|
|
// let stream = try await client.listen(to: ["test"])
|
|
//
|
|
// for await result in stream {
|
|
// var buffer = result.buffer
|
|
// guard let double = Double(buffer: &buffer) else {
|
|
// XCTFail("Failed to decode double")
|
|
// return
|
|
// }
|
|
//
|
|
// XCTAssertEqual(double, 75)
|
|
// XCTAssertEqual(result.topic, "test")
|
|
// try await client.publish(26, to: "publish")
|
|
// try await Task.sleep(for: .milliseconds(100))
|
|
// client.shutdown()
|
|
// }
|
|
//
|
|
// XCTAssertEqual(capturedValues.values.count, 1)
|
|
// XCTAssertEqual(capturedValues.values.first?.value, 26)
|
|
// XCTAssertEqual(capturedValues.values.first?.topic, "publish")
|
|
// XCTAssertTrue(capturedValues.didShutdown)
|
|
// }
|
|
// }
|
|
//
|
|
// func testSensorCapturesPublishedState() async throws {
|
|
// let client = createClient(identifier: "testSensorCapturesPublishedState")
|
|
// let mqtt = client.client
|
|
// let sensor = TemperatureAndHumiditySensor(location: .mixedAir)
|
|
// let publishInfo = PublishInfoContainer(topicFilters: [
|
|
// sensor.topics.dewPoint,
|
|
// sensor.topics.enthalpy
|
|
// ])
|
|
//
|
|
// try await client.addSensor(sensor)
|
|
// await client.connect()
|
|
// try await client.start()
|
|
//
|
|
// _ = try await mqtt.subscribe(to: [
|
|
// MQTTSubscribeInfo(topicFilter: sensor.topics.dewPoint, qos: MQTTQoS.exactlyOnce),
|
|
// MQTTSubscribeInfo(topicFilter: sensor.topics.enthalpy, qos: MQTTQoS.exactlyOnce)
|
|
// ])
|
|
//
|
|
// let listener = mqtt.createPublishListener()
|
|
// Task {
|
|
// for await result in listener {
|
|
// switch result {
|
|
// case let .failure(error):
|
|
// XCTFail("\(error)")
|
|
// case let .success(value):
|
|
// await publishInfo.addPublishInfo(value)
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// try await mqtt.publish(
|
|
// to: sensor.topics.temperature,
|
|
// payload: ByteBufferAllocator().buffer(string: "75.123"),
|
|
// qos: MQTTQoS.exactlyOnce,
|
|
// retain: true
|
|
// )
|
|
//
|
|
// try await Task.sleep(for: .seconds(1))
|
|
//
|
|
// // XCTAssert(client.sensors.first!.needsProcessed)
|
|
// let firstSensor = client.sensors.first!
|
|
// XCTAssertEqual(firstSensor.temperature, DryBulb.celsius(75.123))
|
|
//
|
|
// try await mqtt.publish(
|
|
// to: sensor.topics.humidity,
|
|
// payload: ByteBufferAllocator().buffer(string: "50"),
|
|
// qos: MQTTQoS.exactlyOnce,
|
|
// retain: true
|
|
// )
|
|
//
|
|
// try await Task.sleep(for: .seconds(1))
|
|
//
|
|
// XCTAssertEqual(publishInfo.info.count, 2)
|
|
//
|
|
// await client.shutdown()
|
|
// }
|
|
|
|
func createClient(identifier: String) -> MQTTClient {
|
|
let envVars = EnvVars(
|
|
appEnv: .testing,
|
|
host: Self.hostname,
|
|
port: "1883",
|
|
identifier: identifier,
|
|
userName: nil,
|
|
password: nil
|
|
)
|
|
let config = MQTTClient.Configuration(
|
|
version: .v3_1_1,
|
|
userName: envVars.userName,
|
|
password: envVars.password,
|
|
useSSL: false,
|
|
useWebSockets: false,
|
|
tlsConfiguration: nil,
|
|
webSocketURLPath: nil
|
|
)
|
|
return .init(
|
|
host: Self.hostname,
|
|
identifier: identifier,
|
|
eventLoopGroupProvider: .shared(MultiThreadedEventLoopGroup(numberOfThreads: 1)),
|
|
logger: Self.logger,
|
|
configuration: config
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: Helpers for tests.
|
|
|
|
extension AsyncStream {
|
|
func first() async -> Element {
|
|
var first: Element
|
|
for await value in self {
|
|
first = value
|
|
}
|
|
return first
|
|
}
|
|
}
|
|
|
|
class PublishInfoContainer {
|
|
private(set) var info: [MQTTPublishInfo]
|
|
private var topicFilters: [String]?
|
|
|
|
init(topicFilters: [String]? = nil) {
|
|
self.info = []
|
|
self.topicFilters = topicFilters
|
|
}
|
|
|
|
func addPublishInfo(_ info: MQTTPublishInfo) async {
|
|
guard let topicFilters else {
|
|
self.info.append(info)
|
|
return
|
|
}
|
|
if topicFilters.contains(info.topicName) {
|
|
self.info.append(info)
|
|
}
|
|
}
|
|
}
|
|
|
|
// extension SensorsClient {
|
|
//
|
|
// static func testing(
|
|
// yielding: [(value: Double, to: String)],
|
|
// capturePublishedValues: @escaping (Double, String) -> Void,
|
|
// captureShutdownEvent: @escaping (Bool) -> Void
|
|
// ) -> Self {
|
|
// let (stream, continuation) = AsyncStream.makeStream(of: PublishInfo.self)
|
|
// let logger = Logger(label: "\(Self.self).testing")
|
|
//
|
|
// return .init(
|
|
// listen: { topics in
|
|
// for (value, topic) in yielding where topics.contains(topic) {
|
|
// continuation.yield(
|
|
// (buffer: ByteBuffer(string: "\(value)"), topic: topic)
|
|
// )
|
|
// }
|
|
// return stream
|
|
// },
|
|
// logger: logger,
|
|
// publish: { value, topic in
|
|
// capturePublishedValues(value, topic)
|
|
// },
|
|
// shutdown: {
|
|
// captureShutdownEvent(true)
|
|
// continuation.finish()
|
|
// }
|
|
// )
|
|
// }
|
|
// }
|
|
|
|
struct TopicNotFoundError: Error {}
|