meshtastic 0.0.176 → 0.0.177

data/spec/lib/meshtastic/bluetooth/bluez_spec.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Meshtastic::Bluetooth::BlueZ do # rubocop:disable Metrics/BlockLength
+  let(:address) { 'AA:BB:CC:DD:EE:FF' }
+
+  let(:device_path) { '/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF' }
+  let(:service_path) { "#{device_path}/service0001" }
+  let(:socket) { instance_double(UNIXSocket, close: nil, closed?: false) }
+  let(:bus) { double('private D-Bus connection', message_queue: double(socket: socket)) }
+  let(:calls) { [] }
+  let(:objects) do
+    {
+      '/org/bluez/hci0' => { 'org.bluez.Adapter1' => { 'Powered' => true } },
+      device_path => { 'org.bluez.Device1' => { 'Address' => address, 'Adapter' => '/org/bluez/hci0', 'Name' => 'Mesh', 'UUIDs' => [described_class::SERVICE_UUID], 'Paired' => true, 'Connected' => false, 'ServicesResolved' => true } },
+      service_path => { 'org.bluez.GattService1' => { 'UUID' => described_class::SERVICE_UUID, 'Device' => device_path } },
+      "#{service_path}/to" => { 'org.bluez.GattCharacteristic1' => { 'UUID' => described_class::TORADIO_UUID, 'Service' => service_path } },
+      "#{service_path}/from" => { 'org.bluez.GattCharacteristic1' => { 'UUID' => described_class::FROMRADIO_UUID, 'Service' => service_path } }
+    }
+  end
+  let(:backend) { described_class.new(address: address, timeout: 0.03) }
+
+  before do
+    allow(DBus::ASystemBus).to receive(:allocate).and_return(bus)
+    allow(bus).to receive(:initialize)
+    allow(bus).to receive(:send_sync_or_async) do |message|
+      calls << message
+      case message.member
+      when 'GetManagedObjects' then [objects]
+      when 'GetAll' then [objects.fetch(message.path).fetch(message.params.first.last)]
+      when 'Connect' then objects[device_path]['org.bluez.Device1']['Connected'] = true
+                          []
+      when 'Disconnect' then objects[device_path]['org.bluez.Device1']['Connected'] = false
+                             []
+      else []
+      end
+    end
+  end
+
+  it 'connects a paired device on the chosen powered adapter' do
+    expect(backend.connect).to equal(backend)
+    expect(calls.find { |call| call.member == 'Connect' }.path).to eq(device_path)
+  end
+
+  it 'requires pre-pairing and releases the bus after a refused connection' do
+    objects[device_path]['org.bluez.Device1']['Paired'] = false
+    expect { backend.connect }.to raise_error(IOError, /bluetoothctl pair AA:BB:CC:DD:EE:FF/)
+    expect(calls.map(&:member)).not_to include('Connect', 'Pair', 'Disconnect')
+    expect(socket).to have_received(:close).once
+  end
+
+  it 'rejects unavailable or unpowered adapters and missing devices without connecting' do
+    objects['/org/bluez/hci0']['org.bluez.Adapter1']['Powered'] = false
+    expect { backend.connect }.to raise_error(IOError, /powered/)
+    objects.delete('/org/bluez/hci0')
+    expect { backend.connect }.to raise_error(IOError, /adapter/)
+    objects['/org/bluez/hci0'] = { 'org.bluez.Adapter1' => { 'Powered' => true } }
+    objects.delete(device_path)
+    expect { backend.connect }.to raise_error(IOError, /not found/)
+    expect(calls.map(&:member)).not_to include('Connect')
+  end
+
+  it 'writes one unframed protobuf to the characteristic scoped to the chosen device and service' do
+    wrong_service = "#{device_path}/wrong"
+    decoys = {
+      '/other/service' => { 'org.bluez.GattService1' => { 'UUID' => described_class::SERVICE_UUID, 'Device' => '/other' } },
+      '/other/to' => { 'org.bluez.GattCharacteristic1' => { 'UUID' => described_class::TORADIO_UUID, 'Service' => '/other/service' } },
+      "#{wrong_service}/to" => { 'org.bluez.GattCharacteristic1' => { 'UUID' => described_class::TORADIO_UUID, 'Service' => wrong_service } }
+    }
+    objects.replace(decoys.merge(objects))
+    bytes = "\x00\xFF\x94\xC3".b * 100
+    backend.connect
+    expect(backend.write(bytes)).to eq(bytes.bytesize)
+    writes = calls.select { |call| call.member == 'WriteValue' }
+    expect(writes.size).to eq(1)
+    expect(writes.first.path).to eq("#{service_path}/to")
+    expect(writes.first.params).to eq([['ay', bytes.bytes], ['a{sv}', { 'type' => %w[s request] }]])
+  end
+
+  it 'reads raw binary FromRadio bytes and returns binary empty strings for an empty queue' do
+    backend.connect
+
+    allow(bus).to receive(:send_sync_or_async).with(have_attributes(member: 'ReadValue')).and_return([[0, 255, 128]], [[]])
+    expect(backend.read).to eq("\x00\xFF\x80".b)
+    expect(backend.read).to eq(''.b)
+    expect(bus).to have_received(:send_sync_or_async).with(have_attributes(path: "#{service_path}/from", member: 'ReadValue', params: [['a{sv}', {}]])).twice
+  end
+
+  it 'waits for ServicesResolved before selecting required characteristics, bounded by timeout' do
+    objects[device_path]['org.bluez.Device1']['ServicesResolved'] = false
+    expect { backend.connect }.to raise_error(IOError, /ServicesResolved.*timed out/)
+    expect(calls.map(&:member)).to include('Disconnect')
+    expect(socket).to have_received(:close).once
+  end
+
+  it 'requires both characteristics under the Meshtastic service during connect' do
+    objects.delete("#{service_path}/from")
+    expect { backend.connect }.to raise_error(IOError, /characteristic/)
+    expect(calls.map(&:member)).to include('Disconnect')
+  end
+
+  it 'raises on disconnected reads and writes instead of treating disconnect as an empty queue' do
+    backend.connect
+    objects[device_path]['org.bluez.Device1']['Connected'] = false
+    allow(bus).to receive(:send_sync_or_async).with(have_attributes(member: 'ReadValue')).and_return([[]])
+    expect { backend.read }.to raise_error(IOError, /disconnected/)
+    expect { backend.write('data') }.to raise_error(IOError, /disconnected/)
+    expect(calls.map(&:member)).not_to include('ReadValue', 'WriteValue')
+  end
+
+  it 'bounds a stalled D-Bus call and discards the interrupted connection' do
+    backend.connect
+    allow(bus).to receive(:send_sync_or_async).with(have_attributes(member: 'ReadValue')) {
+      sleep 1
+      [[]]
+    }
+    started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    expect { backend.read }.to raise_error(IOError, /timed out/)
+    expect(Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).to be < 0.5
+    expect(socket).to have_received(:close).once
+    expect { backend.read }.to raise_error(IOError, /disconnected/)
+  end
+
+  it 'bounds D-Bus initialization and closes partially initialized resources' do
+    allow(bus).to receive(:initialize) { sleep 1 }
+    expect { backend.connect }.to raise_error(IOError, /timed out/)
+    expect(socket).to have_received(:close).once
+  end
+
+  it 'serializes read, write and close on the private D-Bus connection' do
+    connection = described_class.new(address: address, timeout: 1)
+    connection.connect
+    entered = Queue.new
+    release = Queue.new
+    reading = false
+    overlap = false
+    allow(bus).to receive(:send_sync_or_async).with(have_attributes(member: 'ReadValue')) do
+      reading = true
+      entered << true
+      release.pop
+      reading = false
+      [[]]
+    end
+    %w[WriteValue Disconnect].each do |member|
+      allow(bus).to receive(:send_sync_or_async).with(have_attributes(member: member)) {
+        overlap ||= reading
+        []
+      }
+    end
+    reader = Thread.new { connection.read }
+    entered.pop
+    writer = Thread.new do
+      connection.write('data')
+    rescue StandardError
+      IOError
+    end
+    closer = Thread.new { connection.close }
+    sleep 0.02
+    release << true
+    [reader, writer, closer].each(&:join)
+    expect(overlap).to be(false)
+    expect(socket).to have_received(:close).once
+    connection.close
+    expect(socket).to have_received(:close).once
+  end
+
+  it 'scans only Meshtastic devices on the requested adapter and releases its discovery session' do
+    objects['/other'] = { 'org.bluez.Device1' => objects[device_path]['org.bluez.Device1'].merge('Adapter' => '/org/bluez/hci1') }
+    objects['/nonmesh'] = { 'org.bluez.Device1' => objects[device_path]['org.bluez.Device1'].merge('UUIDs' => []) }
+    expect(described_class.scan(adapter: 'hci0', timeout: 0.001)).to eq([{ address: address, name: 'Mesh', paired: true }])
+    expect(calls.map(&:member)).to include('StartDiscovery', 'StopDiscovery')
+    expect(calls.map(&:member)).not_to include('Connect', 'Pair', 'Disconnect')
+    expect(calls.find { |call| call.member == 'StartDiscovery' }.path).to eq('/org/bluez/hci0')
+    expect(socket).to have_received(:close).once
+  end
+
+  it 'rejects invalid adapter names and nonpositive or nonfinite timeouts' do
+    ['../hci0', 'hci0/foo', nil].each do |adapter|
+      expect { described_class.new(address: address, adapter: adapter) }.to raise_error(ArgumentError, /adapter/)
+    end
+    [0, -1, Float::INFINITY, Float::NAN, '5'].each do |timeout|
+      expect { described_class.new(address: address, timeout: timeout) }.to raise_error(ArgumentError, /timeout/)
+    end
+  end
+
+  it 'rejects malformed Bluetooth addresses before accessing D-Bus' do
+    expect { described_class.new(address: 'AA-BB-CC-DD-EE-FF') }.to raise_error(ArgumentError, /address/)
+  end
+end

