chef-umami 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 20229674bc6c78285cdb0e431520c7586128e9a5
-  data.tar.gz: 67e17a4cd7045f7105f7ab83aecdc858e02fcfec
+SHA256:
+  metadata.gz: c4b494656c612150234d8aadf2f2b9522ce278bf2a279d7de9c187a2afc63ec5
+  data.tar.gz: 790ea90397d73c0defa6c600246d66faa7c4618fd2ec337e091dd37a4779d2d1
 SHA512:
-  metadata.gz: 93f9eaf93b7b68f378793c8745c6dda3235240a568093e0d7d82da4873d51a9e24eb08d34e8f3aaaf383c0a9f779c95c6b247c6e911319f22a462f99b91f96d2
-  data.tar.gz: aec07f530e3fd0bbb618046315845f30927eb3cd8b37e9026202ebf62891f19128d9579f66debd12f5966331a886e07b613b80d96676640b259fe86aea9fd7bd
+  metadata.gz: ca092e6173b6b1d8827cf5191145b271341e159e4cb9ecff7ddaa4cf8e795f0ed3d551b49694e8f9ad7c4c4b4c5c2bde5742e571b918b6e3a75115afed39104a
+  data.tar.gz: aa896dd76d1e333b8e28144ad837d345228c751551d1ec0681f3f79d6ca36c65c8a1cfd2d677b9fccf74ff9fbd0ea57627c4b0bdd98b8a2a04e506a803ad37b3

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.1.0]
+
+Updates to support modern Chef.
+
+- Specifically Chef 14.x and ChefDK 3.4.x.
+- Replaces the export/upload mechanism with the push mechanism as it does all that work anyhow.
+  - Honestly, the only thing being used by the previous export functionality was the Chef client config. The rest was waste.
+- Updates `Umami::Client` to manage creating and ingesting the config we need.
+- Adds `Umami::Policyfile::PolicyfileLock` as a convenience.
+- Minor updates to address changes in Chef/ChefDK support and methods.
+- Fixes up Rubocop support within Umami as well as that used for testing Umami itself.
+
 ## [0.0.6]
 - Adds tests.
 - Updates gem dependencies to use newer versions of Chef and ChefDK.

data/lib/chef-umami/client.rb

@@ -13,17 +13,96 @@
 #   limitations under the License.
 
 require 'chef'
+require 'chef-umami/policyfile/policyfile_lock'
+require 'tmpdir' # Extends Dir
+
+# NOTE: Lifts some code from https://github.com/chef/chef-dk/blob/master/lib/chef-dk/policyfile_services/export_repo.rb
 
 module Umami
   class Client
-    def initialize
-      @client = client
+    attr_reader :config_path
+    attr_reader :policyfile
+    attr_reader :staging_dir # Where Umami will stage files.
+    def initialize(policyfile = nil)
+      @client          = client
+      @policy_name     = nil
+      @policyfile      = policyfile
+      @staging_dir     = Dir.mktmpdir('umami-')
+      @config_path     = client_rb_staging_path
+    end
+
+    def policy_name
+      @policy_name ||= Umami::Policyfile::PolicyfileLock.new(policyfile).name
     end
 
     def client
       @client ||= Chef::Client.new
     end
 
+    def fake_client_key
+      File.join(staging_dir, 'umami.pem')
+    end
+
+    def cp_fake_client_key
+      # Create a fake client cert based on a dummy cert we have laying around.
+      fake_client_key_src = File.join(File.dirname(__FILE__), %w(.. .. support umami.pem))
+      FileUtils.cp(fake_client_key_src, fake_client_key)
+    end
+
+    def dot_chef_staging_dir
+      dot_dir = File.join(staging_dir, '.chef')
+      FileUtils.mkdir_p(dot_dir)
+      dot_dir
+    end
+
+    def client_rb_staging_path
+      File.join(dot_chef_staging_dir, 'config.rb')
+    end
+
+    def create_client_rb
+      File.open(client_rb_staging_path, 'wb+') do |f|
+        f.print(<<~CONFIG)
+          ### Chef Client Configuration ###
+          # The settings in this file will configure chef to apply the exported policy in
+          # this directory. To use it, run:
+          #
+          # chef-client -z
+          #
+          policy_name '#{policy_name}'
+          policy_group 'local'
+          use_policyfile true
+          policy_document_native_api true
+          chef_server_url 'http://127.0.0.1:8889'
+          node_name 'umami-node'
+          client_key '#{fake_client_key}'
+          # In order to use this repo, you need a version of Chef Client and Chef Zero
+          # that supports policyfile "native mode" APIs:
+          current_version = Gem::Version.new(Chef::VERSION)
+          unless Gem::Requirement.new(">= 12.7").satisfied_by?(current_version)
+            puts("!" * 80)
+            puts(<<-MESSAGE)
+          This Chef Repo requires features introduced in Chef 12.7, but you are using
+          Chef \#{Chef::VERSION}. Please upgrade to Chef 12.7 or later.
+          MESSAGE
+            puts("!" * 80)
+            exit!(1)
+          end
+        CONFIG
+      end
+    end
+
+    def build_config
+      create_client_rb
+      cp_fake_client_key
+    end
+
+    def apply_config!
+      build_config
+      Chef::Config.from_file(config_path)
+      # Define Chef::Config['config_file'] lest Ohai complain.
+      Chef::Config['config_file'] = config_path
+    end
+
     # Perform the steps required prior to compiling resources, including
     # running Ohai and building up the node object.
     def prep

