vagrant-qemu 0.6.2 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 440c288ae31987a57f90398d4b8c621ff32377ca8e6479a64e74d221fde483b3
-  data.tar.gz: 1dbd3b2b5fcb3d0bd68f384fd9cb6bde0700552c7960e0ae79d536b6ed6b5841
+  metadata.gz: 275a26aad79e641534b4c9ea0bb7a9824f964b61c66dbbe9e3bf0d7075f23081
+  data.tar.gz: f4afe41ed386785952534fff85e7030030fab8b4defdd7438ce37cee649b1a50
 SHA512:
-  metadata.gz: e067f314f5c759d43ba2a3b49980c9610847abdfbd360dfa2007e65b9eaee0d7d8f0bfd6f0a9c3e393f8b7f238499eb672376c1a8550a60e97d81d6c6f1278c4
-  data.tar.gz: c8576beb1bbb8da421f5c4e8d4eabd4e77b536bcca3abae4b1c39d3fe47d5817589452dda06b0af492d0776133c3780f7da03004dd058e68b3358ba797bc8044
+  metadata.gz: b05b9827dc708cf7dab8a417caae11eeed6fda22380e6d80d8eb3fd8a08c974b70f26b32ee0a10ceb06699a69ed59f1dcbfb42b856bed00ddb5bdeefa04acd37
+  data.tar.gz: dd55d31e14d55305e1c7714d74eb5d273fed56ba3b4ea927fb37ff305d337dbfd752f913f3b509562c395d8734950079d155e59950138c601041d29b0f10f744

data/CHANGELOG.md

