macos.rb 0.50.0

data/test/MacOS/Defaults/NSGlobalDomain/NSUserKeyEquivalents_test.rb

@@ -0,0 +1,67 @@
+require_relative '../../../helper'
+require 'MacOS/Defaults/NSGlobalDomain/NSUserKeyEquivalents'
+
+describe MacOS::Defaults::NSGlobalDomain::NSUserKeyEquivalents do
+  let(:keys){MacOS::Defaults::NSGlobalDomain::NSUserKeyEquivalents}
+
+  describe ".key_code" do
+    it "codes modifier and arrow keys, in either case" do
+      _(keys.key_code(%w{cmd alt left})).must_equal('@~\\UF702')
+      _(keys.key_code(%w{CMD ALT LEFT})).must_equal('@~\\UF702')
+      _(keys.key_code(:ctrl, :shift, :right)).must_equal('^$\\UF703')
+    end
+
+    it "keeps a letter as itself" do
+      _(keys.key_code(%w{cmd D})).must_equal('@d')
+    end
+
+    it "raises for a key it doesn't know" do
+      _{keys.key_code(%w{cmd hyper})}.must_raise(RuntimeError)
+    end
+  end
+
+  describe ".parse_key_code" do
+    it "splits a key code at each \\U" do
+      _(keys.parse_key_code('@~\UF702')).must_equal(['@~', 'F702'])
+    end
+  end
+
+  describe "assigning keys" do
+    it "makes a defaults write command for each menu item" do
+      _(keys.assign_key_code_command_strings('@~\\UF702', ['Previous Tab', 'Show Previous Tab'])).must_equal([
+        "defaults write NSGlobalDomain NSUserKeyEquivalents -dict-add 'Previous Tab' '@~\\UF702'",
+        "defaults write NSGlobalDomain NSUserKeyEquivalents -dict-add 'Show Previous Tab' '@~\\UF702'",
+      ])
+    end
+
+    it "runs them, succeeding where each does" do
+      result = nil
+      commands = commands_run_by(keys){result = keys.assign_keys(%w{cmd alt left}, 'Previous Tab')}
+      _(result).must_equal(true)
+      _(commands).must_equal([["defaults write NSGlobalDomain NSUserKeyEquivalents -dict-add 'Previous Tab' '@~\\UF702'"]])
+    end
+
+    it "loads several shortcuts at once" do
+      shortcuts = [{keys: %w{cmd alt left}, menu_items: ['Previous Tab']}, {keys: %w{cmd shift d}, menu_items: ['Find Previous']}]
+      commands = commands_run_by(keys){keys.load(shortcuts)}
+      _(commands.size).must_equal(2)
+    end
+  end
+
+  describe ".read_keys" do
+    it "reads the shortcuts back, as keys and the menu items they're for" do
+      keys.stub(:`, fixture('defaults-read-NSUserKeyEquivalents.txt')) do
+        _(keys.read_keys).must_equal([
+          {keys: [:cmd, :alt, :left], menu_items: ['Previous Tab']},
+          {keys: [:cmd, :shift, 'd'], menu_items: ['Find Previous']},
+        ])
+      end
+    end
+
+    it "writes them as YAML" do
+      keys.stub(:`, fixture('defaults-read-NSUserKeyEquivalents.txt')) do
+        _(YAML.load(keys.to_yaml, permitted_classes: [Symbol]).first[:menu_items]).must_equal(['Previous Tab'])
+      end
+    end
+  end
+end

data/test/MacOS/Defaults_test.rb