data/lib/chef-umami/helpers/filetools.rb

@@ -32,7 +32,7 @@ module Umami
         r = RuboCop::CLI.new
         # Don't output to STDOUT.
         args = [
-          '--only', 'Style/IndentationWidth,Style/IndentationConsistency',
+          '--only', 'Layout/IndentationWidth,Layout/IndentationConsistency',
           '--auto-correct',
           '--out', '/dev/null',
           path

data/lib/chef-umami/policyfile/{uploader.rb → policyfile_lock.rb}

@@ -12,35 +12,35 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-require 'chef-dk/authenticated_http'
 require 'chef-dk/policyfile/storage_config'
-require 'chef-dk/policyfile/uploader'
 require 'chef-dk/policyfile_lock'
 require 'chef-dk/ui'
 
 module Umami
   class Policyfile
-    class Uploader
-      attr_reader :policyfile_lock_file
-      def initialize(policyfile_lock_file = nil)
-        @http_client = http_client
-        @policyfile_lock_file = policyfile_lock_file
-        @policyfile_lock = policyfile_lock
-        @policyfile_uploader = policyfile_uploader
-        @storage_config = storage_config
-        @ui = ui
+    class PolicyfileLock
+      attr_reader :policyfile
+      def initialize(policyfile = nil)
+        @policyfile      = policyfile
+        @policyfile_lock = nil
+        @storage_config  = storage_config
+        @ui              = ui
       end
 
       def storage_config
-        @storage_config ||= ChefDK::Policyfile::StorageConfig.new.use_policyfile(policyfile_lock_file)
+        @storage_config ||= ChefDK::Policyfile::StorageConfig.new.use_policyfile(policyfile)
       end
 
       def ui
         @ui ||= ChefDK::UI.new
       end
 
+      def policyfile_lock_path
+        policyfile.gsub(/\.rb$/, '.lock.json')
+      end
+
       def policyfile_lock_content
-        IO.read(policyfile_lock_file)
+        IO.read(policyfile_lock_path)
       end
 
       def lock_data
@@ -54,31 +54,8 @@ module Umami
         ).build_from_lock_data(lock_data)
       end
 
-      def http_client
-        @http_client ||= ChefDK::AuthenticatedHTTP.new(Chef::Config['chef_server_url'])
-      end
-
-      def policy_group
-        Chef::Config['policy_group']
-      end
-
-      def policy_document_native_api
-        true
-      end
-
-      def policyfile_uploader
-        @policyfile_uploader ||= ChefDK::Policyfile::Uploader.new(
-          policyfile_lock,
-          policy_group,
-          ui: ui,
-          http_client: http_client,
-          policy_document_native_api: policy_document_native_api
-        )
-      end
-
-      # Push the policy, including all dependent cookbooks.
-      def upload
-        policyfile_uploader.upload
+      def name
+        policyfile_lock.name
       end
     end
   end

data/lib/chef-umami/policyfile_services/push.rb

