puppetlabs-onceover 5.0.3 → 5.0.4

data/spec/fixtures/controlrepos/deploy_test/regular_file.txt

@@ -0,0 +1 @@
+hello

data/spec/puppetlabs-onceover/beaker_spec.rb

@@ -0,0 +1,293 @@
+require 'spec_helper'
+require 'puppetlabs-onceover/beaker'
+
+# The `beaker`/`beaker-rspec` gems are intentionally NOT in this project's Gemfile
+# (removing that dependency is the whole point of this fork -- see CAT-2770 et al).
+# beaker.rb's deprecated, still-shippped `deploy_controlrepo_on`/`provision_and_test`/
+# `host_create` methods `require 'beaker-rspec'` / `require 'beaker/network_manager'`
+# and reference `::Beaker::NetworkManager` inline. To cover those code paths without
+# pulling the real (large, unmaintained-for-this-repo's-purposes) beaker gems back in,
+# stand in a minimal fake `::Beaker::NetworkManager` and make the specific `require`
+# calls those methods make into no-ops.
+module ::Beaker
+  unless defined?(::Beaker::NetworkManager)
+    class NetworkManager
+    end
+  end
+end
+
+describe "PuppetlabsOnceover::Beaker" do
+  before(:each) do
+    allow(Kernel).to receive(:warn)
+    allow_any_instance_of(Object).to receive(:require).and_wrap_original do |original, name|
+      %w[beaker-rspec beaker/network_manager].include?(name) || original.call(name)
+    end
+  end
+
+  describe ".facts_to_vagrant_box" do
+    it "maps Ubuntu facts to a puppetlabs vagrant box name" do
+      facts = { 'os' => { 'distro' => { 'id' => 'Ubuntu', 'release' => { 'major' => '20.04' } }, 'architecture' => 'x86_64' } }
+      expect(PuppetlabsOnceover::Beaker.facts_to_vagrant_box(facts)).to eq('puppetlabs/ubuntu-20.04-64-puppet')
+    end
+
+    it "maps Debian facts to a puppetlabs vagrant box name" do
+      facts = { 'os' => { 'distro' => { 'id' => 'Debian', 'release' => { 'full' => '10.9' } }, 'architecture' => 'x86_64' } }
+      expect(PuppetlabsOnceover::Beaker.facts_to_vagrant_box(facts)).to eq('puppetlabs/Debian-10.9-64-puppet')
+    end
+
+    it "maps RedHat family facts to a centos vagrant box name" do
+      facts = { 'os' => { 'family' => 'RedHat', 'release' => { 'major' => '7', 'minor' => '9' }, 'architecture' => 'x86_64' } }
+      expect(PuppetlabsOnceover::Beaker.facts_to_vagrant_box(facts)).to eq('puppetlabs/centos-7.9-64-puppet')
+    end
+
+    it "returns UNKNOWN when the OS cannot be determined" do
+      facts = { 'os' => { 'family' => 'SomeWeirdOS', 'architecture' => 'x86_64' } }
+      expect(PuppetlabsOnceover::Beaker.facts_to_vagrant_box(facts)).to eq('UNKNOWN')
+    end
+
+    it "detects 32-bit architectures" do
+      facts = { 'os' => { 'family' => 'RedHat', 'release' => { 'major' => '6', 'minor' => '0' } }, 'architecture' => 'i386' }
+      expect(PuppetlabsOnceover::Beaker.facts_to_vagrant_box(facts)).to eq('puppetlabs/centos-6.0-32-puppet')
+    end
+
+    it "recurses over an array of factsets" do
+      facts = [
+        { 'os' => { 'family' => 'RedHat', 'release' => { 'major' => '7', 'minor' => '0' }, 'architecture' => 'x86_64' } },
+        { 'os' => { 'family' => 'SomeWeirdOS', 'architecture' => 'x86_64' } }
+      ]
+      result = PuppetlabsOnceover::Beaker.facts_to_vagrant_box(facts)
+      expect(result).to eq(['puppetlabs/centos-7.0-64-puppet', 'UNKNOWN'])
+    end
+
+    it "does not blow up when the facts hash does not have the expected 'os' shape" do
+      expect(PuppetlabsOnceover::Beaker.facts_to_vagrant_box({ 'architecture' => 'x86_64' })).to eq('UNKNOWN')
+    end
+  end
+
+  describe ".facts_to_platform" do
+    it "maps RedHat family facts to an 'el' platform string" do
+      facts = { 'os' => { 'family' => 'RedHat', 'release' => { 'major' => '7' }, 'architecture' => 'x86_64' } }
+      expect(PuppetlabsOnceover::Beaker.facts_to_platform(facts)).to eq('el-7-64')
+    end
+
+    it "maps Ubuntu facts to an 'ubuntu' platform string" do
+      facts = { 'os' => { 'family' => 'Debian', 'distro' => { 'id' => 'Ubuntu', 'release' => { 'major' => '20.04' } }, 'architecture' => 'x86_64' } }
+      expect(PuppetlabsOnceover::Beaker.facts_to_platform(facts)).to eq('ubuntu-20.04-64')
+    end
+
+    it "maps Debian facts to a 'debian' platform string" do
+      facts = { 'os' => { 'family' => 'Debian', 'distro' => { 'id' => 'Debian', 'release' => { 'full' => '10.9' } }, 'architecture' => 'x86_64' } }
+      expect(PuppetlabsOnceover::Beaker.facts_to_platform(facts)).to eq('debian-10.9-64')
+    end
+
+    it "detects 32-bit architectures" do
+      facts = { 'os' => { 'family' => 'RedHat', 'release' => { 'major' => '6' }, 'architecture' => 'i386' } }
+      expect(PuppetlabsOnceover::Beaker.facts_to_platform(facts)).to eq('el-6-32')
+    end
+
+    it "produces a nil-nil platform string when nothing matches" do
+      facts = { 'os' => { 'family' => 'SomeWeirdOS', 'architecture' => 'x86_64' } }
+      expect(PuppetlabsOnceover::Beaker.facts_to_platform(facts)).to eq('--64')
+    end
+
+    it "recurses over an array of factsets" do
+      facts = [
+        { 'os' => { 'family' => 'RedHat', 'release' => { 'major' => '7' }, 'architecture' => 'x86_64' } },
+        { 'os' => { 'family' => 'RedHat', 'release' => { 'major' => '8' }, 'architecture' => 'x86_64' } }
+      ]
+      expect(PuppetlabsOnceover::Beaker.facts_to_platform(facts)).to eq(['el-7-64', 'el-8-64'])
+    end
+  end
+
+  describe ".deploy_controlrepo_on" do
+    it "installs r10k, git, copies the r10k config, and deploys via r10k on a single host" do
+      host = double('host')
+      repo = double('repo', r10k_config_file: '/tmp/r10k.yaml')
+
+      allow(PuppetlabsOnceover::Beaker).to receive(:require).and_return(true)
+      allow(host).to receive(:is_a?).with(Array).and_return(false)
+      allow(PuppetlabsOnceover::Beaker).to receive(:install_r10k_on)
+      allow(host).to receive(:install_package).with('git')
+      allow(PuppetlabsOnceover::Beaker).to receive(:scp_to)
+      allow(PuppetlabsOnceover::Beaker).to receive(:r10k_deploy)
+
+      PuppetlabsOnceover::Beaker.deploy_controlrepo_on(host, repo)
+
+      expect(PuppetlabsOnceover::Beaker).to have_received(:install_r10k_on).with(host)
+      expect(host).to have_received(:install_package).with('git')
+      expect(PuppetlabsOnceover::Beaker).to have_received(:scp_to).with(host, '/tmp/r10k.yaml', '/tmp/r10k.yaml')
+      expect(PuppetlabsOnceover::Beaker).to have_received(:r10k_deploy).with(host, { puppetfile: true, configfile: '/tmp/r10k.yaml' })
+    end
+
+    it "recurses when given an array of hosts (accepted quirk: iterates `hosts`, an undefined local, not the `host` array param)" do
+      host_array = double('host_array')
+      allow(host_array).to receive(:is_a?).with(Array).and_return(true)
+      repo = double('repo', r10k_config_file: '/tmp/r10k.yaml')
+
+      allow(PuppetlabsOnceover::Beaker).to receive(:install_r10k_on)
+      allow(host_array).to receive(:install_package)
+      allow(PuppetlabsOnceover::Beaker).to receive(:scp_to)
+      allow(PuppetlabsOnceover::Beaker).to receive(:r10k_deploy)
+
+      # `hosts.each { ... }` inside the `if host.is_a?(Array)` branch references an
+      # undefined local `hosts` (not the `host` param) -- a real bug in the source.
+      # It raises NameError immediately, so the array-recursion branch never actually
+      # recurses; we assert the crash rather than pretending it works.
+      expect { PuppetlabsOnceover::Beaker.deploy_controlrepo_on(host_array, repo) }.to raise_error(NameError, /hosts/)
+    end
+  end
+
+  describe ".provision_and_test" do
+    # provision_and_test's 4th positional param defaults to `PuppetlabsOnceover::Controlrepo.new`
+    # -- Ruby evaluates that default for any omitted arg before the method body (and its own
+    # raise checks) ever runs, and a real `Controlrepo.new` throws outside an actual controlrepo.
+    # Always pass an explicit (unused) repo double as the 4th arg to avoid tripping that default.
+    let(:unused_repo) { double('repo') }
+
+    it "raises when given an array of hosts" do
+      expect do
+        PuppetlabsOnceover::Beaker.provision_and_test([double('host')], 'role::example', {}, unused_repo)
+      end.to raise_error(RuntimeError, /must be a single host object/)
+    end
+
+    it "raises when puppet_class is not a String" do
+      expect do
+        PuppetlabsOnceover::Beaker.provision_and_test(double('host'), :not_a_string, {}, unused_repo)
+      end.to raise_error(RuntimeError, /must be a single Class/)
+    end
+
+    it "provisions (when host is not up), applies the manifest, checks idempotency, and cleans up" do
+      host = double('host', up?: false)
+      network_manager = double('network_manager')
+      allow(network_manager).to receive(:instance_variable_set)
+      allow(network_manager).to receive(:provision)
+      allow(network_manager).to receive(:proxy_package_manager)
+      allow(network_manager).to receive(:validate)
+      allow(network_manager).to receive(:configure)
+      allow(network_manager).to receive(:cleanup)
+      allow(Beaker::NetworkManager).to receive(:new).and_return(network_manager)
+
+      apply_calls = []
+      allow(PuppetlabsOnceover::Beaker).to receive(:apply_manifest_on) do |h, manifest, opts|
+        apply_calls << [h, manifest, opts]
+      end
+      allow(PuppetlabsOnceover::Beaker).to receive(:options).and_return({})
+      allow(PuppetlabsOnceover::Beaker).to receive(:logger).and_return(double('logger'))
+
+      PuppetlabsOnceover::Beaker.provision_and_test(host, 'role::example', {}, unused_repo)
+
+      expect(network_manager).to have_received(:provision)
+      expect(network_manager).to have_received(:cleanup)
+      expect(apply_calls.map { |c| c[2] }).to include({ catch_failures: true }, { catch_changes: true })
+    end
+
+    it "skips provisioning when the host is already up, and skips idempotency check when disabled" do
+      host = double('host', up?: true)
+      network_manager = double('network_manager')
+      allow(network_manager).to receive(:instance_variable_set)
+      allow(network_manager).to receive(:cleanup)
+      allow(Beaker::NetworkManager).to receive(:new).and_return(network_manager)
+
+      apply_calls = []
+      allow(PuppetlabsOnceover::Beaker).to receive(:apply_manifest_on) do |h, manifest, opts|
+        apply_calls << [h, manifest, opts]
+      end
+      allow(PuppetlabsOnceover::Beaker).to receive(:options).and_return({})
+      allow(PuppetlabsOnceover::Beaker).to receive(:logger).and_return(double('logger'))
+
+      PuppetlabsOnceover::Beaker.provision_and_test(host, 'role::example', { check_idempotency: false, runs_before_idempotency: 2 }, unused_repo)
+
+      expect(apply_calls.size).to eq(2)
+      expect(apply_calls.map { |c| c[2] }).to eq([{ catch_failures: true }, { catch_failures: true }])
+    end
+  end
+
+  describe ".match_indentation" do
+    it "sets the logger's line_prefix based on the scoped_id depth" do
+      test = double('test', metadata: { scoped_id: '1:2:3' })
+      logger = double('logger')
+      expect(logger).to receive(:line_prefix=).with('    ')
+      PuppetlabsOnceover::Beaker.match_indentation(test, logger)
+    end
+
+    it "uses no prefix for a top-level scoped_id" do
+      test = double('test', metadata: { scoped_id: '1' })
+      logger = double('logger')
+      expect(logger).to receive(:line_prefix=).with('')
+      PuppetlabsOnceover::Beaker.match_indentation(test, logger)
+    end
+  end
+
+  describe ".host_create" do
+    it "builds a single host via a NetworkManager, wires up a down! method, and returns it" do
+      nodes = { HOSTS: { 'centos7' => { platform: 'el-7-x86_64' }, 'other' => { platform: 'ubuntu' } }, other_opt: 'value' }
+
+      host_double = double('host')
+      allow(host_double).to receive(:instance_variable_set)
+      allow(host_double).to receive(:define_singleton_method)
+
+      network_manager = double('network_manager')
+      allow(network_manager).to receive(:provision)
+      allow(network_manager).to receive(:proxy_package_manager)
+      allow(network_manager).to receive(:validate)
+      allow(network_manager).to receive(:configure)
+      allow(network_manager).to receive(:instance_variable_get).with(:@hosts).and_return([host_double])
+      allow(Beaker::NetworkManager).to receive(:new).and_return(network_manager)
+      allow(PuppetlabsOnceover::Beaker).to receive(:logger).and_return(double('logger'))
+      allow(PuppetlabsOnceover::Beaker).to receive(:hosts).and_return([host_double])
+
+      result = PuppetlabsOnceover::Beaker.host_create('centos7', nodes)
+
+      expect(result).to eq(host_double)
+      expect(Beaker::NetworkManager).to have_received(:new) do |opts, _logger|
+        expect(opts[:HOSTS]).to eq({ 'centos7' => { platform: 'el-7-x86_64' } })
+        expect(opts[:other_opt]).to eq('value')
+      end
+    end
+
+    it "supports the default_proc string/symbol key fallback on current_opts" do
+      nodes = { HOSTS: { 'centos7' => {} } }
+      captured_opts = nil
+
+      host_double = double('host')
+      allow(host_double).to receive(:instance_variable_set)
+      allow(host_double).to receive(:define_singleton_method)
+
+      network_manager = double('network_manager')
+      allow(network_manager).to receive(:provision)
+      allow(network_manager).to receive(:proxy_package_manager)
+      allow(network_manager).to receive(:validate)
+      allow(network_manager).to receive(:configure)
+      allow(network_manager).to receive(:instance_variable_get).with(:@hosts).and_return([host_double])
+      allow(Beaker::NetworkManager).to receive(:new) do |opts, _logger|
+        captured_opts = opts
+        network_manager
+      end
+      allow(PuppetlabsOnceover::Beaker).to receive(:logger).and_return(double('logger'))
+      allow(PuppetlabsOnceover::Beaker).to receive(:hosts).and_return([host_double])
+
+      PuppetlabsOnceover::Beaker.host_create('centos7', nodes)
+
+      expect(captured_opts[:HOSTS]).to eq({ 'centos7' => {} })
+      expect(captured_opts['HOSTS']).to eq({ 'centos7' => {} })
+    end
+
+    it "raises if the network manager created more than one host" do
+      nodes = { HOSTS: { 'centos7' => {} } }
+
+      network_manager = double('network_manager')
+      allow(network_manager).to receive(:provision)
+      allow(network_manager).to receive(:proxy_package_manager)
+      allow(network_manager).to receive(:validate)
+      allow(network_manager).to receive(:configure)
+      allow(network_manager).to receive(:instance_variable_get).with(:@hosts).and_return([double('a'), double('b')])
+      allow(Beaker::NetworkManager).to receive(:new).and_return(network_manager)
+      allow(PuppetlabsOnceover::Beaker).to receive(:logger).and_return(double('logger'))
+      allow(PuppetlabsOnceover::Beaker).to receive(:hosts).and_return([double('a'), double('b')])
+
+      expect do
+        PuppetlabsOnceover::Beaker.host_create('centos7', nodes)
+      end.to raise_error(RuntimeError, /too many machines/)
+    end
+  end
+end