@@ -195,3 +195,31 @@
   that device, just with its output discarded; `-parallel none` — now the
   default — skips creating it entirely, matching how the other default args
   (`-monitor`/`-display`/`-vga`) already disable their optional devices. (#80)
+
+# 0.6.3 (2026-08-12)
+
+* Fix `vagrant up` aborting with `no implicit conversion of nil into Array`
+  on macOS whenever `advanced_network` was enabled without also setting
+  `net_mode`. The default `net_mode` of `:auto` selects the vmnet backend but
+  was never resolved to a concrete mode, so the backend produced no `-netdev`
+  arguments for the private network NIC and the command line assembly blew up
+  before QEMU was launched. Setting `net_mode` explicitly (e.g.
+  `:vmnet_shared`) was the workaround. (#40)
+
+# 0.6.4 (2026-10-09)
+
+* Fix `vagrant up` failing with `ForwardPortCollision` ("The forwarded port
+  to 50022 is already in use") on macOS 27 even when nothing listens on the
+  port. A non-blocking connect to a closed local port there reports success
+  on the retry, so Vagrant's port check treated every port as in use. The
+  provider now supplies a port check that confirms the connection; results on
+  other systems are unchanged, and Windows keeps Vagrant's own check.
+* Quote MAC addresses in the generated cloud-init `network-config`. cloud-init
+  reads it as YAML 1.1, where an unquoted MAC whose octets are all decimal and
+  below 60 (e.g. `52:54:00:26:47:05`) is a base-60 integer. With
+  `advanced_network`, about 1.3% of generated MACs hit this, and the guest's
+  network config was rejected, which could leave the VM unreachable over SSH
+  on first boot. (#82, thanks @SamuelBoerlin)
+* README: bring a `socket_opts` `listen=`/`connect=` pair up with
+  `vagrant up --no-parallel`. A plain `vagrant up` boots both machines in
+  parallel, and if the connector starts first the link never comes up.

data/CLAUDE.md

@@ -23,7 +23,43 @@ vagrant plugin install ./pkg/vagrant-qemu-<version>.gem
 vagrant plugin list | grep vagrant-qemu
 ```
 
-Tests (rspec) are defined in the Gemfile but currently commented out in the Rakefile. There is no active test suite.
+## Testing
+
+```bash
+bundle exec rake spec:unit        # unit specs
+bundle exec rake spec:acceptance  # acceptance specs
+bundle exec rake spec             # unit + acceptance
+```
+
+Heavy suites are tag-gated in `spec/spec_helper.rb` and excluded unless the matching env var is set: `TEST_QEMU` (`:requires_qemu`), `TEST_VMNET` (`:requires_vmnet`), `TEST_SOCKET_VMNET` (`:requires_socket_vmnet`). rspec prints the excluded tags in its `Run options:` line — check it to confirm the suite you wanted actually ran. The vmnet e2e suite needs root:
+
+```bash
+TEST_VMNET=1 sudo -E bundle exec rspec spec/e2e/advanced_network_spec.rb
+```
+
+**e2e exercises the *installed* plugin, not the source tree.** `spec/e2e/helper.rb` compares the installed plugin version against `lib/vagrant-qemu/version.rb` and aborts on a mismatch, so rebuild and reinstall first:
+
+```bash
+bundle exec rake build && vagrant plugin install ./pkg/vagrant-qemu-<version>.gem
+```
+
+That guard compares version *numbers* only. Reinstalling after a source change without bumping the version passes the check while still testing stale code — and produces a local gem whose version collides with a published one.
+
+## Releasing
+
+`bundle exec rake release` handles the mechanics: tags `v<version>`, pushes the tag, builds, and pushes the gem to rubygems.org. Bump `lib/vagrant-qemu/version.rb` and add the CHANGELOG entry in a separate `Release <version>` commit first (see git history for the shape).
+
+A release is complete only when all four have landed:
+
+1. gem published on rubygems.org
+2. `master` pushed
+3. tag `v<version>` pushed
+4. GitHub release created **with the built gem attached as an asset** — a repo convention every prior release follows:
+   ```bash
+   gh release create v<version> --title v<version> --notes-file <notes> pkg/vagrant-qemu-<version>.gem
+   ```
+
+`rake release` tags before pushing the gem, so a mid-way failure can leave a pushed tag with no published gem; verify all four rather than assuming the command got through.
 
 ## Architecture
 

data/README.md

@@ -329,7 +329,7 @@ For VM-to-VM networking on macOS without sudo, use `:socket` with a `listen`/`co
 ```ruby
 Vagrant.configure("2") do |config|
   PORT = 12399
-  # vm1 listens; define it first so it is up before vm2 connects.
+  # vm1 listens, vm2 connects to it.
   config.vm.define "vm1" do |c|
     c.vm.box = "perk/ubuntu-2204-arm64"  # an aarch64 cloud-init box
     c.vm.network "private_network", ip: "192.168.105.51"
@@ -354,6 +354,8 @@ Vagrant.configure("2") do |config|
 end
 ```
 
+Bring it up with `vagrant up --no-parallel`. The provider boots machines in parallel by default, so a plain `vagrant up` can start vm2 before vm1 is listening, and the link never comes up.
+
 A single VM with a static IP (vmnet is the default backend on macOS when `net_mode` is `:auto`):
 
 ```ruby
@@ -415,7 +417,7 @@ Notes:
 * The Linux `:tap` backend expects a pre-created tap device attached to a bridge, e.g.:
   `sudo ip tuntap add tap0 mode tap && sudo ip link set tap0 master br0 && sudo ip link set tap0 up`
 * `socket_opts = "mcast=..."` gives N-way VM-to-VM on Linux/Windows, but does **not** work on macOS: QEMU binds the netdev socket to the multicast group address, which the Darwin socket stack refuses to send from (`EADDRNOTAVAIL`). On macOS use a `listen`/`connect` pair (no root) or vmnet (sudo).
-* `socket_opts = "listen=..."` / `"connect=..."` is a point-to-point QEMU TCP link and connects **exactly two** VMs (QEMU's listening socket accepts a single connection — it is not a hub). You choose which VM listens and which connects. The listener must be running before the connector starts, so define the listener first and bring the environment up together (`vagrant up`); starting a connector alone, or reloading the listener, drops the link.
+* `socket_opts = "listen=..."` / `"connect=..."` is a point-to-point QEMU TCP link and connects **exactly two** VMs (QEMU's listening socket accepts a single connection — it is not a hub). You choose which VM listens and which connects. The listener must be running before the connector starts, so define the listener first and bring the environment up with `vagrant up --no-parallel` (a plain `vagrant up` boots both in parallel and may start the connector first: both VMs come up with their IPs, but no traffic passes). Starting a connector alone, or reloading the listener, drops the link.
 
 Platform support:
 

data/lib/vagrant-qemu/action/prepare_forwarded_port_collision_params.rb

@@ -1,3 +1,5 @@
+require "socket"
+
 module VagrantPlugins
   module QEMU
     module Action
@@ -17,6 +19,13 @@ module VagrantPlugins
       remap = {}
       env[:port_collision_remap] = remap
 
+      # Windows keeps Vagrant's per-interface check for 0.0.0.0.
+      if !Vagrant::Util::Platform.windows?
+        env[:port_collision_port_check] = lambda do |host_ip, host_port|
+          self.class.port_in_use?(host_ip || "0.0.0.0", host_port)
+        end
+      end
+
       has_ssh_forward = false
       machine.config.vm.networks.each do |type, options|
         next if type != :forwarded_port
@@ -42,6 +51,20 @@ module VagrantPlugins
 
       @app.call(env)
       end
+
+      # Vagrant's IsPortOpen with an extra getpeername: on macOS 27 a refused
+      # non-blocking connect reports EISCONN on the retry, so Socket.tcp
+      # returns an unconnected socket and every port looks in use.
+      def self.port_in_use?(host, port)
+        Socket.tcp(host, port, connect_timeout: 0.1) do |sock|
+          sock.remote_address
+          true
+        end
+      rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTUNREACH,
+          Errno::ENETUNREACH, Errno::EACCES, Errno::ENOTCONN, Errno::EALREADY,
+          Errno::EINVAL
+        false
+      end
     end
     end
   end

data/lib/vagrant-qemu/network/vmnet.rb

@@ -8,8 +8,10 @@ module VagrantPlugins
       # Supports vmnet-shared, vmnet-host, vmnet-bridged
       class Vmnet < Base
         def build_netdev_args(id, options)
+          # :auto reaches this backend only on macOS, where it means vmnet-shared;
+          # net_mode is not rewritten during backend selection, so match it here.
           case options[:net_mode]
-          when :vmnet_shared
+          when :vmnet_shared, :auto
             base = "vmnet-shared,id=#{id}"
             base += subnet_args(options)
             %W(-netdev #{base})

data/lib/vagrant-qemu/network.rb

@@ -100,10 +100,15 @@ module VagrantPlugins
       # @param mac1 [String] MAC of advanced network NIC
       # @param ip [String] static IP for the advanced NIC (e.g. "192.168.105.10")
       # @param netmask [String] netmask (e.g. "255.255.255.0")
-      # @return [String] YAML string
+      # Emitted as JSON, which is valid YAML: cloud-init parses network-config
+      # as YAML 1.1, where an unquoted MAC whose octets are all decimal and
+      # below 60 (e.g. 52:54:00:26:47:05) is a base-60 integer. Psych's
+      # to_yaml leaves such a MAC unquoted; JSON always quotes strings.
+      #
+      # @return [String] YAML (JSON) string
       def self.build_network_config(mac0:, mac1:, ip:, netmask: "255.255.255.0")
         require 'ipaddr'
-        require 'yaml'
+        require 'json'
 
         prefix = IPAddr.new(netmask).to_i.to_s(2).count("1")
 
@@ -123,7 +128,7 @@ module VagrantPlugins
           }
         }
 
-        config.to_yaml
+        JSON.pretty_generate(config)
       end
     end
   end

data/lib/vagrant-qemu/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module QEMU
-    VERSION = '0.6.2'
+    VERSION = '0.6.4'
   end
 end

data/spec/e2e/advanced_network_spec.rb

@@ -10,9 +10,13 @@ describe "advanced networking end-to-end", :requires_vmnet do
     end
   end
 
-  it "VM gets the configured static IP" do
+  # net_mode is deliberately left at its default (:auto) here — the other
+  # examples cover it set explicitly. Issue #40 was reported against exactly
+  # this shape, which no test in any layer exercised.
+  it "VM gets the configured static IP with the default net_mode" do
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.box = "#{test_box_cloudinit}"
         config.vm.box_check_update = false
         config.vm.synced_folder ".", "/vagrant", disabled: true
@@ -20,7 +24,6 @@ describe "advanced networking end-to-end", :requires_vmnet do
         config.vm.provider "qemu" do |qe|
           qe.memory = "2G"
           qe.advanced_network = true
-          qe.net_mode = :vmnet_shared
         end
       end
     RUBY
@@ -33,6 +36,7 @@ describe "advanced networking end-to-end", :requires_vmnet do
   it "host can ping the VM IP" do
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.box = "#{test_box_cloudinit}"
         config.vm.box_check_update = false
         config.vm.synced_folder ".", "/vagrant", disabled: true
@@ -56,6 +60,7 @@ describe "advanced networking end-to-end", :requires_vmnet do
     user_mac = "52:54:00:aa:bb:cc"
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.box = "#{test_box_cloudinit}"
         config.vm.box_check_update = false
         config.vm.synced_folder ".", "/vagrant", disabled: true
@@ -78,6 +83,7 @@ describe "advanced networking end-to-end", :requires_vmnet do
   it "two VMs can communicate via private network" do
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.define "vm1" do |c|
           c.vm.box = "#{test_box_cloudinit}"
           c.vm.box_check_update = false

data/spec/e2e/helper.rb

@@ -46,6 +46,15 @@ module E2EHelper
     TEST_BOX_CLOUDINIT
   end
 
+  # The cloud-init box starts a snapd auto-refresh on first boot, and stopping
+  # snapd mid-refresh can hold guest shutdown for up to 90s. Destroy follows
+  # right after, so don't wait for it.
+  def snapd_fast_stop
+    <<~RUBY.chomp
+      config.vm.provision "shell", inline: "mkdir -p /etc/systemd/system/snapd.service.d && printf '[Service]\\\\nTimeoutStopSec=5s\\\\n' > /etc/systemd/system/snapd.service.d/e2e-fast-stop.conf && systemctl daemon-reload"
+    RUBY
+  end
+
   def vagrant_up(cwd, provider: "qemu", timeout: 300)
     run_vagrant_cmd("up", "--provider=#{provider}", cwd: cwd, timeout: timeout)
   end
@@ -65,7 +74,10 @@ module E2EHelper
     run_vagrant_cmd("reload", cwd: cwd, timeout: timeout)
   end
 
-  def vagrant_destroy(cwd, timeout: 60)
+  # Longer than the driver's own escalation (powerdown, then quit, each up to
+  # graceful_timeout) for two machines: killing vagrant mid-stop leaves the
+  # daemonized QEMU running and holding its ports for the next example.
+  def vagrant_destroy(cwd, timeout: 300)
     run_vagrant_cmd("destroy", "-f", cwd: cwd, timeout: timeout)
   end
 

data/spec/e2e/socket_network_spec.rb

@@ -36,6 +36,7 @@ describe "advanced networking over socket multicast (no root)", :requires_qemu d
     # assignment or cross-VM traffic broke.
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.box = "#{test_box_cloudinit}"
         config.vm.box_check_update = false
         config.vm.synced_folder ".", "/vagrant", disabled: true
@@ -57,6 +58,37 @@ describe "advanced networking over socket multicast (no root)", :requires_qemu d
     expect(ssh[:stdout]).to include("192.168.105.40")
   end
 
+  it "a MAC that YAML 1.1 reads as an integer reaches netplan as a string" do
+    # All octets decimal and below 60: an unquoted MAC in network-config is a
+    # base-60 integer to cloud-init, and netplan then rejects the rendered
+    # config. Generated MACs hit this ~1.3% of the time, so pin one.
+    mac = "52:54:00:26:47:05"
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
+        config.vm.box = "#{test_box_cloudinit}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.network "private_network", ip: "192.168.105.42", mac: "#{mac}"
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+          qe.advanced_network = true
+          qe.net_mode = :socket
+          qe.mcast_addr = "#{MCAST}"
+        end
+      end
+    RUBY
+
+    result = vagrant_up(@work_dir, timeout: 600)
+    expect(result[:exit_code]).to eq 0
+
+    ssh = vagrant_ssh(@work_dir, command: "ip addr show")
+    expect(ssh[:stdout]).to include("192.168.105.42")
+
+    ssh = vagrant_ssh(@work_dir, command: "sudo netplan generate")
+    expect(ssh[:exit_code]).to eq(0), ssh[:stderr]
+  end
+
   it "two VMs communicate over the socket multicast private network" do
     # QEMU's socket-multicast netdev binds its UDP socket to the multicast
     # group address (net/socket.c net_socket_mcast_create). Darwin's socket
@@ -73,6 +105,7 @@ describe "advanced networking over socket multicast (no root)", :requires_qemu d
 
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.define "vm1" do |c|
           c.vm.box = "#{test_box_cloudinit}"
           c.vm.box_check_update = false
@@ -135,8 +168,8 @@ describe "advanced networking over socket listen/connect (no root)", :requires_q
   it "two VMs communicate over a user-defined listen/connect socket" do
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
-        # The user picks the roles: vm1 listens, vm2 connects. vm1 is defined
-        # first so it boots first and is listening before vm2 dials in.
+        #{snapd_fast_stop}
+        # The user picks the roles: vm1 listens, vm2 connects.
         config.vm.define "vm1" do |c|
           c.vm.box = "#{test_box_cloudinit}"
           c.vm.box_check_update = false
@@ -167,7 +200,10 @@ describe "advanced networking over socket listen/connect (no root)", :requires_q
       end
     RUBY
 
-    vagrant_up(@work_dir, timeout: 600)
+    # The provider boots machines in parallel; --no-parallel follows the
+    # definition order, so vm1 is listening before vm2 connects.
+    result = run_vagrant_cmd("up", "--provider=qemu", "--no-parallel", cwd: @work_dir, timeout: 600)
+    expect(result[:exit_code]).to eq(0), result[:stderr]
 
     # vm1 (listener) pings vm2 (connector) over the link. Assert on the ping
     # output itself, not just an exit code that can pass vacuously.

data/spec/e2e/socket_vmnet_spec.rb

@@ -16,6 +16,7 @@ describe "socket_vmnet advanced networking end-to-end", :requires_socket_vmnet d
   it "VM gets the configured static IP (no sudo)" do
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.box = "#{test_box_cloudinit}"
         config.vm.box_check_update = false
         config.vm.synced_folder ".", "/vagrant", disabled: true
@@ -36,6 +37,7 @@ describe "socket_vmnet advanced networking end-to-end", :requires_socket_vmnet d
   it "host can ping the VM IP" do
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.box = "#{test_box_cloudinit}"
         config.vm.box_check_update = false
         config.vm.synced_folder ".", "/vagrant", disabled: true
@@ -56,6 +58,7 @@ describe "socket_vmnet advanced networking end-to-end", :requires_socket_vmnet d
   it "two VMs can communicate via the socket_vmnet private network" do
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.define "vm1" do |c|
           c.vm.box = "#{test_box_cloudinit}"
           c.vm.box_check_update = false
@@ -100,6 +103,7 @@ describe "socket_vmnet advanced networking end-to-end", :requires_socket_vmnet d
     shim = File.expand_path("support/qemu_no_stream_shim.sh", __dir__)
     File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
       Vagrant.configure("2") do |config|
+        #{snapd_fast_stop}
         config.vm.box = "#{test_box_cloudinit}"
         config.vm.box_check_update = false
         config.vm.synced_folder ".", "/vagrant", disabled: true

data/spec/unit/action/prepare_forwarded_port_collision_params_spec.rb

@@ -69,4 +69,36 @@ describe VagrantPlugins::QEMU::Action::PrepareForwardedPortCollisionParams do
 
     expect(ssh_entry[:host]).to eq 60022
   end
+
+  describe "port collision check" do
+    def port_check(windows: false)
+      allow(Vagrant::Util::Platform).to receive(:windows?).and_return(windows)
+      ctx = mock_vagrant_env(networks: [])
+      described_class.new(app, ctx[:env]).call(ctx[:env])
+      ctx[:env][:port_collision_port_check]
+    end
+
+    it "reports a listening port as in use" do
+      server = TCPServer.new("127.0.0.1", 0)
+      expect(port_check.call("127.0.0.1", server.addr[1])).to eq true
+    ensure
+      server&.close
+    end
+
+    it "reports a closed port as free" do
+      server = TCPServer.new("127.0.0.1", 0)
+      port = server.addr[1]
+      server.close
+      expect(port_check.call("127.0.0.1", port)).to eq false
+    end
+
+    it "checks 0.0.0.0 when no host_ip is given" do
+      expect(described_class).to receive(:port_in_use?).with("0.0.0.0", 50022).and_return(false)
+      port_check.call(nil, 50022)
+    end
+
+    it "keeps Vagrant's own check on Windows" do
+      expect(port_check(windows: true)).to be_nil
+    end
+  end
 end

data/spec/unit/driver/start_cmd_advanced_spec.rb

@@ -67,6 +67,17 @@ describe VagrantPlugins::QEMU::Driver, "start command line (dual NIC)" do
     expect(cmd_str).to include("-netdev vmnet-shared,id=net1")
   end
 
+  # Regression for issue #40: the default net_mode :auto selected the Vmnet
+  # backend but matched none of its cases, so NIC 1 args came back nil.
+  it "builds NIC 1 args for the default net_mode :auto" do
+    allow(VagrantPlugins::QEMU::Network).to receive(:auto_detect)
+      .and_return(VagrantPlugins::QEMU::Network::Vmnet.new)
+    subject.start(advanced_options.merge(net_mode: :auto))
+    cmd_str = @captured_cmd.join(" ")
+    expect(cmd_str).to include("-netdev vmnet-shared,id=net1")
+    expect(cmd_str).to include("start-address=192.168.105.1")
+  end
+
   it "NIC 1 has different MAC than NIC 0" do
     subject.start(advanced_options)
     cmd_str = @captured_cmd.join(" ")

data/spec/unit/network/build_network_config_spec.rb

@@ -29,6 +29,15 @@ describe VagrantPlugins::QEMU::Network, ".build_network_config" do
     expect(priv_nic["addresses"]).to eq ["192.168.105.10/24"]
   end
 
+  context "with MACs that YAML 1.1 reads as base-60 integers" do
+    let(:mac0) { "52:54:00:26:47:05" }
+    let(:mac1) { "52:54:00:12:34:56" }
+
+    it "quotes the MACs" do
+      expect(subject).to include("\"#{mac0}\"", "\"#{mac1}\"")
+    end
+  end
+
   it "calculates /16 prefix for 255.255.0.0 netmask" do
     result = described_class.build_network_config(
       mac0: mac0, mac1: mac1,

data/spec/unit/network/vmnet_spec.rb

@@ -20,6 +20,12 @@ describe VagrantPlugins::QEMU::Network::Vmnet do
     expect(netdev_arg).to include("subnet-mask=255.255.255.0")
   end
 
+  it "treats :auto as vmnet-shared (macOS default)" do
+    pn = [{ ip: "192.168.105.10", netmask: "255.255.255.0" }]
+    args = subject.build_netdev_args("net1", net_mode: :auto, private_networks: pn)
+    expect(args).to eq subject.build_netdev_args("net1", net_mode: :vmnet_shared, private_networks: pn)
+  end
+
   it "builds vmnet-host args with subnet" do
     args = subject.build_netdev_args("net1",
       net_mode: :vmnet_host,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-qemu
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.4
 platform: ruby
 authors:
 - ppggff
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-22 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies: []
 description: Enables Vagrant to manage machines with QEMU.
 email: pgf00a@gmail.com