meshtastic 0.0.179 → 0.0.181

data/spec/lib/meshtastic/admin/channel_spec.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+shared_context 'channel serial framing' do
+  def fake_serial_obj
+    written = +''.b
+    serial_conn = Object.new
+    serial_conn.define_singleton_method(:write) do |b|
+      written << b
+      b.bytesize
+    end
+    serial_conn.define_singleton_method(:flush) { true }
+    serial_conn.define_singleton_method(:closed?) { false }
+    serial_conn.define_singleton_method(:close) { true }
+    { serial_conn: serial_conn, written: written, my_node_num: 0xb0b }
+  end
+
+  def decode_admin(serial_obj)
+    frame = serial_obj[:written]
+    body = frame.byteslice(4, (frame.getbyte(2) << 8) + frame.getbyte(3))
+    Meshtastic::AdminMessage.decode(Meshtastic::ToRadio.decode(body).packet.decoded.payload)
+  end
+end
+
+describe Meshtastic::Admin::Channel do
+  include_context 'channel serial framing'
+
+  it 'requests a channel by index via Admin' do
+    serial_obj = fake_serial_obj
+    described_class.get(serial_obj: serial_obj, index: 1)
+    expect(decode_admin(serial_obj).get_channel_request).to eq(2)
+  end
+
+  [0, 7].each do |index|
+    it "requests zero-based slot #{index} with its one-based wire index" do
+      serial_obj = fake_serial_obj
+      described_class.get(serial_obj: serial_obj, index: index)
+      expect(decode_admin(serial_obj).get_channel_request).to eq(index + 1)
+    end
+  end
+
+  it 'sets a Channel protobuf including settings and role' do
+    serial_obj = fake_serial_obj
+    settings = described_class.build_settings(name: 'LongFast', uplink_enabled: true)
+    described_class.set(serial_obj: serial_obj, index: 0, role: :PRIMARY, settings: settings)
+    channel = decode_admin(serial_obj).set_channel
+    expect(channel.index).to eq(0)
+    expect(channel.role).to eq(:PRIMARY)
+    expect(channel.settings.name).to eq('LongFast')
+    expect(channel.settings.uplink_enabled).to be true
+  end
+
+  it 'copies an existing channel and preserves settings when changing its role' do
+    original = Meshtastic::Channel.new(index: 2, role: :SECONDARY, settings: { name: 'test', psk: "\x01".b })
+    updated = described_class.build(channel: original, role: :DISABLED)
+    expect(updated.settings).to eq(original.settings)
+    expect(original.role).to eq(:SECONDARY)
+    expect(updated).not_to equal(original)
+  end
+
+  it 'builds all settings including nested hashes without mutating existing settings' do
+    original = Meshtastic::ChannelSettings.new(name: 'before', uplink_enabled: true)
+    settings = described_class.build_settings(settings: original, name: 'after', psk: "\x01".b, channel_num: 3,
+                                              id: 17, uplink_enabled: false, downlink_enabled: true,
+                                              use_aead: true, module_settings: { position_precision: 13 })
+    expect(settings.to_h).to include(name: 'after', psk: "\x01".b, channel_num: 3, id: 17,
+                                     downlink_enabled: true, use_aead: true)
+    expect(settings.uplink_enabled).to be false
+    expect(settings.module_settings.position_precision).to eq(13)
+    expect(original.name).to eq('before')
+    expect(original.uplink_enabled).to be true
+  end
+end
+
+describe Meshtastic::Admin::Channel, 'channel URL support' do
+  include_context 'channel serial framing'
+
+  it 'exports primary first and enabled secondary settings with LoRa in a channel URL' do
+    primary = Meshtastic::Channel.new(index: 0, role: :PRIMARY, settings: { name: 'main', psk: "\x01".b })
+    secondary = Meshtastic::Channel.new(index: 2, role: :SECONDARY, settings: { name: 'other' })
+    disabled = Meshtastic::Channel.new(index: 3, settings: { name: 'hidden' })
+    lora = Meshtastic::Config::LoRaConfig.new(region: :US, use_preset: true)
+    url = described_class.export_url(channels: [secondary, disabled, primary], lora_config: lora)
+    expect(url).to start_with('https://meshtastic.org/e/#')
+    require 'base64'
+    channel_set = Meshtastic::ChannelSet.decode(Base64.urlsafe_decode64(url.split('#').last))
+    expect(channel_set.settings.map(&:name)).to eq(%w[main other])
+    expect(channel_set.lora_config).to eq(lora)
+    expect(url).not_to end_with('=')
+  end
+
+  it 'imports official e and legacy d URLs as offline ChannelSet protobufs' do
+    expected = Meshtastic::ChannelSet.new(settings: [{ name: 'test', psk: "\x01".b }], lora_config: { region: :US })
+    encoded = Base64.urlsafe_encode64(expected.to_proto, padding: false)
+    %w[e d].each do |path|
+      expect(described_class.import_url(url: "https://meshtastic.org/#{path}/##{encoded}")).to eq(expected)
+    end
+  end
+
+  it 'rejects invalid URL envelopes and empty or oversized channel sets without leaking the URL' do
+    empty = Base64.urlsafe_encode64(Meshtastic::ChannelSet.new.to_proto, padding: false)
+    oversized = Base64.urlsafe_encode64(Meshtastic::ChannelSet.new(settings: Array.new(9) { { name: 'test' } }).to_proto, padding: false)
+    valid = Base64.urlsafe_encode64(Meshtastic::ChannelSet.new(settings: [{ name: 'test' }]).to_proto, padding: false)
+    urls = ["https://example.org/e/##{valid}", "https://meshtastic.org/v/##{valid}",
+            'https://meshtastic.org/e/', 'https://meshtastic.org/e/#not!base64',
+            'https://meshtastic.org/e/#_w', "https://meshtastic.org/e/##{empty}",
+            "https://meshtastic.org/e/##{oversized}", "https://user:secret@meshtastic.org/e/##{valid}"]
+    urls.each do |url|
+      expect { described_class.import_url(url: url) }.to raise_error(ArgumentError, 'invalid channel URL')
+    end
+  end
+
+  it 'exports only primary when include_all is false and requires exactly one primary' do
+    primary = Meshtastic::Channel.new(role: :PRIMARY, settings: { name: 'main' })
+    secondary = Meshtastic::Channel.new(index: 1, role: :SECONDARY, settings: { name: 'other' })
+    url = described_class.export_url(channels: [primary, secondary], include_all: false)
+    expect(described_class.import_url(url: url).settings.map(&:name)).to eq(['main'])
+    [[], [secondary], [primary, primary]].each do |channels|
+      expect { described_class.export_url(channels: channels) }.to raise_error(ArgumentError)
+    end
+  end
+
+  it 'rejects invalid settings lengths and slot indexes before any write' do
+    [-1, 8, 0.5, 'junk'].each do |index|
+      serial_obj = fake_serial_obj
+      expect { described_class.set(serial_obj: serial_obj, index: index, role: :PRIMARY) }.to raise_error(ArgumentError)
+      expect(serial_obj[:written]).to be_empty
+    end
+    expect { described_class.build_settings(psk: 'bad') }.to raise_error(ArgumentError)
+    expect { described_class.build_settings(name: 'a' * 12) }.to raise_error(ArgumentError)
+    [0, 1, 16, 32].each do |length|
+      expect(described_class.build_settings(psk: 'x' * length).psk.bytesize).to eq(length)
+    end
+  end
+
+  it 'validates and overlays supplied channel/settings before transmission' do
+    serial_obj = fake_serial_obj
+    original = Meshtastic::Channel.new(index: 2, role: :SECONDARY, settings: { name: 'before', uplink_enabled: true })
+    described_class.set(serial_obj: serial_obj, channel: original, name: 'after', uplink_enabled: false)
+    written = decode_admin(serial_obj).set_channel
+    expect(written.index).to eq(2)
+    expect(written.settings.name).to eq('after')
+    expect(written.settings.uplink_enabled).to be false
+    expect(original.settings.name).to eq('before')
+    expect(described_class.build(settings: { name: 'hash' }).settings.name).to eq('hash')
+    invalid = Meshtastic::Channel.new(index: 8)
+    expect { described_class.set(serial_obj: fake_serial_obj, channel: invalid) }.to raise_error(ArgumentError)
+    expect { described_class.build(settings: { psk: 'bad' }) }.to raise_error(ArgumentError)
+  end
+
+  it 'applies an imported URL as indexed channel writes followed by its LoRa section' do
+    serial_obj = fake_serial_obj
+    channel_set = Meshtastic::ChannelSet.new(settings: [{ name: 'main' }, { name: 'other' }], lora_config: { region: :US })
+    url = "https://meshtastic.org/e/##{Base64.urlsafe_encode64(channel_set.to_proto, padding: false)}"
+    results = described_class.apply_url(serial_obj: serial_obj, url: url, session_passkey: 'test-key')
+    frames = serial_obj[:written].dup
+    messages = []
+    until frames.empty?
+      length = (frames.getbyte(2) << 8) + frames.getbyte(3)
+      packet = Meshtastic::ToRadio.decode(frames.byteslice(4, length)).packet
+      messages << Meshtastic::AdminMessage.decode(packet.decoded.payload)
+      frames = frames.byteslice((length + 4)..)
+    end
+    expect(results.length).to eq(3)
+    expect(messages.map(&:payload_variant)).to eq(%i[set_channel set_channel set_config])
+    expect(messages.first.set_channel.index).to eq(0)
+    expect(messages.first.set_channel.role).to eq(:PRIMARY)
+    expect(messages[1].set_channel.index).to eq(1)
+    expect(messages[1].set_channel.role).to eq(:SECONDARY)
+    expect(messages.last.set_config.lora.region).to eq(:US)
+    expect(messages.map(&:session_passkey)).to all(eq('test-key'))
+  end
+
+  it 'preflights all URL settings and refuses add-only links before writing' do
+    serial_obj = fake_serial_obj
+    invalid = Meshtastic::ChannelSet.new(settings: [{ name: 'good' }, { psk: 'bad' }])
+    url = "https://meshtastic.org/e/##{Base64.urlsafe_encode64(invalid.to_proto, padding: false)}"
+    expect { described_class.apply_url(serial_obj: serial_obj, url: url) }.to raise_error(ArgumentError)
+    expect(serial_obj[:written]).to be_empty
+    valid = Meshtastic::ChannelSet.new(settings: [{ name: 'test' }])
+    url = "https://meshtastic.org/e/?add=true##{Base64.urlsafe_encode64(valid.to_proto, padding: false)}"
+    expect { described_class.apply_url(serial_obj: serial_obj, url: url) }.to raise_error(ArgumentError, /add-only/)
+    expect(serial_obj[:written]).to be_empty
+  end
+
+  it 'rejects unsupported channel roles before writing' do
+    expect { described_class.build(role: 99) }.to raise_error(ArgumentError)
+  end
+
+  it 'rejects oversized or invalid enabled channel sets on export' do
+    primary = Meshtastic::Channel.new(role: :PRIMARY, settings: { name: 'main' })
+    secondary = Meshtastic::Channel.new(role: :SECONDARY, settings: { name: 'other' })
+    expect { described_class.export_url(channels: [primary] + Array.new(8, secondary)) }.to raise_error(ArgumentError)
+    primary.settings.psk = 'bad'
+    expect { described_class.export_url(channels: [primary]) }.to raise_error(ArgumentError)
+  end
+
+  it 'prints usage without raising' do
+    expect { described_class.help }.to output(/USAGE/).to_stdout
+  end
+end