@@ -0,0 +1,46 @@
+#   Copyright 2017 Bloomberg Finance, L.P.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+require 'chef-dk/policyfile_services/push'
+
+module Umami
+  class PolicyfileServices
+    class Push < ChefDK::PolicyfileServices::Push
+      def initialize(policyfile: nil, ui: nil, policy_group: nil, config: nil, root_dir: nil)
+        super(policyfile: policyfile, ui: ui, policy_group: policy_group,
+              config: config, root_dir: root_dir)
+      end
+
+      # Keep up with the times and force use of the newer API.
+      def api_version
+        '2'
+      end
+
+      # We'll override the #http_client method to ensure we set the appropriate
+      # API version we expect to be used. Chef::Authenticator#request_version
+      # will use this to set the appropriate header that Chef Server (Zero)
+      # uses to determine how to generate cookbook manifests. Without this, we
+      # see issues during the Umami::Client#compile phase where Chef cannot
+      # locate recipes within a cookbook and `umami` fails miserably.
+      # I spent a week debugging this when trying to update `umami` to support
+      # newer Chef libraries. That, too, was miserable.
+      def http_client
+        @http_client ||= Chef::ServerAPI.new(config.chef_server_url,
+                                             signing_key_filename: config.client_key,
+                                             client_name: config.node_name,
+                                             api_version: api_version)
+      end
+    end
+  end
+end

data/lib/chef-umami/runner.rb

@@ -18,10 +18,10 @@ require 'chef-umami/client'
 require 'chef-umami/logger'
 require 'chef-umami/options'
 require 'chef-umami/server'
-require 'chef-umami/policyfile/exporter'
-require 'chef-umami/policyfile/uploader'
+require 'chef-umami/policyfile_services/push'
 require 'chef-umami/test/unit'
 require 'chef-umami/test/integration'
+require 'chef-dk/ui'
 
 module Umami
   class Runner
@@ -30,24 +30,36 @@ module Umami
 
     attr_reader :cookbook_dir
     def initialize
-      @config = config
+      @umami_config = umami_config
       @cookbook_dir = Dir.pwd
-      @exporter = exporter
-      @chef_zero_server = chef_zero_server
-      # If we load the uploader or client now, they won't see the updated
-      # Chef config!
-      @uploader = nil
+      ## If we load the pusher or client now, they won't see the updated
+      ## Chef config!
+      @push = nil
       @chef_client = nil
+      @ui = ui
     end
 
-    # A hash of values describing the config. Comprised of command line
+    # A hash of values describing the Umami config. Comprised of command line
     # options. May (in the future) contain options read from a config file.
-    def config
-      @config ||= parse_options
+    def umami_config
+      @umami_config ||= parse_options
+    end
+
+    # Convenience to return the Chef::Config singleton.
+    def chef_config
+      Chef::Config
+    end
+
+    def ui
+      @ui ||= ChefDK::UI.new
     end
 
     def policyfile
-      config[:policyfile]
+      umami_config[:policyfile]
+    end
+
+    def policy_group
+      chef_config['policy_group']
     end
 
     # Return the computed policyfile lock name.
@@ -65,12 +77,14 @@ module Umami
       end
     end
 
-    def exporter
-      @exporter ||= Umami::Policyfile::Exporter.new(policyfile_lock_file, cookbook_dir, policyfile)
-    end
-
-    def uploader
-      @uploader ||= Umami::Policyfile::Uploader.new(policyfile_lock_file)
+    def push
+      # rubocop:disable Layout/AlignHash
+      @push ||= Umami::PolicyfileServices::Push.new(policyfile: policyfile,
+                                                      ui:           ui,
+                                                      policy_group: policy_group,
+                                                      config:       chef_config,
+                                                      root_dir:     cookbook_dir)
+      # rubocop:enable Layout/AlignHash
     end
 
     def chef_zero_server
@@ -78,31 +92,27 @@ module Umami
     end
 
     def chef_client
-      @chef_client ||= Umami::Client.new
+      @chef_client ||= Umami::Client.new(policyfile)
     end
 
     def run
       validate_lock_file!
-      puts "\nExporting the policy, related cookbooks, and a valid client configuration..."
-      exporter.export
-      Chef::Config.from_file(exporter.chef_config_file)
+      chef_client.apply_config!
       chef_zero_server.start
       puts "\nUploading the policy and related cookbooks..."
-      uploader.upload
+      push.run
       puts "\nExecuting chef-client compile phase..."
-      # Define Chef::Config['config_file'] lest Ohai complain.
-      Chef::Config['config_file'] = exporter.chef_config_file
       chef_client.compile
       # Build a hash of all the recipes' resources, keyed by the canonical
       # name of the recipe (i.e. ohai::default).
       recipe_resources = {}
       chef_client.resource_collection.each do |resource|
         canonical_recipe = "#{resource.cookbook_name}::#{resource.recipe_name}"
