berkshelf 5.2.0 → 8.0.15

data/features/step_definitions/filesystem_steps.rb

@@ -1,269 +0,0 @@
-require 'aruba/api'
-
-World(Aruba::Api)
-World(Berkshelf::RSpec::ChefAPI)
-World(Berkshelf::RSpec::FileSystemMatchers)
-
-Given /^a cookbook named "(.*?)"$/ do |name|
-  create_directory(name)
-  write_file(File.join(name, "metadata.rb"), "name '#{name}'")
-end
-
-Given /^the cookbook "(.*?)" has the file "(.*?)" with:$/ do |cookbook_name, file_name, content|
-  write_file(::File.join(cookbook_name, file_name), content)
-end
-
-Given /^the cookbook store has the cookbooks:$/ do |cookbooks|
-  cookbooks.raw.each do |name, version, license|
-    generate_cookbook(cookbook_store.storage_path, name, version, license: license)
-  end
-end
-
-Given /^the cookbook store has the git cookbooks:$/ do |cookbooks|
-  cookbooks.raw.each do |name, version, sha|
-    folder   = "#{name}-#{sha}"
-    metadata = File.join(folder, 'metadata.rb')
-
-    create_directory(folder)
-    write_file(metadata, [
-      "name '#{name}'",
-      "version '#{version}'"
-    ].join("\n"))
-  end
-end
-
-Given /^the cookbook store contains a cookbook "(.*?)" "(.*?)" with dependencies:$/ do |name, version, dependencies|
-  generate_cookbook(cookbook_store.storage_path, name, version, dependencies: dependencies.raw)
-end
-
-Given(/^the cookbook store is empty$/) do
-  Berkshelf::CookbookStore.instance.clean!
-end
-
-Then /^the cookbook store should have the cookbooks:$/ do |cookbooks|
-  cookbooks.raw.each do |name, version|
-    expect(cookbook_store.storage_path).to have_structure {
-      directory "#{name}-#{version}" do
-        file "metadata.rb" do
-          contains version
-        end
-      end
-    }
-  end
-end
-
-Then /^the cookbook store should have the git cookbooks:$/ do |cookbooks|
-  cookbooks.raw.each do |name, version, sha1|
-    expect(cookbook_store.storage_path).to have_structure {
-      directory "#{name}-#{sha1}" do
-        file "metadata.rb" do
-          contains version
-        end
-      end
-    }
-  end
-end
-
-Then /^the cookbook store should not have the cookbooks:$/ do |cookbooks|
-  cookbooks.raw.each do |name, version|
-    expect(cookbook_store.storage_path).to_not have_structure {
-      directory "#{name}-#{version}"
-    }
-  end
-end
-
-Then /^I should have a new cookbook skeleton "(.*?)"$/ do |name|
-  cb_path = Pathname.new(current_dir).join(name)
-  expect(cb_path).to have_structure {
-    directory "attributes"
-    directory "files" do
-      directory "default"
-    end
-    directory "libraries"
-    directory "providers"
-    directory "recipes" do
-      file "default.rb"
-    end
-    directory "resources"
-    directory "templates" do
-      directory "default"
-    end
-    file ".gitignore"
-    file "chefignore"
-    file "Berksfile" do
-      contains "metadata"
-    end
-    file "Gemfile"
-    file "metadata.rb"
-    file "README.md"
-    file "Vagrantfile" do
-      contains "recipe[#{name}::default]"
-    end
-  }
-end
-
-Then /^I should have a new cookbook skeleton "(.*?)" with Chef-Minitest support$/ do |name|
-  steps %Q{ Then I should have a new cookbook skeleton "#{name}" }
-
-  cb_path = Pathname.new(current_dir).join(name)
-  expect(cb_path).to have_structure {
-    file "Berksfile" do
-      contains "cookbook 'minitest-handler'"
-    end
-    file "Vagrantfile" do
-      contains "recipe[minitest-handler::default]"
-    end
-    directory "files" do
-      directory "default" do
-        directory "tests" do
-          directory "minitest" do
-            file "default_test.rb" do
-              contains "describe '#{name}::default' do"
-              contains "include Helpers::#{name.capitalize}"
-            end
-            directory "support" do
-              file "helpers.rb" do
-                contains "module #{name.capitalize}"
-              end
-            end
-          end
-        end
-      end
-    end
-  }
-end
-
-
-Then /^I should have a new cookbook skeleton "(.*?)" with Foodcritic support$/ do |name|
-  steps %Q{ Then I should have a new cookbook skeleton "#{name}" }
-
-  cb_path = Pathname.new(current_dir).join(name)
-  expect(cb_path).to have_structure {
-    file "Gemfile" do
-      contains "gem 'thor-foodcritic'"
-    end
-    file "Thorfile" do
-      contains "require 'thor/foodcritic'"
-    end
-  }
-end
-
-Then /^I should have a new cookbook skeleton "(.*?)" with SCMVersion support$/ do |name|
-  steps %Q{ Then I should have a new cookbook skeleton "#{name}" }
-
-  cb_path = Pathname.new(current_dir).join(name)
-  expect(cb_path).to have_structure {
-    file "Gemfile" do
-      contains "gem 'thor-scmversion'"
-    end
-    file "Thorfile" do
-      contains "require 'thor/scmversion'"
-    end
-  }
-end
-
-Then /^I should have a new cookbook skeleton "(.*?)" with no Bundler support$/ do |name|
-  cb_path = Pathname.new(current_dir).join(name)
-  expect(cb_path).to have_structure {
-    directory "attributes"
-    directory "files" do
-      directory "default"
-    end
-    directory "libraries"
-    directory "providers"
-    directory "recipes" do
-      file "default.rb"
-    end
-    directory "resources"
-    directory "templates" do
-      directory "default"
-    end
-    file "README.md"
-    file "metadata.rb"
-    file "Berksfile" do
-      contains "metadata"
-    end
-    file "chefignore"
-    file "Berksfile"
-    no_file "Gemfile"
-  }
-end
-
-Then /^I should have a new cookbook skeleton "(.*?)" with no Git support$/ do |name|
-  expect(Pathname.new(current_dir).join(name)).to have_structure {
-    no_file ".gitignore"
-  }
-end
-
-Then /^I should have a new cookbook skeleton "(.*?)" with no Vagrant support$/ do |name|
-  expect(Pathname.new(current_dir).join(name)).to have_structure {
-    file "Gemfile" do
-      does_not_contain "gem 'vagrant'"
-    end
-    no_file "Vagrantfile"
-  }
-end
-
-Then(/^I should have a new cookbook skeleton "(.*?)" with no Test Kitchen support$/) do |name|
-  expect(Pathname.new(current_dir).join(name)).to have_structure {
-    file "Gemfile" do
-      does_not_contain "gem 'test-kitchen'"
-    end
-    no_file ".kitchen.yml"
-    no_file ".kitchen.yml.local"
-  }
-end
-
-Then /^the cookbook "(.*?)" should have the following files:$/ do |name, files|
-  check_file_presence(files.raw.map{|file_row| ::File.join(name, file_row[0])}, true)
-end
-
-Then /^the cookbook "(.*?)" should not have the following files:$/ do |name, files|
-  check_file_presence(files.raw.map{|file_row| ::File.join(name, file_row[0])}, false)
-end
-
-Then /^the git cookbook "(.*?)" should not have the following directories:$/ do |name, directories|
-  check_directory_presence(directories.raw.map{|directory_row| ::File.join(cookbook_store.storage_path.to_path, name, directory_row[0])}, false)
-end
-
-Then /^the file "(.*?)" in the cookbook "(.*?)" should contain:$/ do |file_name, cookbook_name, content|
-  expect(Pathname.new(current_dir).join(cookbook_name)).to have_structure {
-    file "Berksfile" do
-      contains content
-    end
-    file "chefignore"
-  }
-end
-
-Then /^the resulting "(.+)" Vagrantfile should contain:$/ do |cookbook_name, content|
-  expect(Pathname.new(current_dir).join(cookbook_name)).to have_structure {
-    file "Vagrantfile" do
-      content.respond_to?(:raw) ?
-        content.raw.flatten.each { |string| contains string } :
-        contains(content)
-    end
-  }
-end
-
-Then /^the directory "(.*?)" should have the following files:$/ do |name, files|
-  check_file_presence(files.raw.map{|file_row| ::File.join(name, file_row[0])}, true)
-end
-
-Then /^the directory "(.*?)" should not have the following files:$/ do |name, files|
-  check_file_presence(files.raw.map{|file_row| ::File.join(name, file_row[0])}, false)
-end
-
-Then /^the file "(.*?)" in the directory "(.*?)" should not contain:$/ do |file_name, directory_name, content|
-  Pathname.new(current_dir).join(directory_name).should_not have_structure {
-    file "Berksfile" do
-      contains content
-    end
-  }
-end
-
-Then(/^the directory "(.*?)" should contain version "(.*?)" of the "(.*?)" cookbook$/) do |path, version, name|
-  cookbook_path = File.join(current_dir, path)
-  cookbook = Berkshelf::CachedCookbook.from_path(cookbook_path)
-  expect(cookbook.version).to eq(version)
-  expect(cookbook.cookbook_name).to eq(name)
-end