data/spec/lib/meshtastic/bluetooth_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Meshtastic::Bluetooth do
+  let(:connection) do
+    Class.new do
+      attr_reader :writes, :incoming
+
+      def initialize
+        @writes = []
+        @incoming = Queue.new
+        @closed = false
+      end
+
+      def connect
+        self
+      end
+
+      def write(bytes)
+        raise IOError, 'disconnected' if @closed
+
+        @writes << bytes
+        bytes.bytesize
+      end
+
+      def read
+        raise IOError, 'disconnected' if @closed
+
+        @incoming.pop(true)
+      rescue ThreadError
+        ''.b
+      end
+
+      def close
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+    end.new
+  end
+
+  before do
+    backend = Class.new
+    stub_const('Meshtastic::Bluetooth::BlueZ', backend)
+    allow(backend).to receive(:new).with(address: 'AA:BB:CC:DD:EE:FF', adapter: 'hci0', timeout: 15).and_return(connection)
+  end
+
+  after do
+    described_class.disconnect(bluetooth_obj: @bluetooth_obj) if @bluetooth_obj
+  end
+
+  def connect(opts = {})
+    @bluetooth_obj = described_class.connect({ address: 'AA:BB:CC:DD:EE:FF', want_config: false }.merge(opts))
+  end
+
+  it 'writes text as a raw ToRadio protobuf without UART framing' do
+    handle = connect
+    size = described_class.send_text(bluetooth_obj: handle, text: 'hello', to: '!83726fb1', channel: 0, want_ack: true)
+    bytes = connection.writes.last
+    packet = Meshtastic::ToRadio.decode(bytes).packet
+    expect(size).to eq(bytes.bytesize)
+    expect(packet.decoded.payload).to eq('hello')
+    expect(packet.to).to eq(0x83726fb1)
+    expect(packet.channel).to eq(0)
+    expect(packet.want_ack).to be(true)
+    expect(packet.encrypted).to eq('')
+    expect(packet.from).to eq(0)
+  end
+
+  it 'receives FromRadio messages and completes the matching configuration handshake' do
+    handle = connect(want_config: true)
+    config_id = Meshtastic::ToRadio.decode(connection.writes.first).want_config_id
+    expect(config_id).to be_positive
+    info = Meshtastic::FromRadio.new(my_info: Meshtastic::MyNodeInfo.new(my_node_num: 123))
+    connection.incoming << info.to_proto
+    connection.incoming << Meshtastic::FromRadio.new(config_complete_id: config_id).to_proto
+    expect(described_class.wait_for_config(bluetooth_obj: handle, timeout: 1)).to eq(handle)
+    expect(handle[:my_node_num]).to eq(123)
+    expect(described_class.recv_from_radio(bluetooth_obj: handle, timeout: 0)).to eq(info)
+  end
+
+  it 'subscribes to filtered text messages with the same decoded hashes as Serial' do
+    handle = connect
+    %w[hidden hello].each do |text|
+      connection.incoming << Meshtastic::FromRadio.new(packet: Meshtastic::MeshPacket.new(
+        from: 123, to: 0xffffffff, channel: 0,
+        decoded: Meshtastic::Data.new(portnum: :TEXT_MESSAGE_APP, payload: text)
+      )).to_proto
+    end
+    received = Timeout.timeout(1) do
+      described_class.subscribe(bluetooth_obj: handle, include: 'TEXT_MESSAGE_APP', exclude: 'hidden', include_raw: true) do |message|
+        break message
+      end
+    end
+    expect(received.dig(:packet, :decoded, :payload)).to eq('hello')
+    expect(received.dig(:packet, :node_id_from)).to eq('!7b')
+    expect(Meshtastic::FromRadio.decode(received.dig(:packet, :raw_packet)).packet.from).to eq(123)
+  end
+
+  it 'sends binary data to a shared channel with device-managed encryption' do
+    handle = connect
+    data = Meshtastic::Data.new(portnum: :PRIVATE_APP, payload: "\x00\xff".b)
+    described_class.send_data(bluetooth_obj: handle, data: data, channel: 2)
+    packet = Meshtastic::ToRadio.decode(connection.writes.last).packet
+    expect(packet.to).to eq(0xffffffff)
+    expect(packet.channel).to eq(2)
+    expect(packet.decoded).to eq(data)
+  end
+
+  it 'drains messages and snapshots or clears per-connection console and protobuf buffers' do
+    handle = connect
+    message = Meshtastic::FromRadio.new(log_record: Meshtastic::LogRecord.new(message: 'BLE log'))
+    connection.incoming << message.to_proto
+    expect(described_class.recv_from_radio(bluetooth_obj: handle, timeout: 1)).to eq(message)
+    expect(described_class.drain_from_radio(bluetooth_obj: handle)).to eq([])
+    expect(described_class.dump_stdout_data(bluetooth_obj: handle, type: :console)).to eq("BLE log\n")
+    expect(described_class.dump_stdout_data(type: :proto)).to eq([message.to_h])
+    yielded = []
+    described_class.dump_stdout_data(bluetooth_obj: handle, type: :console) { |line| yielded << line }
+    expect(yielded).to eq(['BLE log'])
+    described_class.flush_data(bluetooth_obj: handle, type: :console)
+    expect(described_class.dump_stdout_data(bluetooth_obj: handle, type: :console)).to eq('')
+  end
+
+  it 'cleans up a failed GATT write without recursive disconnect attempts' do
+    handle = connect
+    allow(connection).to receive(:write).and_raise(IOError, 'GATT write failed')
+    expect { described_class.send_text(bluetooth_obj: handle, text: 'hello') }.to raise_error(IOError, 'GATT write failed')
+    expect(connection.closed?).to be(true)
+    expect(handle[:rx_thread].alive?).to be(false)
+    expect(handle[:from_radio_queue].closed?).to be(true)
+  end
+
+  it 'scans with the selected adapter and bounded discovery timeout' do
+    devices = [{ address: 'AA:BB:CC:DD:EE:FF', name: 'Meshtastic_test', paired: true }]
+    expect(described_class::BlueZ).to receive(:scan).with(adapter: 'hci1', timeout: 2).and_return(devices)
+    expect(described_class.scan(adapter: 'hci1', timeout: 2)).to eq(devices)
+  end
+
+  it 'prints usage without raising' do
+    expect { described_class.help }.to output(/USAGE/).to_stdout
+  end
+end