data/spec/puppetlabs-onceover/class_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'puppetlabs-onceover/class'
+require 'puppetlabs-onceover/controlrepo'
+
+describe "PuppetlabsOnceover::Class" do
+  before(:each) do
+    PuppetlabsOnceover::Class.class_variable_set(:@@all, [])
+    # Silence the info/warn logging noise from the shared $logger global
+    logger.level = :fatal
+  end
+
+  describe ".name_is_regexp?" do
+    it "returns true for a /.../ delimited string" do
+      expect(PuppetlabsOnceover::Class.name_is_regexp?('/role::/')).to eq(true)
+    end
+
+    it "returns false for a plain string" do
+      expect(PuppetlabsOnceover::Class.name_is_regexp?('role::webserver')).to eq(false)
+    end
+
+    it "returns false for a string that only starts with /" do
+      expect(PuppetlabsOnceover::Class.name_is_regexp?('/role::webserver')).to eq(false)
+    end
+  end
+
+  describe ".string_to_regexp" do
+    it "converts a /.../ delimited string into a Regexp" do
+      expect(PuppetlabsOnceover::Class.string_to_regexp('/role::/')).to eq(Regexp.new('role::'))
+    end
+
+    it "raises when the string is not regexp-shaped" do
+      expect { PuppetlabsOnceover::Class.string_to_regexp('role::webserver') }.to raise_error(
+        RuntimeError, /does not start and end with/
+      )
+    end
+  end
+
+  describe "#initialize" do
+    it "sets the name and adds itself to .all for a plain class name" do
+      cls = PuppetlabsOnceover::Class.new('role::webserver')
+      expect(cls.name).to eq('role::webserver')
+      expect(PuppetlabsOnceover::Class.all).to eq([cls])
+    end
+
+    context "when given a regexp name" do
+      before(:each) do
+        PuppetlabsOnceover::Controlrepo.new(path: 'spec/fixtures/controlrepos/function_mocking')
+      end
+
+      it "expands into one Class object per matching controlrepo class, and does not add the regexp itself" do
+        PuppetlabsOnceover::Class.new('/role::/')
+        names = PuppetlabsOnceover::Class.all.map(&:name)
+        expect(names).not_to be_empty
+        expect(names).to all(match(/role::/))
+      end
+
+      it "creates no objects when nothing matches" do
+        PuppetlabsOnceover::Class.new('/nothing_matches_this_prefix_xyz::/')
+        expect(PuppetlabsOnceover::Class.all).to eq([])
+      end
+    end
+  end
+
+  describe ".find" do
+    it "finds an exact match by name" do
+      cls = PuppetlabsOnceover::Class.new('role::webserver')
+      expect(PuppetlabsOnceover::Class.find('role::webserver')).to eq(cls)
+    end
+
+    it "returns nil (and warns) when nothing matches" do
+      expect(PuppetlabsOnceover::Class.find('role::does_not_exist')).to be_nil
+    end
+
+    it "finds all matches when given a regexp name" do
+      a = PuppetlabsOnceover::Class.new('role::a')
+      b = PuppetlabsOnceover::Class.new('profile::b')
+      expect(PuppetlabsOnceover::Class.find('/role::/')).to eq([a])
+      expect(PuppetlabsOnceover::Class.find('/role::/')).not_to include(b)
+    end
+  end
+
+  describe ".all" do
+    it "returns every class created so far" do
+      a = PuppetlabsOnceover::Class.new('role::a')
+      b = PuppetlabsOnceover::Class.new('role::b')
+      expect(PuppetlabsOnceover::Class.all).to eq([a, b])
+    end
+  end
+end