data/features/step_definitions/gem_steps.rb

@@ -1,13 +0,0 @@
-Given /^the gem "(.*)" is not installed$/ do |gem_name|
-  allow(Gem::Specification).to receive(:find_by_name)
-    .with(gem_name)
-    .and_raise(Gem::LoadError)
-end
-
-Then /^the output should contain a warning to suggest supporting the option "(.*?)" by installing "(.*?)"$/ do |option, gem_name|
-  step "the output should contain \"This cookbook was generated with --#{option}, however, #{gem_name} is not installed.\nTo make use of --#{option}: gem install #{gem_name}\""
-end
-
-Then /^the output should contain a warning to suggest supporting the default for "(.*?)" by installing "(.*?)"$/ do |option, gem_name|
-  step "the output should contain \"By default, this cookbook was generated to support #{gem_name}, however, #{gem_name} is not installed.\nTo skip support for #{gem_name}, use --no-#{option}\"\nTo install #{gem_name}: gem install #{gem_name}"
-end

data/features/step_definitions/json_steps.rb

@@ -1,23 +0,0 @@
-class Hash
-  def sort_by_key(&block)
-    self.keys.sort(&block).reduce({}) do |seed, key|
-      seed[key] = self[key]
-      if seed[key].is_a?(Hash)
-        seed[key] = seed[key].sort_by_key(&block)
-      elsif seed[key].is_a?(Array)
-        seed[key] = seed[key].map do |i|
-          i.respond_to?(:sort_by_key) ? i.sort_by_key(&block) : i
-        end
-      end
-      seed
-    end
-  end
-end
-
-Then /^the output should contain JSON:$/ do |data|
-  parsed = ERB.new(data).result
-  target = JSON.pretty_generate(JSON.parse(parsed).sort_by_key)
-  actual = JSON.pretty_generate(JSON.parse(all_commands.map { |c| c.output }.join("\n")).sort_by_key)
-
-  expect(actual).to eq(target)
-end