@@ -0,0 +1,144 @@
+require_relative '../helper'
+require 'tmpdir'
+require 'MacOS/Defaults'
+
+describe MacOS::Defaults do
+  def with_domains(&block)
+    MacOS::Defaults.stub(:`, fixture('defaults-domains.txt'), &block)
+  end
+
+  # Stands in for MacOS::Defaults.new, making Defaults whose named methods only record the calls made on them.
+  def recorder(calls, *methods)
+    ->(domain:) do
+      defaults = MacOS::Defaults.allocate
+      defaults.send(:initialize, domain: domain)
+      methods.each{|method| defaults.define_singleton_method(method){|*args| calls << [domain, method, *args]}}
+      defaults
+    end
+  end
+
+  describe ".domains" do
+    it "lists every domain" do
+      with_domains do
+        _(MacOS::Defaults.domains).must_equal(%w{com.apple.dock com.apple.finder com.apple.Safari})
+      end
+    end
+
+    it "makes a Defaults for each" do
+      with_domains do
+        _(MacOS::Defaults.all.map{|defaults| defaults.instance_variable_get(:@domain)}).must_equal(%w{com.apple.dock com.apple.finder com.apple.Safari})
+      end
+    end
+  end
+
+  describe "a domain" do
+    it "is valid where defaults lists it, or where it's the global domain" do
+      with_domains do
+        _(MacOS::Defaults.new(domain: 'com.apple.dock').domain_valid?).must_equal(true)
+        _(MacOS::Defaults.new(domain: '-globalDomain').domain_valid?).must_equal(true)
+        _(MacOS::Defaults.new(domain: 'com.example.nowhere').domain_valid?).must_equal(false)
+      end
+    end
+
+    it "knows whether it's the global domain" do
+      _(MacOS::Defaults.new(domain: '-globalDomain').global_domain?).must_equal(true)
+      _(MacOS::Defaults.new(domain: 'com.apple.dock').global_domain?).must_equal(false)
+    end
+  end
+
+  describe "exporting and importing" do
+    it "exports a valid domain to a plist file" do
+      commands = []
+      MacOS::Defaults.stub(:domains, %w{com.apple.dock}) do
+        defaults = MacOS::Defaults.new(domain: 'com.apple.dock')
+        defaults.stub(:`, ->(command){commands << command; ''}){_(defaults.export).must_equal(true)}
+      end
+      _(commands).must_equal(['defaults export com.apple.dock /tmp/com.apple.dock.plist'])
+    end
+
+    it "won't export a domain defaults doesn't know" do
+      MacOS::Defaults.stub(:domains, []) do
+        _{MacOS::Defaults.new(domain: 'com.example.nowhere').export}.must_raise(RuntimeError)
+      end
+    end
+
+    it "won't import a domain without its plist file" do
+      _{MacOS::Defaults.new(domain: 'com.example.nowhere').import}.must_raise(RuntimeError)
+    end
+
+    it "exports and imports every domain in bulk" do
+      calls = []
+      MacOS::Defaults.stub(:domains, %w{com.apple.dock com.apple.finder}) do
+        MacOS::Defaults.stub(:new, recorder(calls, :export, :import)) do
+          MacOS::Defaults.bulk_export_to_plist_files
+          MacOS::Defaults.bulk_import_from_plist_files
+        end
+      end
+      _(calls).must_equal([['com.apple.dock', :export], ['com.apple.finder', :export], ['com.apple.dock', :import], ['com.apple.finder', :import]])
+    end
+  end
+
+  describe "from YAML" do
+    let(:attributes){[{'autohide' => true}, {'tilesize' => 48}, {'scale' => 0.5}, {'orientation' => 'bottom'}, {'persistent-apps' => ['/Applications/Example.app']}]}
+
+    it "writes each attribute, typed by its value" do
+      defaults = MacOS::Defaults.new(domain: 'com.apple.dock')
+      commands = commands_run_by(defaults){_(defaults.from_yaml(attributes)).must_equal(true)}
+      _(commands).must_equal([
+        %w{defaults write com.apple.dock autohide -bool true},
+        %w{defaults write com.apple.dock tilesize -int 48},
+        %w{defaults write com.apple.dock scale -float 0.5},
+        %w{defaults write com.apple.dock orientation -string bottom},
+        %w{defaults write com.apple.dock persistent-apps -array /Applications/Example.app},
+      ])
+    end
+
+    it "is false where a write fails" do
+      defaults = MacOS::Defaults.new(domain: 'com.apple.dock')
+      defaults.stub(:system, false) do
+        _(defaults.from_yaml([{'autohide' => true}])).must_equal(false)
+      end
+    end
+
+    it "writes a Hash as a dictionary" do
+      defaults = MacOS::Defaults.new(domain: 'com.apple.dock')
+      commands = commands_run_by(defaults){defaults.from_yaml([{'example-dict' => {'size' => 48, 'shown' => true}}])}
+      _(commands).must_equal([%w{defaults write com.apple.dock example-dict -dict size 48 shown true}])
+    end
+
+    it "reads what to_yaml writes" do
+      written = MacOS::Defaults.new(domain: 'com.apple.dock')
+      yaml = written.stub(:to_h, {'autohide' => true, 'tilesize' => 48}){written.to_yaml}
+      _(YAML.safe_load(yaml)['com.apple.dock']).must_equal([{'autohide' => true}, {'tilesize' => 48}])
+    end
+
+    it "writes each domain a YAML file gives" do
+      Dir.mktmpdir do |directory|
+        path = File.join(directory, 'defaults.yml')
+        File.write(path, {'com.apple.dock' => [{'autohide' => true}], 'com.apple.finder' => [{'ShowPathbar' => true}]}.to_yaml)
+        calls = []
+        MacOS::Defaults.stub(:new, recorder(calls, :from_yaml)){MacOS::Defaults.from_yaml(path)}
+        _(calls).must_equal([['com.apple.dock', :from_yaml, [{'autohide' => true}]], ['com.apple.finder', :from_yaml, [{'ShowPathbar' => true}]]])
+      end
+    end
+
+    it "reads DEFAULT_YAML_FILENAME where it's given no file" do
+      loaded = []
+      YAML.stub(:load_file, ->(path){loaded << path; {}}){MacOS::Defaults.from_yaml}
+      _(loaded).must_equal([MacOS::Defaults::DEFAULT_YAML_FILENAME])
+    end
+  end
+
+  describe "#to_h" do
+    it "reads the domain's exported plist file" do
+      domain = "com.example.macos-rb-test-#{Process.pid}"
+      path = File.join(MacOS::Defaults::DEFAULT_PLIST_DIRECTORY, "#{domain}.plist")
+      plist = CFPropertyList::List.new
+      plist.value = CFPropertyList.guess('autohide' => true, 'tilesize' => 48)
+      plist.save(path, CFPropertyList::List::FORMAT_XML)
+      _(MacOS::Defaults.new(domain: domain).to_h).must_equal('autohide' => true, 'tilesize' => 48)
+    ensure
+      File.delete(path) if path && File.exist?(path)
+    end
+  end
+end