data/spec/puppetlabs-onceover/cli/run_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'puppetlabs-onceover/cli/run'
+
+describe PuppetlabsOnceover::CLI::Run do
+  describe '.command' do
+    it 'builds a memoized Cri::Command named run' do
+      cmd = described_class.command
+      expect(cmd).to be_a(Cri::Command)
+      expect(cmd.name).to eq('run')
+      expect(described_class.command).to equal(cmd)
+    end
+
+    it 'prints help and exits 0 when run directly' do
+      allow_any_instance_of(Object).to receive(:exit)
+      expect { described_class.command.run([]) }.to output(/Runs either the spec or acceptance tests/).to_stdout
+    end
+
+    it 'registers the spec and acceptance subcommands' do
+      names = described_class.command.subcommands.map(&:name)
+      expect(names).to include('spec', 'acceptance')
+    end
+  end
+
+  describe PuppetlabsOnceover::CLI::Run::Spec do
+    describe '.command' do
+      it 'builds a memoized Cri::Command named spec' do
+        cmd = described_class.command
+        expect(cmd).to be_a(Cri::Command)
+        expect(cmd.name).to eq('spec')
+        expect(described_class.command).to equal(cmd)
+      end
+
+      it 'deploys locally then prepares and runs the spec suite' do
+        repo = double('repo', onceover_yaml: '/some/repo/.onceover.yaml')
+        config = double('config')
+        deploy = double('deploy', deploy_local: nil)
+        runner = double('runner', prepare!: nil, run_spec!: nil)
+
+        allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+        allow(PuppetlabsOnceover::TestConfig).to receive(:new).and_return(config)
+        allow(PuppetlabsOnceover::Deploy).to receive(:new).and_return(deploy)
+        allow(PuppetlabsOnceover::Runner).to receive(:new).and_return(runner)
+
+        described_class.command.run([])
+
+        expect(deploy).to have_received(:deploy_local).with(repo, anything)
+        expect(PuppetlabsOnceover::Runner).to have_received(:new).with(repo, config, :spec)
+        expect(runner).to have_received(:prepare!)
+        expect(runner).to have_received(:run_spec!)
+      end
+    end
+  end
+
+  describe PuppetlabsOnceover::CLI::Run::Acceptance do
+    describe '.command' do
+      it 'builds a memoized Cri::Command named acceptance' do
+        cmd = described_class.command
+        expect(cmd).to be_a(Cri::Command)
+        expect(cmd.name).to eq('acceptance')
+        expect(described_class.command).to equal(cmd)
+      end
+
+      it 'warns about deprecation then prepares and runs the acceptance suite' do
+        repo = double('repo', onceover_yaml: '/some/repo/.onceover.yaml')
+        config = double('config')
+        runner = double('runner', prepare!: nil, run_acceptance!: nil)
+
+        allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+        allow(PuppetlabsOnceover::TestConfig).to receive(:new).and_return(config)
+        allow(PuppetlabsOnceover::Runner).to receive(:new).and_return(runner)
+
+        expect { described_class.command.run([]) }.to output(/DEPRECATION/).to_stderr
+
+        expect(PuppetlabsOnceover::Runner).to have_received(:new).with(repo, config, :acceptance)
+        expect(runner).to have_received(:prepare!)
+        expect(runner).to have_received(:run_acceptance!)
+      end
+    end
+  end
+end