data/spec/lib/meshtastic/admin/config_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Meshtastic::Admin::Config do
+  def fake_serial_obj
+    written = +''.b
+    serial_conn = Object.new
+    serial_conn.define_singleton_method(:write) do |b|
+      written << b
+      b.bytesize
+    end
+    serial_conn.define_singleton_method(:flush) { true }
+    serial_conn.define_singleton_method(:closed?) { false }
+    serial_conn.define_singleton_method(:close) { true }
+    { serial_conn: serial_conn, written: written, my_node_num: 0xb0b }
+  end
+
+  def decode_admin(serial_obj)
+    frame = serial_obj[:written]
+    body = frame.byteslice(4, (frame.getbyte(2) << 8) + frame.getbyte(3))
+    Meshtastic::AdminMessage.decode(Meshtastic::ToRadio.decode(body).packet.decoded.payload)
+  end
+
+  it 'requests LoRa config via Admin' do
+    serial_obj = fake_serial_obj
+    described_class.get(serial_obj: serial_obj, config_type: :LORA_CONFIG)
+    expect(decode_admin(serial_obj).get_config_request).to eq(:LORA_CONFIG)
+  end
+
+  it 'sets a Config protobuf' do
+    serial_obj = fake_serial_obj
+    config = Meshtastic::Config.new
+    config.device = Meshtastic::Config::DeviceConfig.new(role: :CLIENT)
+    described_class.set(serial_obj: serial_obj, config: config)
+    expect(decode_admin(serial_obj).set_config.device.role).to eq(:CLIENT)
+  end
+
+  it 'requests each ConfigType via named getters' do
+    serial_obj = fake_serial_obj
+    described_class.get_lora(serial_obj: serial_obj)
+    expect(decode_admin(serial_obj).get_config_request).to eq(:LORA_CONFIG)
+  end
+
+  Meshtastic::Config.descriptor.each do |field|
+    next if %w[sessionkey device_ui].include?(field.name)
+
+    it "writes the #{field.name} section through real serial framing" do
+      serial_obj = fake_serial_obj
+      section = field.subtype.msgclass.new
+      described_class.public_send("set_#{field.name}", serial_obj: serial_obj, field.name.to_sym => section)
+      config = decode_admin(serial_obj).set_config
+      expect(config.payload_variant).to eq(field.name.to_sym)
+      expect(config[field.name]).to eq(section)
+    end
+  end
+
+  it 'rejects an empty config before writing bytes' do
+    serial_obj = fake_serial_obj
+    expect { described_class.set(serial_obj: serial_obj, config: Meshtastic::Config.new) }.to raise_error(ArgumentError)
+    expect(serial_obj[:written]).to be_empty
+  end
+
+  Meshtastic::Config.descriptor.each do |field|
+    next if %w[sessionkey device_ui].include?(field.name)
+
+    it "accepts a field hash for #{field.name}" do
+      serial_obj = fake_serial_obj
+      described_class.public_send("set_#{field.name}", serial_obj: serial_obj, field.name.to_sym => {})
+      expect(decode_admin(serial_obj).set_config.payload_variant).to eq(field.name.to_sym)
+    end
+
+    it "rejects missing #{field.name} before writing bytes" do
+      serial_obj = fake_serial_obj
+      expect { described_class.public_send("set_#{field.name}", serial_obj: serial_obj) }.to(raise_error { |error| expect([ArgumentError, KeyError]).to include(error.class) })
+      expect(serial_obj[:written]).to be_empty
+    end
+  end
+
+  it 'uses dedicated device UI requests and stores instead of firmware no-op Config fields' do
+    serial_obj = fake_serial_obj
+    described_class.get_device_ui(serial_obj: serial_obj)
+    expect(decode_admin(serial_obj).payload_variant).to eq(:get_ui_config_request)
+    serial_obj = fake_serial_obj
+    described_class.set_device_ui(serial_obj: serial_obj, device_ui: {})
+    expect(decode_admin(serial_obj).payload_variant).to eq(:store_ui_config)
+  end
+
+  it 'rejects the read-only session-key placeholder without transmitting' do
+    serial_obj = fake_serial_obj
+    config = Meshtastic::Config.new(sessionkey: {})
+    expect { described_class.set(serial_obj: serial_obj, config: config) }.to raise_error(ArgumentError, /request-only/)
+    expect { described_class.set_sessionkey(serial_obj: serial_obj, sessionkey: {}) }.to raise_error(ArgumentError, /request-only/)
+    expect(serial_obj[:written]).to be_empty
+  end
+
+  {
+    device: :DEVICE_CONFIG, position: :POSITION_CONFIG, power: :POWER_CONFIG,
+    network: :NETWORK_CONFIG, display: :DISPLAY_CONFIG, lora: :LORA_CONFIG,
+    bluetooth: :BLUETOOTH_CONFIG, security: :SECURITY_CONFIG, sessionkey: :SESSIONKEY_CONFIG
+  }.each do |section, config_type|
+    it "requests #{section} using its protocol ConfigType" do
+      serial_obj = fake_serial_obj
+      described_class.public_send("get_#{section}", serial_obj: serial_obj)
+      message = decode_admin(serial_obj)
+      expect(message.payload_variant).to eq(:get_config_request)
+      expect(message.get_config_request).to eq(config_type)
+    end
+  end
+
+  it 'prints usage without raising' do
+    expect { described_class.help }.to output(/USAGE/).to_stdout
+  end
+end