data/features/step_definitions/utility_steps.rb

@@ -1,11 +0,0 @@
-Given /^skip\s+"([^\"]+)"$/ do |msg|
-  skip
-end
-
-Then /the output from \`(.+)\` should be the same as \`(.+)\`/ do |actual, expected|
-  run(actual)
-  actual_output = last_command_started.stdout
-  run(expected)
-  expected_output = last_command_started.stdout
-  expect(actual_output).to eql(expected_output)
-end

data/features/support/aruba.rb

@@ -1,12 +0,0 @@
-module Aruba
-  # Force Aruba to behave like the SpawnProcess Aruba class.
-  class InProcess
-    def stdin
-      @stdin
-    end
-
-    def output
-      stdout + stderr
-    end
-  end
-end

data/features/support/env.rb

@@ -1,82 +0,0 @@
-require 'spork'
-
-def windows?
-  !!(RUBY_PLATFORM =~ /mswin|mingw|windows/)
-end
-
-Spork.prefork do
-  require 'aruba/cucumber'
-  require 'aruba/in_process'
-  require 'aruba/spawn_process'
-  require 'cucumber/rspec/doubles'
-  require 'berkshelf/api/rspec' unless windows?
-  require 'berkshelf/api/cucumber' unless windows?
-
-  Dir['spec/support/**/*.rb'].each { |f| require File.expand_path(f) }
-
-  World(Berkshelf::RSpec::PathHelpers)
-  World(Berkshelf::RSpec::Kitchen)
-
-  CHEF_SERVER_PORT = 26310
-  BERKS_API_PORT   = 26210
-
-  at_exit do
-    Berkshelf::RSpec::ChefServer.stop
-    Berkshelf::API::RSpec::Server.stop unless windows?
-  end
-
-  Before do
-
-    # Legacy ENV variables until we can move over to all InProcess
-    Berkshelf.instance_variable_set(:@berkshelf_path, nil)
-    ENV['BERKSHELF_PATH'] = berkshelf_path.to_s
-    ENV['BERKSHELF_CONFIG'] = Berkshelf.config.path.to_s
-    ENV['BERKSHELF_CHEF_CONFIG'] = chef_config_path.to_s
-
-    aruba.config.command_launcher = :in_process
-    aruba.config.main_class = Berkshelf::Cli::Runner
-    @dirs                       = ["spec/tmp/aruba"] # set aruba's temporary directory
-
-    stub_kitchen!
-    clean_tmp_path
-    Berkshelf.initialize_filesystem
-    Berkshelf::CookbookStore.instance.initialize_filesystem
-    reload_configs
-    Berkshelf::CachedCookbook.instance_variable_set(:@loaded_cookbooks, nil)
-
-    endpoints = [
-      {
-        type: "chef_server",
-        options: {
-          url: "http://localhost:#{CHEF_SERVER_PORT}",
-          client_name: "reset",
-          client_key: File.expand_path("spec/config/berkshelf.pem")
-        }
-      }
-    ]
-
-    Berkshelf::RSpec::ChefServer.start(port: CHEF_SERVER_PORT)
-    Berkshelf::API::RSpec::Server.start(port: BERKS_API_PORT, endpoints: endpoints) unless windows?
-
-    aruba.config.io_wait_timeout = Cucumber::JRUBY ? 7 : 5
-    @aruba_timeout_seconds = Cucumber::JRUBY ? 35 : 15
-  end
-
-  Before('@spawn') do
-    aruba.config.command_launcher = :spawn
-
-    Berkshelf.instance_variable_set(:@berkshelf_path, nil)
-    set_environment_variable('BERKSHELF_PATH', berkshelf_path.to_s)
-    set_environment_variable('BERKSHELF_CONFIG', Berkshelf.config.path.to_s)
-    set_environment_variable('BERKSHELF_CHEF_CONFIG', chef_config_path.to_s)
-  end
-
-  Before('@slow_process') do
-    aruba.config.io_wait_timeout = Cucumber::JRUBY ? 70 : 30
-    @aruba_timeout_seconds = Cucumber::JRUBY ? 140 : 60
-  end
-end
-
-Spork.each_run do
-  require 'berkshelf/cli'
-end

data/generator_files/Berksfile.erb

@@ -1,11 +0,0 @@
-source "https://supermarket.chef.io"
-<% if options[:chef_minitest] -%>
-
-group :integration do
-  cookbook 'minitest-handler'
-end
-<% end -%>
-<% if options[:metadata_entry] -%>
-
-metadata
-<% end -%>

data/generator_files/CHANGELOG.md.erb

@@ -1,3 +0,0 @@
-# 0.1.0
-
-Initial release of <%= name %>

data/generator_files/Gemfile.erb

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-<% if options[:foodcritic] -%>
-gem 'thor-foodcritic'
-<% end -%>
-<% if options[:scmversion] -%>
-gem 'thor-scmversion'
-<% end -%>

data/generator_files/README.md.erb

@@ -1,42 +0,0 @@
-# <%= name %>-cookbook
-
-TODO: Enter the cookbook description here.
-
-## Supported Platforms
-
-TODO: List your supported platforms.
-
-## Attributes
-
-<table>
-  <tr>
-    <th>Key</th>
-    <th>Type</th>
-    <th>Description</th>
-    <th>Default</th>
-  </tr>
-  <tr>
-    <td><tt>['<%= name %>']['bacon']</tt></td>
-    <td>Boolean</td>
-    <td>whether to include bacon</td>
-    <td><tt>true</tt></td>
-  </tr>
-</table>
-
-## Usage
-
-### <%= name %>::default
-
-Include `<%= name %>` in your node's `run_list`:
-
-```json
-{
-  "run_list": [
-    "recipe[<%= name %>::default]"
-  ]
-}
-```
-
-## License and Authors
-
-Author:: <%= maintainer %> (<<%= maintainer_email %>>)

data/generator_files/Thorfile.erb

@@ -1,11 +0,0 @@
-# encoding: utf-8
-
-require 'bundler'
-require 'bundler/setup'
-<% if options[:foodcritic] -%>
-require 'thor/foodcritic'
-<% end -%>
-<% if options[:scmversion] -%>
-require 'thor/scmversion'
-<% end -%>
-require 'berkshelf/thor'

data/generator_files/Vagrantfile.erb

@@ -1,117 +0,0 @@
-# -*- mode: ruby -*-
-# vi: set ft=ruby :
-
-# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
-VAGRANTFILE_API_VERSION = '2'
-
-Vagrant.require_version '>= 1.5.0'
-
-Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
-  # All Vagrant configuration is done here. The most common configuration
-  # options are documented and commented below. For a complete reference,
-  # please see the online documentation at vagrantup.com.
-
-  config.vm.hostname = '<%= "#{cookbook_name.gsub('_','-')}-berkshelf" %>'
-
-  # Set the version of chef to install using the vagrant-omnibus plugin
-  # NOTE: You will need to install the vagrant-omnibus plugin:
-  #
-  #   $ vagrant plugin install vagrant-omnibus
-  #
-  if Vagrant.has_plugin?("vagrant-omnibus")
-    config.omnibus.chef_version = '<%= berkshelf_config.vagrant.omnibus.version %>'
-  end
-
-  # Every Vagrant virtual environment requires a box to build off of.
-  # If this value is a shorthand to a box in Vagrant Cloud then
-  # config.vm.box_url doesn't need to be specified.
-  config.vm.box = '<%= berkshelf_config.vagrant.vm.box %>'
-
-<% unless berkshelf_config.vagrant.vm.box_url.nil? -%>
-  # The url from where the 'config.vm.box' box will be fetched if it
-  # is not a Vagrant Cloud box and if it doesn't already exist on the
-  # user's system.
-  config.vm.box_url = '<%= berkshelf_config.vagrant.vm.box_url %>'
-<% end -%>
-
-  # Assign this VM to a host-only network IP, allowing you to access it
-  # via the IP. Host-only networks can talk to the host machine as well as
-  # any other machines on the same network, but cannot be accessed (through this
-  # network interface) by any external networks.
-  config.vm.network :private_network, type: 'dhcp'
-
-  # Create a forwarded port mapping which allows access to a specific port
-  # within the machine from a port on the host machine. In the example below,
-  # accessing "localhost:8080" will access port 80 on the guest machine.
-<% berkshelf_config.vagrant.vm.forward_port.each do |guest, host| %>
-  config.vm.network :forwarded_port, guest: <%= guest %>, host: <%= host %>
-<% end -%>
-
-  # Share an additional folder to the guest VM. The first argument is
-  # the path on the host to the actual folder. The second argument is
-  # the path on the guest to mount the folder. And the optional third
-  # argument is a set of non-required options.
-  # config.vm.synced_folder "../data", "/vagrant_data"
-
-  # Provider-specific configuration so you can fine-tune various
-  # backing providers for Vagrant. These expose provider-specific options.
-  # Example for VirtualBox:
-  #
-  # config.vm.provider :virtualbox do |vb|
-  #   # Don't boot with headless mode
-  #   vb.gui = true
-  #
-  #   # Use VBoxManage to customize the VM. For example to change memory:
-  #   vb.customize ["modifyvm", :id, "--memory", "1024"]
-  # end
-  #
-  # View the documentation for the provider you're using for more
-  # information on available options.
-
-  # The path to the Berksfile to use with Vagrant Berkshelf
-  # config.berkshelf.berksfile_path = "./Berksfile"
-
-  # Enabling the Berkshelf plugin. To enable this globally, add this configuration
-  # option to your ~/.vagrant.d/Vagrantfile file
-  config.berkshelf.enabled = true
-
-  # An array of symbols representing groups of cookbook described in the Vagrantfile
-  # to exclusively install and copy to Vagrant's shelf.
-  # config.berkshelf.only = []
-
-  # An array of symbols representing groups of cookbook described in the Vagrantfile
-  # to skip installing and copying to Vagrant's shelf.
-  # config.berkshelf.except = []
-
-<% if berkshelf_config.vagrant.vm.provision == 'chef_client' -%>
-  config.vm.provision :chef_client do |chef|
-    chef.chef_server_url        = '<%= berkshelf_config.chef.chef_server_url %>'
-    chef.validation_client_name = '<%= berkshelf_config.chef.validation_client_name %>'
-    chef.validation_key_path    = '<%= berkshelf_config.chef.validation_key_path %>'
-
-    chef.run_list = [
-<% if options[:chef_minitest] %>
-      'recipe[minitest-handler::default]',
-<% end -%>
-      'recipe[<%= cookbook_name %>::default]'
-    ]
-  end
-<% elsif berkshelf_config.vagrant.vm.provision == 'chef_solo' -%>
-  config.vm.provision :chef_solo do |chef|
-    chef.json = {
-      mysql: {
-        server_root_password: 'rootpass',
-        server_debian_password: 'debpass',
-        server_repl_password: 'replpass'
-      }
-    }
-
-    chef.run_list = [
-<% if options[:chef_minitest] %>
-      'recipe[minitest-handler::default]',
-<% end -%>
-      'recipe[<%= cookbook_name %>::default]'
-    ]
-  end
-<% end -%>
-end