data/spec/puppetlabs-onceover/cli/show_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'puppetlabs-onceover/cli/show'
+
+describe PuppetlabsOnceover::CLI::Show do
+  describe '.command' do
+    it 'builds a memoized Cri::Command named show' do
+      cmd = described_class.command
+      expect(cmd).to be_a(Cri::Command)
+      expect(cmd.name).to eq('show')
+      expect(described_class.command).to equal(cmd)
+    end
+
+    it 'prints help and exits 0 when run directly' do
+      allow_any_instance_of(Object).to receive(:exit)
+      expect { described_class.command.run([]) }.to output(/Shows the current state of things/).to_stdout
+    end
+
+    it 'registers the repo and puppetfile subcommands' do
+      names = described_class.command.subcommands.map(&:name)
+      expect(names).to include('repo', 'puppetfile')
+    end
+  end
+
+  describe PuppetlabsOnceover::CLI::Show::Repo do
+    describe '.command' do
+      it 'builds a memoized Cri::Command named repo' do
+        cmd = described_class.command
+        expect(cmd).to be_a(Cri::Command)
+        expect(cmd.name).to eq('repo')
+        expect(described_class.command).to equal(cmd)
+      end
+
+      it 'prints repo and test config information and exits 0' do
+        allow_any_instance_of(Object).to receive(:exit)
+        repo = double('repo', to_s: 'REPO INFO', onceover_yaml: '/some/repo/.onceover.yaml')
+        config = double('config', to_s: 'CONFIG INFO')
+        allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+        allow(PuppetlabsOnceover::TestConfig).to receive(:new).and_return(config)
+
+        expect { described_class.command.run([]) }.to output(/REPO INFO/).to_stdout
+        expect { described_class.command.run([]) }.to output(/CONFIG INFO/).to_stdout
+        expect(PuppetlabsOnceover::TestConfig).to have_received(:new).with(repo.onceover_yaml, anything).at_least(:once)
+      end
+    end
+  end
+
+  describe PuppetlabsOnceover::CLI::Show::Puppetfile do
+    describe '.command' do
+      it 'builds a memoized Cri::Command named puppetfile' do
+        cmd = described_class.command
+        expect(cmd).to be_a(Cri::Command)
+        expect(cmd.name).to eq('puppetfile')
+        expect(described_class.command).to equal(cmd)
+      end
+
+      it 'prints the puppetfile table and exits 0' do
+        allow_any_instance_of(Object).to receive(:exit)
+        repo = double('repo', print_puppetfile_table: nil)
+        allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+
+        described_class.command.run([])
+
+        expect(repo).to have_received(:print_puppetfile_table)
+      end
+    end
+  end
+end