data/test/MacOS/DiskUtil_test.rb

@@ -0,0 +1,48 @@
+require_relative '../helper'
+require 'MacOS/DiskUtil'
+
+describe MacOS::DiskUtil do
+  def with_disks(&block)
+    MacOS::DiskUtil.stub(:xml_volume_plist, fixture('diskutil-list-plist.xml'), &block)
+  end
+
+  def with_df(&block)
+    MacOS::DiskUtil.stub(:`, fixture('df-k.txt'), &block)
+  end
+
+  describe "the volumes" do
+    it "keeps the disks with partitions" do
+      with_disks do
+        _(MacOS::DiskUtil.volumes_and_partitions.map{|disk| disk['DeviceIdentifier']}).must_equal(%w{disk0 disk4})
+      end
+    end
+
+    it "gives each partition's device, mount point, name and size" do
+      with_disks do
+        _(MacOS::DiskUtil.volumes.last).must_equal(device_id: 'disk4s1', mount_point: '/Volumes/EXAMPLE', name: 'EXAMPLE', size: 32006733824)
+        _(MacOS::DiskUtil.volumes.map{|volume| volume[:device_id]}).must_equal(%w{disk0s1 disk0s2 disk4s1})
+      end
+    end
+
+    it "gives those which are mounted as its external volumes" do
+      with_disks do
+        _(MacOS::DiskUtil.external_volumes.map{|volume| volume[:name]}).must_equal(%w{EXAMPLE})
+      end
+    end
+  end
+
+  describe "the free space" do
+    it "gives the bytes available on a device or a volume" do
+      with_df do
+        _(MacOS::DiskUtil.free_bytes_for_device_id('disk4s1')).must_equal(31241024 * 1024)
+        _(MacOS::DiskUtil.free_bytes_for_volume_name('EXAMPLE')).must_equal(31241024 * 1024)
+      end
+    end
+
+    it "gives nil for a device which isn't there" do
+      with_df do
+        _(MacOS::DiskUtil.free_bytes_for_device_id('disk9s9')).must_be_nil
+      end
+    end
+  end
+end

data/test/MacOS/Dmg_test.rb

@@ -0,0 +1,69 @@
+require_relative '../helper'
+require 'MacOS/Dmg'
+
+describe MacOS::Dmg do
+  def run_quietly(&block)
+    Dir.stub(:chdir, nil){commands_run_by(MacOS::Dmg, &block)}
+  end
+
+  describe "the class" do
+    it "mounts, installs from and unmounts a disk image, escaping each name for the shell" do
+      commands = run_quietly do
+        MacOS::Dmg.mount('Example App.dmg')
+        MacOS::Dmg.run_installer(mount_point: 'Example App', pkg_name: 'Example App.pkg')
+        MacOS::Dmg.unmount('Example App')
+      end
+      _(commands).must_equal([
+        ['hdiutil attach Example\\ App.dmg'],
+        ["sudo installer -pkg Example\\ App.pkg -target '/'"],
+        ['hdiutil detach -Force /Volumes/Example\\ App'],
+      ])
+    end
+
+    it "installs from a disk image it's given the names of" do
+      commands = run_quietly{MacOS::Dmg.install(path_to_dmg: '/tmp/Example-1.0.dmg', disk_image_name: 'Example-1.0.dmg', package: 'Example')}
+      _(commands).must_equal([
+        ['hdiutil attach /tmp/Example-1.0.dmg'],
+        ["sudo installer -pkg Example.pkg -target '/'"],
+        ['hdiutil detach -Force /Volumes/Example-1'],
+      ])
+    end
+
+    it "prints each command where verbose" do
+      MacOS::Dmg.verbose = true
+      _{run_quietly{MacOS::Dmg.mount('Example.dmg')}}.must_output("hdiutil attach Example.dmg\n")
+    ensure
+      MacOS::Dmg.verbose = nil
+    end
+  end
+
+  describe "an instance" do
+    let(:dmg){MacOS::Dmg.new(path_to_dmg: '/tmp/Example-1.0.dmg', disk_image_name: 'Example-1.0.dmg', package: 'Example')}
+
+    it "takes its package's name and its mount point from its other names, where they aren't given" do
+      _(dmg.pkg_name).must_equal('Example.pkg')
+      _(dmg.mount_point).must_equal('Example-1')
+    end
+
+    it "takes them as given" do
+      dmg.pkg_name = 'Other.pkg'
+      dmg.mount_point = 'Other'
+      _(dmg.pkg_name).must_equal('Other.pkg')
+      _(dmg.mount_point).must_equal('Other')
+    end
+
+    it "answers to each of its disk image's names" do
+      dmg.filename = 'Renamed.dmg'
+      _([dmg.disk_image_name, dmg.filename, dmg.dmg_filename, dmg.image_name]).must_equal(['Renamed.dmg'] * 4)
+    end
+
+    it "mounts, installs and unmounts" do
+      commands = run_quietly{dmg.install}
+      _(commands).must_equal([
+        ['hdiutil attach /tmp/Example-1.0.dmg'],
+        ["sudo installer -pkg Example.pkg -target '/'"],
+        ['hdiutil detach -Force /Volumes/Example-1'],
+      ])
+    end
+  end
+end

data/test/MacOS/HardwarePort_test.rb

@@ -0,0 +1,46 @@
+require_relative '../helper'
+require 'MacOS/HardwarePort'
+
+describe MacOS::HardwarePort do
+  def with_ports(&block)
+    MacOS::HardwarePort.stub(:output, fixture('networksetup-listallhardwareports.txt'), &block)
+  end
+
+  describe ".parse" do
+    it "makes one for each hardware port networksetup lists" do
+      ports = MacOS::HardwarePort.parse(fixture('networksetup-listallhardwareports.txt'))
+      _(ports.map(&:interface)).must_equal(%w{en4 en5 en6 en8 bridge0 en0 en1 en2 en3})
+    end
+
+    it "reads each port's name, device and Ethernet address" do
+      wifi = MacOS::HardwarePort.parse(fixture('networksetup-listallhardwareports.txt')).find{|port| port.device == 'en0'}
+      _(wifi.hardware_port).must_equal('Wi-Fi')
+      _(wifi.name).must_equal('Wi-Fi')
+      _(wifi.ethernet_address).must_equal('00:00:5e:00:53:08')
+      _(wifi.mac_address).must_equal('00:00:5e:00:53:08')
+    end
+  end
+
+  describe "finding" do
+    it "finds a port by its interface, its name or its MAC address" do
+      with_ports do
+        _(MacOS::HardwarePort.find_by_interface('en0').name).must_equal('Wi-Fi')
+        _(MacOS::HardwarePort.find_by_device('bridge0').name).must_equal('Thunderbolt Bridge')
+        _(MacOS::HardwarePort.find_by_name('Wi-Fi').interface).must_equal('en0')
+        _(MacOS::HardwarePort.find_by_hardware_port('Thunderbolt 2').interface).must_equal('en2')
+        _(MacOS::HardwarePort.find_by_mac_address('00:00:5e:00:53:04').interface).must_equal('en4')
+        _(MacOS::HardwarePort.find_by_ethernet_address('00:00:5e:00:53:04').interface).must_equal('en4')
+      end
+    end
+
+    it "finds nothing for a port which isn't there" do
+      with_ports do
+        _(MacOS::HardwarePort.find_by_name('Nowhere')).must_be_nil
+      end
+    end
+  end
+
+  it "keeps the raw output to itself" do
+    _(MacOS::HardwarePort.respond_to?(:output)).must_equal(false)
+  end
+end

data/test/MacOS/IfConfig_test.rb

@@ -0,0 +1,144 @@
+require_relative '../helper'
+require 'MacOS/IfConfig'
+
+describe MacOS::IfConfig do
+  let(:output){fixture('ifconfig-a.txt')}
+
+  def with_ifconfig(output = fixture('ifconfig-a.txt'), &block)
+    MacOS::IfConfig.stub(:output, output, &block)
+  end
+
+  def interface(name)
+    MacOS::IfConfig.parse(output).find{|ifconfig| ifconfig.interface == name}
+  end
+
+  describe ".parse" do
+    it "makes one for each interface, in the order ifconfig lists them" do
+      _(MacOS::IfConfig.parse(output).map(&:interface)).must_equal(%w{lo0 gif0 stf0 en1 en0 awdl0 bridge0 utun0 utun4})
+    end
+
+    it "reads an interface's address, netmask and broadcast address" do
+      en0 = interface('en0')
+      _(en0.ipv4_address).must_equal('192.0.2.114')
+      _(en0.netmask).must_equal('0xffffff00')
+      _(en0.broadcast_address).must_equal('192.0.2.255')
+    end
+
+    it "reads an address without a broadcast address" do
+      _(interface('lo0').ipv4_address).must_equal('127.0.0.1')
+      _(interface('lo0').netmask).must_equal('0xff000000')
+    end
+
+    it "reads the near end of a point-to-point address" do
+      _(interface('utun4').ipv4_address).must_equal('198.51.100.250')
+      _(interface('utun4').netmask).must_equal('0xffffffff')
+    end
+
+    it "reads the MAC address, status and flags" do
+      en0 = interface('en0')
+      _(en0.mac_address).must_equal('00:00:5e:00:53:02')
+      _(en0.status).must_equal('active')
+      _(en0.flags).must_include('UP')
+    end
+
+    it "reads lines with a trailing space, as older ifconfigs give them" do
+      older = "en0: flags=8863<UP,BROADCAST> mtu 1500\n\tether 00:00:5e:00:53:02 \n\tinet 192.0.2.114 netmask 0xffffff00 \n"
+      en0 = MacOS::IfConfig.parse(older).first
+      _(en0.mac_address).must_equal('00:00:5e:00:53:02')
+      _(en0.ipv4_address).must_equal('192.0.2.114')
+      _(en0.netmask).must_equal('0xffffff00')
+    end
+
+    it "gives the same each time" do
+      first = MacOS::IfConfig.parse(output).map(&:interface)
+      _(MacOS::IfConfig.parse(output).map(&:interface)).must_equal(first)
+    end
+
+    it "gives none for output with no interfaces" do
+      _(MacOS::IfConfig.parse('')).must_equal([])
+    end
+  end
+
+  describe "the interfaces in each state" do
+    it "lists those which are active and inactive" do
+      with_ifconfig do
+        _(MacOS::IfConfig.active_interfaces_names).must_equal(%w{en0 awdl0})
+        _(MacOS::IfConfig.inactive_interfaces_names).must_equal(%w{en1 bridge0})
+      end
+    end
+
+    it "lists those which are up: active or flagged UP, and with an address" do
+      with_ifconfig do
+        _(MacOS::IfConfig.up_interfaces_names).must_equal(%w{lo0 en0 utun4})
+      end
+    end
+  end
+
+  describe "the interfaces themselves" do
+    it "lists every interface's name, and those active and inactive" do
+      with_ifconfig do
+        _(MacOS::IfConfig.interface_names).must_equal(%w{lo0 gif0 stf0 en1 en0 awdl0 bridge0 utun0 utun4})
+        _(MacOS::IfConfig.active_interfaces.map(&:name)).must_equal(%w{en0 awdl0})
+        _(MacOS::IfConfig.inactive_interfaces.map(&:name)).must_equal(%w{en1 bridge0})
+      end
+    end
+  end
+
+  describe "the addresses" do
+    it "lists every MAC address and IPv4 address" do
+      with_ifconfig do
+        _(MacOS::IfConfig.mac_addresses).must_equal(%w{00:00:5e:00:53:01 00:00:5e:00:53:02 00:00:5e:00:53:03 00:00:5e:00:53:01})
+        _(MacOS::IfConfig.ipv4_addresses).must_equal(%w{127.0.0.1 192.0.2.114 198.51.100.250})
+      end
+    end
+  end
+
+  describe "finding" do
+    it "finds an interface by its name, MAC address or IPv4 address" do
+      with_ifconfig do
+        _(MacOS::IfConfig.find_by_interface('en0').mac_address).must_equal('00:00:5e:00:53:02')
+        _(MacOS::IfConfig.find_by_mac_address('00:00:5e:00:53:03').interface).must_equal('awdl0')
+        _(MacOS::IfConfig.find_by_ipv4_address('198.51.100.250').interface).must_equal('utun4')
+      end
+    end
+
+    it "matches names against a Regexp, or a String taken literally" do
+      with_ifconfig do
+        _(MacOS::IfConfig.all_matching(/\Autun\d/).map(&:name)).must_equal(%w{utun0 utun4})
+        _(MacOS::IfConfig.all_matching('en').map(&:name)).must_equal(%w{en1 en0})
+        _(MacOS::IfConfig.all_matching('.')).must_equal([])
+      end
+    end
+  end
+
+  describe "bringing interfaces down" do
+    it "brings down only those matching which are up" do
+      with_ifconfig do
+        commands = commands_run_by(MacOS::IfConfig) do
+          _(MacOS::IfConfig.bring_down_matching_interfaces(/\Autun/)).must_equal(%w{utun4})
+        end
+        _(commands).must_equal([%w{sudo ifconfig utun4 down}])
+      end
+    end
+
+    it "destroys an interface" do
+      commands = commands_run_by(MacOS::IfConfig){MacOS::IfConfig.destroy_interface('utun4')}
+      _(commands).must_equal([%w{sudo ifconfig utun4 destroy}])
+    end
+  end
+
+  describe "an interface" do
+    it "gives its MAC address as its Ethernet address too" do
+      _(interface('en0').ethernet_address).must_equal('00:00:5e:00:53:02')
+    end
+
+    it "knows whether it's virtual" do
+      _(interface('utun4').virtual?).wont_be_nil
+      _(interface('en0').virtual?).must_be_nil
+    end
+  end
+
+  it "keeps the raw output to itself" do
+    _(MacOS::IfConfig.respond_to?(:output)).must_equal(false)
+  end
+end

data/test/MacOS/Keychain_test.rb

@@ -0,0 +1,22 @@
+require_relative '../helper'
+require 'MacOS/Keychain'
+
+describe MacOS::Keychain do
+  it "asks security for a generic password, the key escaped for the shell" do
+    _(MacOS::Keychain.find_generic_password_command('Example Net')).must_equal('security find-generic-password -ga Example\\ Net')
+  end
+
+  it "gives a Wi-Fi network's password, which security writes to standard error" do
+    found = ["keychain: \"/Library/Keychains/System.keychain\"\n", "password: \"example-passphrase\"\n", nil]
+    MacOS::Keychain.stub(:find_generic_password, found) do
+      _(MacOS::Keychain.wifi_password('ExampleNet')).must_equal('example-passphrase')
+    end
+  end
+
+  it "gives nil where the keychain has no password for the network" do
+    missing = ['', "security: SecKeychainSearchCopyNext: The specified item could not be found in the keychain.\n", nil]
+    MacOS::Keychain.stub(:find_generic_password, missing) do
+      _(MacOS::Keychain.wifi_password('Nowhere')).must_be_nil
+    end
+  end
+end

data/test/MacOS/LaunchControl_test.rb

@@ -0,0 +1,40 @@
+require_relative '../helper'
+require 'MacOS/LaunchControl'
+
+describe MacOS::LaunchControl do
+  let(:plist){'/Library/LaunchDaemons/com.example.agent.plist'}
+
+  it "loads and unloads a plist" do
+    commands = commands_run_by(MacOS::LaunchControl) do
+      MacOS::LaunchControl.load(plist)
+      MacOS::LaunchControl.unload(plist)
+    end
+    _(commands).must_equal([["launchctl load -w #{plist}"], ["launchctl unload -w #{plist}"]])
+  end
+
+  it "escapes the plist's path for the shell" do
+    commands = commands_run_by(MacOS::LaunchControl){MacOS::LaunchControl.load('/Library/Launch Agents/com.example.agent.plist')}
+    _(commands).must_equal([['launchctl load -w /Library/Launch\ Agents/com.example.agent.plist']])
+  end
+
+  describe "an instance" do
+    it "holds the plist it's made with" do
+      _(MacOS::LaunchControl.new(plist).path_to_plist).must_equal(plist)
+      _(MacOS::LaunchControl.new.path_to_plist).must_be_nil
+    end
+
+    it "loads and unloads its own plist" do
+      launch_control = MacOS::LaunchControl.new(plist)
+      commands = commands_run_by(MacOS::LaunchControl) do
+        launch_control.load
+        launch_control.unload
+      end
+      _(commands).must_equal([["launchctl load -w #{plist}"], ["launchctl unload -w #{plist}"]])
+    end
+
+    it "unloads another plist where it's given one" do
+      commands = commands_run_by(MacOS::LaunchControl){MacOS::LaunchControl.new.unload('/tmp/other.plist')}
+      _(commands).must_equal([['launchctl unload -w /tmp/other.plist']])
+    end
+  end
+end

data/test/MacOS/SystemProfiler_test.rb

@@ -0,0 +1,69 @@
+require_relative '../helper'
+require 'MacOS/SystemProfiler'
+
+describe MacOS::SystemProfiler do
+  def with_output(output = fixture('system_profiler-SPSoftwareDataType.txt'), &block)
+    MacOS::SystemProfiler.stub(:system_profiler_output, output, &block)
+  end
+
+  describe "the system's version" do
+    it "reads it from the System Version field" do
+      with_output do
+        _(MacOS::SystemProfiler.system_version_data).must_equal('macOS 15.8.1 (24H32)')
+        _(MacOS::SystemProfiler.system_version_string).must_equal('15.8.1')
+      end
+    end
+
+    it "reads the version of an older OS X" do
+      with_output("      System Version: Mac OS X 10.9.5 (13F34)\n") do
+        _(MacOS::SystemProfiler.system_version_string).must_equal('10.9.5')
+      end
+    end
+
+    it "gives it as a Version, and its major, minor and tiny parts" do
+      with_output do
+        _(MacOS::SystemProfiler.system_version).must_be_instance_of(Version)
+        _(MacOS::SystemProfiler.system_version.to_s).must_equal('15.8.1')
+        _(MacOS::SystemProfiler.major_system_version).must_equal('15')
+        _(MacOS::SystemProfiler.minor_system_version).must_equal('8')
+        _(MacOS::SystemProfiler.tiny_system_version).must_equal('1')
+      end
+    end
+  end
+
+  describe "the kernel" do
+    it "reads its name and version" do
+      with_output do
+        _(MacOS::SystemProfiler.kernel_version_data).must_equal('Darwin 24.6.0')
+        _(MacOS::SystemProfiler.kernel_name).must_equal('Darwin')
+        _(MacOS::SystemProfiler.kernel_version_string).must_equal('24.6.0')
+        _(MacOS::SystemProfiler.kernel_version.to_s).must_equal('24.6.0')
+      end
+    end
+  end
+
+  describe "the other fields" do
+    it "reads each, by its method and by its aliases" do
+      with_output do
+        sp = MacOS::SystemProfiler
+        _([sp.boot_volume_data, sp.boot_volume_string]).must_equal(['Macintosh HD'] * 2)
+        _([sp.boot_mode_data, sp.boot_mode_string, sp.boot_mode]).must_equal(['Normal'] * 3)
+        _([sp.computer_name_data, sp.computer_name_string, sp.computer_name]).must_equal(['Example Mac'] * 3)
+        _([sp.username_data, sp.username_string, sp.username]).must_equal(['Example User (example)'] * 3)
+        _([sp.secure_virtual_memory_data, sp.secure_virtual_memory_string, sp.secure_virtual_memory]).must_equal(['Enabled'] * 3)
+        _([sp.system_integrity_protection_data, sp.system_integrity_protection_string, sp.system_integrity_protection]).must_equal(['Enabled'] * 3)
+        _([sp.time_since_boot_data, sp.time_since_boot_string, sp.time_since_boot]).must_equal(['6 days, 2 hours, 34 minutes'] * 3)
+      end
+    end
+
+    it "gives nil for a field which isn't there" do
+      with_output('') do
+        _(MacOS::SystemProfiler.boot_mode).must_be_nil
+      end
+    end
+  end
+
+  it "keeps its reading of a field to itself" do
+    _(MacOS::SystemProfiler.respond_to?(:field)).must_equal(false)
+  end
+end

data/test/MacOS/USBFlashDrive_test.rb

@@ -0,0 +1,20 @@
+require_relative '../helper'
+require 'MacOS/USBFlashDrive'
+
+describe MacOS::USBFlashDrive do
+  it "asks system_profiler for the USB devices" do
+    _(MacOS::USBFlashDrive.system_profiler_usb_data_type_command).must_equal('system_profiler SPUSBDataType')
+  end
+
+  it "gives every flash drive's mount point" do
+    MacOS::USBFlashDrive.stub(:raw_system_profiler_output, [fixture('system_profiler-SPUSBDataType.txt'), '', nil]) do
+      _(MacOS::USBFlashDrive.all_mount_points).must_equal(['/Volumes/EXAMPLE', '/Volumes/Example 2'])
+    end
+  end
+
+  it "gives none where no flash drive is mounted" do
+    MacOS::USBFlashDrive.stub(:raw_system_profiler_output, ["USB:\n", '', nil]) do
+      _(MacOS::USBFlashDrive.all_mount_points).must_equal([])
+    end
+  end
+end