data/spec/lib/meshtastic/lorawan_bridge_pb_spec.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Meshtastic::LoRaWANBridge do
+end

data/spec/lib/meshtastic/mqtt_spec.rb

@@ -2,5 +2,164 @@
 
 require 'spec_helper'
 
-describe Meshtastic::MQTT do
+describe Meshtastic::MQTT do # rubocop:disable Metrics/BlockLength
+  def fake_mqtt_obj(client_id: '00000b0b')
+    published = []
+    subscribed = []
+    incoming = Queue.new
+    client = Object.new
+    client.define_singleton_method(:client_id) { client_id }
+    client.define_singleton_method(:published) { published }
+    client.define_singleton_method(:subscribed) { subscribed }
+    client.define_singleton_method(:incoming) { incoming }
+    client.define_singleton_method(:subscribe) do |topic, qos|
+      subscribed << { topic: topic, qos: qos }
+    end
+    client.define_singleton_method(:publish) do |topic, payload|
+      published << { topic: topic, payload: payload }
+      payload.bytesize
+    end
+    client.define_singleton_method(:get_packet) do |&block|
+      loop do
+        packet = incoming.pop
+        break if packet.nil?
+
+        block.call(packet)
+      end
+    end
+    client.define_singleton_method(:disconnect) { @disconnected = true }
+    client.define_singleton_method(:disconnected?) { @disconnected == true }
+    client
+  end
+
+  def mqtt_packet(topic:, payload:)
+    packet = Object.new
+    packet.define_singleton_method(:topic) { topic }
+    packet.define_singleton_method(:payload) { payload }
+    packet.define_singleton_method(:to_s) { payload.to_s }
+    packet
+  end
+
+  def publish_and_subscribe(opts = {})
+    mqtt_obj = fake_mqtt_obj
+    described_class.send_text({ mqtt_obj: mqtt_obj }.merge(opts))
+    published = mqtt_obj.published.last
+    mqtt_obj.incoming << mqtt_packet(topic: published[:topic], payload: published[:payload])
+    mqtt_obj.incoming << nil
+    received = nil
+    described_class.subscribe({ mqtt_obj: mqtt_obj }.merge(opts)) do |message|
+      received = message
+      break
+    end
+    [mqtt_obj, received]
+  end
+
+  describe '.connect' do
+    it 'configures keep_alive and ack_timeout on the MQTT client' do
+      client = instance_double(MQTT::Client, keep_alive: 15, ack_timeout: 30)
+      allow(client).to receive(:keep_alive=)
+      allow(client).to receive(:ack_timeout=)
+      expect(MQTTClient).to receive(:connect).with(
+        hash_including(host: 'localhost', port: 1883, ssl: false, username: 'meshdev', client_id: 'abcd1234')
+      ).and_return(client)
+
+      described_class.connect(host: 'localhost', client_id: 'abcd1234', keep_alive: 15, ack_timeout: 30)
+      expect(client).to have_received(:keep_alive=).with(15)
+      expect(client).to have_received(:ack_timeout=).with(30)
+    end
+  end
+
+  describe '.send_text' do
+    it 'publishes an encrypted ServiceEnvelope without UART framing' do
+      mqtt_obj = fake_mqtt_obj
+      described_class.send_text(
+        mqtt_obj: mqtt_obj,
+        from: '!00000b0b',
+        to: '!ffffffff',
+        channel: 0,
+        text: 'ping',
+        psks: { LongFast: 'AQ==' }
+      )
+      published = mqtt_obj.published.last
+      expect(published[:topic]).to eq('msh/US/2/e/LongFast/!00000b0b')
+      expect(published[:payload].getbyte(0)).not_to eq(Meshtastic::START1)
+      envelope = Meshtastic::ServiceEnvelope.decode(published[:payload])
+      expect(envelope.channel_id).to eq('LongFast')
+      expect(envelope.packet.decoded.to_s).to eq('')
+      expect(envelope.packet.encrypted.to_s).not_to eq('')
+      expect(envelope.packet.to).to eq(0xffffffff)
+      expect(envelope.packet.from).to eq(0xb0b)
+    end
+
+    it 'rejects text exceeding the byte limit without publishing' do
+      mqtt_obj = fake_mqtt_obj
+      expect do
+        described_class.send_text(
+          mqtt_obj: mqtt_obj,
+          text: 'é' * Meshtastic::Constants::DATA_PAYLOAD_LEN
+        )
+      end.to raise_error(ArgumentError, /Bytes/)
+      expect(mqtt_obj.published).to be_empty
+    end
+  end
+
+  describe 'mqtt reception' do
+    it 'decrypts a published text message as UTF-8, never as a nested protobuf' do
+      text = "\n\x02hi"
+      _mqtt_obj, received = publish_and_subscribe(text: text, from: '!00000b0b', psks: { LongFast: 'AQ==' })
+      expect(received.dig(:packet, :decoded, :payload)).to eq(text)
+      expect(received.dig(:packet, :decoded, :payload).encoding).to eq(Encoding::UTF_8)
+      expect(received.dig(:packet, :node_id_from)).to eq('!b0b')
+    end
+
+    it 'yields received text through subscription filters' do
+      mqtt_obj = fake_mqtt_obj
+      %w[hidden hello].each do |text|
+        described_class.send_text(mqtt_obj: mqtt_obj, text: text, from: '!00000b0b', psks: { LongFast: 'AQ==' })
+      end
+      mqtt_obj.published.each do |item|
+        mqtt_obj.incoming << mqtt_packet(topic: item[:topic], payload: item[:payload])
+      end
+      mqtt_obj.incoming << nil
+      received = []
+      described_class.subscribe(mqtt_obj: mqtt_obj, include: 'TEXT_MESSAGE_APP', exclude: 'hidden') do |message|
+        received << message.dig(:packet, :decoded, :payload)
+      end
+      expect(received).to eq(['hello'])
+    end
+
+    it 'subscribes to the assembled root/region/topic path' do
+      mqtt_obj = fake_mqtt_obj
+      mqtt_obj.incoming << nil
+      described_class.subscribe(mqtt_obj: mqtt_obj, root_topic: 'msh', region: 'US', topic: '2/e/LongFast/#', qos: 1)
+      expect(mqtt_obj.subscribed).to eq([{ topic: 'msh/US/2/e/LongFast/#', qos: 1 }])
+    end
+
+    it 'includes the raw MQTT packet when requested' do
+      mqtt_obj, received = publish_and_subscribe(text: 'hello', from: '!00000b0b', include_raw: true)
+      expect(Meshtastic::ServiceEnvelope.decode(received.dig(:packet, :raw_packet)).packet.from).to eq(0xb0b)
+      expect(mqtt_obj.disconnected?).to be(true)
+    end
+
+    it 'requires psks to be a hash of channel keys' do
+      mqtt_obj = fake_mqtt_obj
+      expect do
+        described_class.subscribe(mqtt_obj: mqtt_obj, psks: 'AQ==')
+      end.to raise_error(/psks parameter must be a hash/)
+    end
+  end
+
+  describe '.disconnect' do
+    it 'returns nil and disconnects the MQTT client' do
+      mqtt_obj = fake_mqtt_obj
+      expect(described_class.disconnect(mqtt_obj: mqtt_obj)).to be_nil
+      expect(mqtt_obj.disconnected?).to be(true)
+    end
+  end
+
+  describe '.help' do
+    it 'prints usage without raising' do
+      expect { described_class.help }.to output(/USAGE/).to_stdout
+    end
+  end
 end