-        unless config[:recipes].empty?
+        unless umami_config[:recipes].nil? || umami_config[:recipes].empty?
           # The user has explicitly requested that one or more recipes have
           # tests written, to the exclusion of others.
           # ONLY include the recipe if it matches the list.
-          next unless config[:recipes].include?(canonical_recipe)
+          next unless umami_config[:recipes].include?(canonical_recipe)
         end
         if recipe_resources.key?(canonical_recipe)
           recipe_resources[canonical_recipe] << resource
@@ -114,17 +124,17 @@ module Umami
       # Remove the temporary directory using a naive guard to ensure we're
       # deleting what we expect.
       re_export_path = Regexp.new('/tmp/umami')
-      FileUtils.rm_rf(exporter.export_root) if exporter.export_root.match(re_export_path)
+      FileUtils.rm_rf(chef_client.staging_dir) if chef_client.staging_dir.match(re_export_path)
 
-      if config[:unit_tests]
+      if umami_config[:unit_tests]
         puts "\nGenerating a set of unit tests..."
-        unit_tester = Umami::Test::Unit.new(config[:test_root])
+        unit_tester = Umami::Test::Unit.new(umami_config[:test_root])
         unit_tester.generate(recipe_resources)
       end
 
-      if config[:integration_tests]
+      if umami_config[:integration_tests]
         puts "\nGenerating a set of integration tests..."
-        integration_tester = Umami::Test::Integration.new(config[:test_root])
+        integration_tester = Umami::Test::Integration.new(umami_config[:test_root])
         integration_tester.generate(recipe_resources)
       end
     end

data/lib/chef-umami/test/integration.rb

@@ -49,6 +49,7 @@ module Umami
           return if resource.action.include?(:delete)
         end
         return if resource.action == :delete
+
         "\n" + send("test_#{resource.declared_type}", resource)
       end
 

data/lib/chef-umami/test/unit.rb

@@ -60,8 +60,9 @@ module Umami
 
       def write_test(resource = nil)
         state_attrs = [] # Attribute hash to be used with #with()
-        resource.state.each do |attr, value|
+        resource.state_for_resource_reporter.each do |attr, value|
           next if value.nil? || (value.respond_to?(:empty) && value.empty?)
+
           if value.is_a? String
             value = value.gsub("'", "\\\\'") # Escape any single quotes in the value.
           end
@@ -90,6 +91,7 @@ module Umami
           (cookbook, recipe) = canonical_recipe.split('::')
           # Only write unit tests for the cookbook we're in.
           next unless cookbook == tested_cookbook
+
           content = [preamble(cookbook, recipe)]
           resources.each do |resource|
             content << write_test(resource)

data/lib/chef-umami/version.rb

@@ -13,5 +13,5 @@
 #   limitations under the License.
 
 module Umami
-  VERSION = '0.0.6'.freeze
+  VERSION = '0.1.0'.freeze
 end

data/spec/runner_spec.rb

@@ -18,17 +18,16 @@ RSpec.describe Umami::Runner do
   it 'initiates a Umami::Runner object' do
     runner = Umami::Runner.new
     expect(runner).to be_an_instance_of(Umami::Runner)
-    expect(runner.exporter).to be_an_instance_of(Umami::Policyfile::Exporter)
     expect(runner.chef_zero_server).to be_an_instance_of(Umami::Server)
   end
 
   context 'with no options provided' do
     it 'sets proper defaults' do
       runner = Umami::Runner.new
-      expect(runner.config[:integration_tests]).to be true
+      expect(runner.umami_config[:integration_tests]).to be true
       expect(runner.policyfile).to eq("Policyfile.rb")
-      expect(runner.config[:test_root]).to eq("spec")
-      expect(runner.config[:unit_tests]).to be true
+      expect(runner.umami_config[:test_root]).to eq("spec")
+      expect(runner.umami_config[:unit_tests]).to be true
     end
   end
 
@@ -41,10 +40,10 @@ RSpec.describe Umami::Runner do
       my_argv.flatten!
       stub_const("ARGV", my_argv)
       runner = Umami::Runner.new
-      expect(runner.config[:integration_tests]).to be false
+      expect(runner.umami_config[:integration_tests]).to be false
       expect(runner.policyfile).to eq("test_policy.rb")
