puppetlabs-onceover 5.0.3 → 5.0.5

data/lib/puppetlabs-onceover/controlrepo.rb

@@ -672,14 +672,15 @@ class PuppetlabsOnceover
     end
 
     def find_classname(filename)
-      file = File.new(filename, "r")
-      while (line = file.gets)
-        begin
-          if line =~ /^class (\w+(?:::\w+)*)/
-            return $1
+      File.open(filename, "r") do |file|
+        while (line = file.gets)
+          begin
+            if line =~ /^class (\w+(?:::\w+)*)/
+              return $1
+            end
+          rescue ArgumentError => e
+            logger.error "ignoring invalid line in file: #{filename} (#{e.message}) - line: '#{line}'"
           end
-        rescue ArgumentError => e
-          logger.error "ignoring invalid line in file: #{filename} (#{e.message}) - line: '#{line}'"
         end
       end
       return nil

data/lib/puppetlabs-onceover/rake_tasks.rb

@@ -40,7 +40,7 @@ task :generate_onceover_yaml do
   repo = PuppetlabsOnceover::Controlrepo.new
   template_dir = File.expand_path('../../templates', File.dirname(__FILE__))
   onceover_yaml_template = File.read(File.expand_path('./controlrepo.yaml.erb', template_dir))
-  puts ERB.new(onceover_yaml_template, nil, '-').result(binding)
+  puts ERB.new(onceover_yaml_template, trim_mode: '-').result(binding)
 end
 
 task :generate_nodesets do
@@ -81,7 +81,7 @@ task :generate_nodesets do
     # Use an ERB template
     template_dir = File.expand_path('../../templates', File.dirname(__FILE__))
     fixtures_template = File.read(File.expand_path('./nodeset.yaml.erb', template_dir))
-    puts ERB.new(fixtures_template, nil, '-').result(binding)
+    puts ERB.new(fixtures_template, trim_mode: '-').result(binding)
   end
 end
 

data/lib/puppetlabs-onceover/vendored_modules.rb

@@ -1,6 +1,5 @@
 require 'puppet/version'
-require 'net/http'
-require 'uri'
+require 'git'
 require 'multi_json'
 require 'r10k/module_loader/puppetfile'
 require 'puppetlabs-onceover/logger'
@@ -69,16 +68,18 @@ class PuppetlabsOnceover
       # any puppet version this gem tests against). Neither is needed: the
       # module list is stable (see CORE_MODULES) and each module's own repo
       # is the authoritative source for its own latest version.
-      # https://docs.github.com/en/rest/repos/repos#list-repository-tags
+      #
+      # Tags are read via the git protocol (git ls-remote) rather than
+      # GitHub's REST API: the REST API's unauthenticated rate limit
+      # (60 req/hr) is shared across every GitHub-hosted Actions runner IP,
+      # so 10 sequential lookups per test run reliably exhausted it in CI.
+      # git's smart-HTTP protocol has no equivalent per-hour cap.
       @vendored_references = CORE_MODULES.map do |mod_name|
-        tags = query_or_cache(
-          "https://api.github.com/repos/puppetlabs/puppetlabs-#{mod_name}/tags",
-          nil,
-          component_cache(mod_name),
-        )
+        repo_url = "https://github.com/puppetlabs/puppetlabs-#{mod_name}.git"
+        tags = query_or_cache(repo_url, component_cache(mod_name))
         latest_tag = tags.first['name']
         {
-          'url' => "https://github.com/puppetlabs/puppetlabs-#{mod_name}.git",
+          'url' => repo_url,
           'ref' => "refs/tags/#{latest_tag}"
         }
       end
@@ -153,40 +154,36 @@ class PuppetlabsOnceover
       end
     end
 
-    # Return json from a query whom caches, or from the cache to avoid spamming github
-    def query_or_cache(url, params, filepath)
+    # Return tag data from a query whom caches, or from the cache to avoid
+    # re-querying the remote on every run
+    def query_or_cache(repo_url, filepath)
       if (File.exist? filepath) && (@force_update == false)
         logger.debug "Using cache: #{filepath}"
         json = read_json_dump(filepath)
       else
-        logger.debug "Making GET request to: #{url}"
-        json = github_get(url, params)
+        logger.debug "Listing tags for: #{repo_url}"
+        json = remote_tags(repo_url)
         logger.debug "Caching response to: #{filepath}"
         write_json_dump(filepath, json)
       end
       json
     end
 
-    # Given a github url and optional query parameters, return the parsed json body
-    def github_get(url, params)
-      uri = URI.parse(url)
-      uri.query = URI.encode_www_form(params) if params
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == 'https')
-      request = Net::HTTP::Get.new(uri.request_uri)
-      request['Accept'] = 'application/vnd.github.raw+json'
-      request['X-GitHub-Api-Version'] = '2022-11-28'
-      response = http.request(request)
-
-      case response
-      when Net::HTTPOK # 200
-        MultiJson.load(response.body)
-      else
-        # Expose the ratelimit response headers
-        # https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api?apiVersion=2022-11-28#checking-the-status-of-your-rate-limit
-        ratelimit_headers = response.to_hash.select { |k, _v| k =~ /x-ratelimit.*/ }
-        raise "#{response.code} #{response.message} #{ratelimit_headers}"
+    # Given a git remote url, return its tags as [{ 'name' => tag }, ...],
+    # sorted newest version first (matches the shape/ordering the old
+    # GitHub REST tags API returned, so callers can keep using .first).
+    def remote_tags(repo_url)
+      refs = Git.ls_remote(repo_url, refs: true)['tags'] || {}
+      versions = refs.keys.filter_map do |name|
+        next if name.end_with?('^{}') # annotated-tag dereference entries
+
+        begin
+          [Gem::Version.new(name.delete_prefix('v')), name]
+        rescue ArgumentError
+          nil # skip non-version-shaped tags
+        end
       end
+      versions.sort_by(&:first).reverse.map { |_version, name| { 'name' => name } }
     end
 
     # Returns parsed json of file

data/lib/puppetlabs-onceover/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class PuppetlabsOnceover
-  VERSION = '5.0.3'
+  VERSION = '5.0.5'
 end

data/spec/fixtures/controlrepos/deploy_test/Puppetfile

@@ -0,0 +1,3 @@
+forge "https://forge.puppet.com"
+
+mod "puppetlabs/stdlib", '4.11.0'

data/spec/fixtures/controlrepos/deploy_test/a_dir/nested_file.txt

@@ -0,0 +1 @@
+nested

data/spec/fixtures/controlrepos/deploy_test/a_symlink

@@ -0,0 +1 @@
+regular_file.txt

data/spec/fixtures/controlrepos/deploy_test/environment.conf

@@ -0,0 +1 @@
+modulepath          = site:modules:$basemodulepath

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