data/spec/puppetlabs-onceover/cli_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'puppetlabs-onceover/cli'
+require 'puppetlabs-onceover/cli/init'
+require 'puppetlabs-onceover/cli/update'
+require 'puppetlabs-onceover/cli/plugins'
+
+describe PuppetlabsOnceover::CLI do
+  describe '.command' do
+    it 'builds a memoized Cri::Command named onceover' do
+      cmd = described_class.command
+      expect(cmd).to be_a(Cri::Command)
+      expect(cmd.name).to eq('onceover')
+      expect(described_class.command).to equal(cmd)
+    end
+
+    it 'prints help and exits 0 when run with no subcommand' do
+      allow_any_instance_of(Object).to receive(:exit)
+      expect { described_class.command.run([]) }.to output(/Tool for testing Puppet controlrepos/).to_stdout
+    end
+
+    it 'prints help and exits 0 when given -h' do
+      allow_any_instance_of(Object).to receive(:exit)
+      expect { described_class.command.run(['-h']) }.to output(/onceover/).to_stdout
+    end
+
+    it 'registers the show, run, init, and update subcommands' do
+      names = described_class.command.subcommands.map(&:name)
+      expect(names).to include('show', 'run', 'init', 'update')
+    end
+  end
+end
+
+describe PuppetlabsOnceover::CLI::Init do
+  describe '.command' do
+    it 'builds a memoized Cri::Command named init' do
+      cmd = described_class.command
+      expect(cmd).to be_a(Cri::Command)
+      expect(cmd.name).to eq('init')
+      expect(described_class.command).to equal(cmd)
+    end
+
+    it 'calls Controlrepo.init with a freshly built Controlrepo' do
+      repo = double('repo')
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:init)
+
+      described_class.command.run([])
+
+      expect(PuppetlabsOnceover::Controlrepo).to have_received(:init).with(repo)
+    end
+  end
+end
+
+describe PuppetlabsOnceover::CLI::Update do
+  describe '.command' do
+    it 'prints help and exits 0 when run directly' do
+      allow_any_instance_of(Object).to receive(:exit)
+      expect { described_class.command.run([]) }.to output(/Updates stuff/).to_stdout
+    end
+  end
+
+  describe PuppetlabsOnceover::CLI::Update::Puppetfile do
+    it 'calls update_puppetfile on a freshly built Controlrepo and exits 0' do
+      allow_any_instance_of(Object).to receive(:exit)
+      repo = double('repo', update_puppetfile: nil)
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+
+      described_class.command.run([])
+
+      expect(repo).to have_received(:update_puppetfile)
+    end
+  end
+end
+
+describe 'cli/plugins.rb' do
+  it 'requires the plugins file without error, discovering zero or more onceover-* gems' do
+    expect { load File.expand_path('../../lib/puppetlabs-onceover/cli/plugins.rb', __dir__) }.not_to raise_error
+  end
+end