-      expect(runner.config[:test_root]).to eq("dust_spec")
-      expect(runner.config[:unit_tests]).to be false
+      expect(runner.umami_config[:test_root]).to eq("dust_spec")
+      expect(runner.umami_config[:unit_tests]).to be false
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-umami
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Ryan Frantz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-26 00:00:00.000000000 Z
+date: 2019-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '14'
 - !ruby/object:Gem::Dependency
   name: chef-dk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: '0.69'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: '0.69'
 description: A tool to generate unit/integration tests for Chef cookbooks and policy
   files.
 email:
@@ -76,8 +76,8 @@ files:
 - lib/chef-umami/logger.rb
 - lib/chef-umami/options.rb
 - lib/chef-umami/policyfile.rb
-- lib/chef-umami/policyfile/exporter.rb
-- lib/chef-umami/policyfile/uploader.rb
+- lib/chef-umami/policyfile/policyfile_lock.rb
+- lib/chef-umami/policyfile_services/push.rb
 - lib/chef-umami/runner.rb
 - lib/chef-umami/server.rb
 - lib/chef-umami/test.rb
@@ -107,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
 summary: A tool to generate unit/integration tests for Chef cookbooks and policy files.

data/lib/chef-umami/policyfile/exporter.rb

@@ -1,101 +0,0 @@
-#   Copyright 2017 Bloomberg Finance, L.P.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-require 'chef-dk/policyfile_services/install'
-require 'chef-dk/policyfile_services/export_repo'
-require 'chef-dk/ui'
-require 'tmpdir' # Extends Dir
-
-module Umami
-  class Policyfile
-    class Exporter
-      attr_reader   :chef_config_file
-      attr_reader   :cookbook_dir
-      attr_reader   :export_root
-      attr_reader   :export_path
-      attr_reader   :policyfile
-      attr_accessor :policyfile_lock_file
-
-      def initialize(policyfile_lock_file = nil, cookbook_dir = nil, policyfile = nil)
-        @policyfile = policyfile
-        @export_root = Dir.mktmpdir('umami-')
-        # We need the target dir named the same as the source dir so that `chef` commands
-        # work as happily programatically as they would via the command line.
-        # This is because the commands assume they're being run from within a cookbook
-        # directory.
-        @export_path = File.join(export_root, cookbook_dir)
-        @chef_config_file = "#{export_path}/.chef/config.rb"
-      end
-
-      def ui
-        @ui ||= ChefDK::UI.new
-      end
-
-      # Execute `chef install` to ensure we get a fresh, clean Policyfile lock
-      # file on each run.
-      def install_policy
-        puts "Generating a new Policyfile from '#{policyfile}'..."
-        install_service = ChefDK::PolicyfileServices::Install.new(
-          policyfile: policyfile,
-          ui: ui
-        )
-        @policyfile_lock_file = install_service.storage_config.policyfile_lock_filename
-        install_service.run
-      end
-
-      def fake_client_key
-        "#{export_path}/umami.pem"
-      end
-
-      def cp_fake_client_key
-        # Create a fake client cert based on a dummy cert we have laying around.
-        fake_client_key_src = File.join(File.dirname(__FILE__), %w(.. .. .. support umami.pem))
-        FileUtils.cp(fake_client_key_src, fake_client_key)
-      end
-
-      def update_chef_config
-        File.open(chef_config_file, 'a') do |f|
-          f.puts "chef_server_url 'http://127.0.0.1:8889'"
-          f.puts "cookbook_path ['#{export_path}/cookbook_artifacts']"
-          f.puts "client_key '#{fake_client_key}'"
-          f.puts "node_name 'umami-node'"
-        end
-      end
-
-      # Export the cookbook and prepare a chef-zero-compatible directory.
-      # We'll use this as a temporary launch pad for things, as needed, akin
-      # to test-kitchen's sandbox.
-      def export
-        install_policy
-        export_service = ChefDK::PolicyfileServices::ExportRepo.new(
-          policyfile: policyfile_lock_file,
-          export_dir: export_path
-        )
-        begin
-          export_service.run
-        rescue ChefDK::PolicyfileExportRepoError => e
-          puts "\nFAILED TO EXPORT POLICYFILE: #{e.message} (#{e.class})"
-          puts "CAUSE: #{e.cause}"
-          puts 'BACKTRACE:'
-          e.backtrace.each do |line|
-            puts "\t#{line}"
-          end
-          exit(1)
-        end
-        cp_fake_client_key
-        update_chef_config
-      end
-    end
-  end
-end