data/spec/lib/meshtastic/admin/firmware/ble_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class UnifiedGattFixture
+  attr_reader :writes, :closed, :subscriptions
+
+  def initialize(final: "OK\n")
+    @writes = []
+    @notifications = []
+    @subscriptions = []
+    @command = +''
+    @binary = false
+    @received = 0
+    @final = final
+  end
+
+  def subscribe(uuid:)
+    @subscriptions << uuid
+  end
+
+  def write(uuid:, bytes:, response:)
+    raise 'must subscribe before writing' if @subscriptions.empty?
+    raise 'unconsumed ACK' unless @notifications.empty?
+
+    @writes << { uuid: uuid, bytes: bytes, response: response }
+    if @binary
+      @received += bytes.bytesize
+      @notifications << (@received == @size ? @final : "ACK\n")
+    else
+      @command << bytes
+      if @command.end_with?("\n")
+        if @command == "VERSION\n"
+          @notifications << "OK 1 2.7.0 3 v1.0\n"
+        else
+          @size = @command.split[1].to_i
+          @notifications << "ERASING\nOK\n"
+          @binary = true
+        end
+        @command.clear
+      end
+    end
+    bytes.bytesize
+  end
+
+  def notification(timeout:)
+    raise ArgumentError, 'timeout must be positive' unless timeout.positive?
+    raise Timeout::Error, 'silent GATT' if @notifications.empty?
+
+    { uuid: Meshtastic::Admin::Firmware::BLE::TX_UUID, bytes: @notifications.shift }
+  end
+
+  def close
+    @closed = true
+  end
+end
+
+describe 'Firmware selected-device BlueZ GATT' do
+  it 'scopes writes and notification matches to the selected device without requiring bootloader pairing' do
+    klass = Meshtastic::Admin::Firmware::BLE.const_get(:BlueZ)
+    service = Meshtastic::Admin::Firmware::BLE::SERVICE_UUID
+    uuid = Meshtastic::Admin::Firmware::BLE::TX_UUID
+    device = '/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF'
+    objects = {
+      '/org/bluez/hci0' => { 'org.bluez.Adapter1' => { 'Powered' => true } },
+      '/other/s' => { 'org.bluez.GattService1' => { 'Device' => '/other', 'UUID' => service } },
+      '/other/c' => { 'org.bluez.GattCharacteristic1' => { 'Service' => '/other/s', 'UUID' => uuid } },
+      device => { 'org.bluez.Device1' => { 'Address' => 'AA:BB:CC:DD:EE:FF', 'Adapter' => '/org/bluez/hci0', 'ServicesResolved' => true, 'Connected' => true, 'Paired' => false } },
+      "#{device}/s" => { 'org.bluez.GattService1' => { 'Device' => device, 'UUID' => service } },
+      "#{device}/s/c" => { 'org.bluez.GattCharacteristic1' => { 'Service' => "#{device}/s", 'UUID' => uuid } }
+    }
+    socket, peer = UNIXSocket.pair
+    queue = DBus::MessageQueue.allocate
+    queue.instance_variable_set(:@socket, socket)
+    queue.instance_variable_set(:@buffer, +''.b)
+    queue.instance_variable_set(:@read_buffer, +''.b)
+    queue.instance_variable_set(:@mutex, Mutex.new)
+    bus = double('private bus', message_queue: queue)
+    calls = []
+    signal_handler = nil
+    allow(bus).to receive(:process) { |message| signal_handler.call(message) }
+    allow(DBus::ASystemBus).to receive(:allocate).and_return(bus)
+    allow(bus).to receive(:initialize)
+    allow(bus).to receive(:add_match) do |rule, &handler|
+      expect(rule.to_s).to include("path='#{device}/s/c'")
+      signal_handler = handler
+    end
+    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 'WriteValue'
+        signal = DBus::Message.new(DBus::Message::SIGNAL)
+        signal.path = "#{device}/s/c"
+        signal.interface = 'org.freedesktop.DBus.Properties'
+        signal.member = 'PropertiesChanged'
+        signal.add_param('s', 'org.bluez.GattCharacteristic1')
+        signal.add_param('a{sv}', { 'Value' => ['ay', [79, 75, 10]] })
+        signal.add_param('as', [])
+        peer.write(signal.marshall)
+        []
+      else []
+      end
+    end
+    backend = klass.new(address: 'AA:BB:CC:DD:EE:FF', service_uuid: service, timeout: 0.1).connect
+    backend.subscribe(uuid: uuid)
+    backend.write(uuid: uuid, bytes: 'abc', response: true)
+    expect(backend.notification(timeout: 0.1)).to eq(uuid: uuid, bytes: "OK\n")
+    expect(calls.select { |m| m.member == 'WriteValue' }.map(&:path)).to eq(["#{device}/s/c"])
+    expect(calls.map(&:member)).not_to include('Pair', 'StartDiscovery')
+    objects.delete("#{device}/s/c")
+    expect { backend.write(uuid: uuid, bytes: 'must not reach decoy', response: false) }.to raise_error(IOError, /selected device/)
+    expect { backend.notification(timeout: 0.01) }.to raise_error(IOError, /notification timed out/)
+    backend.close
+    expect(socket).to be_closed
+  ensure
+    socket&.close unless socket&.closed?
+    peer&.close
+  end
+end
+
+describe 'Unified BLE firmware installation' do
+  it 'rejects another protocol in the direct BLE helper before touching GATT' do
+    backend = UnifiedGattFixture.new
+    expect do
+      Meshtastic::Admin::Firmware::BLE.install(protocol: :legacy_ble, backend: backend, bytes: 'abc')
+    end.to raise_error(ArgumentError, /protocol/)
+    expect(backend.writes).to be_empty
+  end
+
+  it 'uses the selected-address BlueZ backend by default' do
+    backend = UnifiedGattFixture.new
+    expect(Meshtastic::Admin::Firmware::BLE::BlueZ).to receive(:new)
+      .with(address: 'AA:BB:CC:DD:EE:FF', adapter: 'hci0', timeout: 120, service_uuid: Meshtastic::Admin::Firmware::BLE::SERVICE_UUID)
+      .and_return(backend)
+    expect(backend).to receive(:connect).and_return(backend)
+    expect(Meshtastic::Admin::Firmware.install(protocol: :unified_ble, address: 'AA:BB:CC:DD:EE:FF', bytes: 'abc')[:status]).to eq(:verified)
+  end
+
+  it 'validates timeout and unknown options before any BLE command' do
+    [{ timeout: 0 }, { timeout: Float::INFINITY }, { to: '!aabbccdd' }, { chunk_size: 512 }].each do |invalid|
+      backend = UnifiedGattFixture.new
+      expect do
+        Meshtastic::Admin::Firmware.install({ protocol: :unified_ble, backend: backend, bytes: 'abc' }.merge(invalid))
+      end.to raise_error(ArgumentError)
+      expect(backend.writes).to be_empty
+    end
+  end
+
+  it 'never treats ACK, ERR or disconnect as final completion or retries image bytes' do
+    ["ACK\n", "ERR Hash Mismatch\n", nil].each do |final|
+      backend = UnifiedGattFixture.new(final: final)
+      expect do
+        Meshtastic::Admin::Firmware.install(protocol: :unified_ble, backend: backend, bytes: 'abc')
+      end.to raise_error(IOError)
+      expect(backend.writes.count { |w| w[:bytes] == 'abc' }).to eq(1)
+      expect(backend.closed).to be true
+    end
+  end
+
+  it 'fragments commands to ATT size and waits for ACK per data chunk and final OK' do
+    backend = UnifiedGattFixture.new
+    result = Meshtastic::Admin::Firmware.install(protocol: :unified_ble, backend: backend, bytes: 'x' * 45)
+    expect(result).to include(status: :verified, bytes: 45, sha256: Digest::SHA256.hexdigest('x' * 45))
+    expect(backend.writes.map { |write| write[:bytes].bytesize }.max).to be <= 20
+    expect(backend.writes.map { |write| write[:bytes] }.join).to eq("VERSION\nOTA 45 #{Digest::SHA256.hexdigest('x' * 45)}\n#{'x' * 45}")
+    expect(backend.closed).to be true
+  end
+end