berkshelf 7.0.7 → 7.2.0

data/features/step_definitions/berksfile_steps.rb

@@ -1,54 +0,0 @@
-Given /I have a Berksfile pointing at the community API endpoint with:/ do |content|
-  steps %Q{
-    Given a file named "Berksfile" with:
-      """
-      source '#{Berkshelf::Berksfile::DEFAULT_API_URL}'
-
-      #{content}
-      """
-  }
-end
-
-Given /^I have a Berksfile pointing at the local Berkshelf API$/ do
-  steps %Q{
-    Given I have a Berksfile pointing at the local Berkshelf API with:
-      """
-      """
-  }
-end
-
-Given /^I have a Berksfile pointing at the local Berkshelf API with:$/ do |content|
-  steps %Q{
-    Given I have a Berksfile at "." pointing at the local Berkshelf API with:
-      """
-      #{content}
-      """
-  }
-end
-
-Given /^I have a Berksfile at "(.+)" pointing at the local Berkshelf API with:$/ do |path, content|
-  steps %Q{
-    Given a directory named "#{path}"
-    And a file named "#{path}/Berksfile" with:
-      """
-      source 'http://127.0.0.1:#{BERKS_API_PORT}'
-
-      #{content}
-      """
-  }
-end
-
-Given /I have a Berksfile pointing at an( authenticated)? Artifactory server with:/ do |authenticated, content|
-  if ENV["TEST_BERKSHELF_ARTIFACTORY"]
-    steps %Q{
-      Given a file named "Berksfile" with:
-        """
-        source artifactory: '#{ENV['TEST_BERKSHELF_ARTIFACTORY']}'#{authenticated ? ", api_key: '#{ENV['TEST_BERKSHELF_ARTIFACTORY_API_KEY']}'" : ''}
-
-        #{content}
-        """
-    }
-  else
-    skip_this_scenario
-  end
-end

data/features/step_definitions/chef/config_steps.rb

@@ -1,12 +0,0 @@
-Given(/^I do not have a Berkshelf config$/) do
-  FileUtils.rm_f(ENV["BERKSHELF_CONFIG"])
-end
-
-Given /^I do not have a Chef config$/ do
-  path = tmp_path.join("knife.rb").to_s
-  Berkshelf.chef_config = Ridley::Chef::Config.new(path)
-  Berkshelf.chef_config.save
-
-  ENV["BERKSHELF_CHEF_CONFIG"] = path
-  set_environment_variable "BERKSHELF_CHEF_CONFIG", path
-end

data/features/step_definitions/chef_server_steps.rb

@@ -1,60 +0,0 @@
-World(Berkshelf::RSpec::ChefServer)
-
-Given(/^the Chef Server is empty$/) do
-  Berkshelf::RSpec::ChefServer.reset!
-end
-
-Given /^the Chef Server has cookbooks:$/ do |cookbooks|
-  cookbooks.raw.each do |name, version, dependencies|
-    metadata = []
-    metadata << "name '#{name}'"
-    metadata << "version '#{version}'"
-    dependencies.to_s.split(",").map { |d| d.split(" ", 2) }.each do |(dep_name, constraint)|
-      metadata << "depends '#{dep_name}', '#{constraint}'"
-    end
-
-    chef_cookbook(name, { "metadata.rb" => metadata.join("\n") })
-  end
-end
-
-Given /^the Chef Server has frozen cookbooks:$/ do |cookbooks|
-  cookbooks.raw.each do |name, version|
-    chef_cookbook(name, { "metadata.rb" => "version '#{version}'", frozen: true })
-  end
-end
-
-Given(/^the Chef Server has an environment named "(.*?)"$/) do |name|
-  chef_environment(name, { "description" => "This is an environment" })
-end
-
-Given(/^the Chef Server does not have an environment named "(.*?)"$/) do |name|
-  if chef_server.data_store.exists?(["organizations", "chef", "environments", name])
-    chef_server.data_store.delete(["organizations", "chef", "environments", name])
-  end
-end
-
-Then /^the Chef Server should have the cookbooks:$/ do |cookbooks|
-  list = chef_cookbooks
-  cookbooks.raw.each do |name, version|
-    expect(list.keys).to  include(name)
-    expect(list[name]).to include(version) unless version.nil?
-  end
-end
-
-Then /^the Chef Server should not have the cookbooks:$/ do |cookbooks|
-  list = chef_cookbooks
-  cookbooks.raw.each do |name, version|
-    unless version.nil?
-      expect(list.keys).to_not include(name)
-    else
-      expect(list[name] || []).to_not include(version)
-    end
-  end
-end
-
-Then(/^the version locks in the "(.*?)" environment should be:$/) do |name, locks|
-  list = chef_environment_locks(name)
-  locks.raw.each do |cookbook, version|
-    expect(list[cookbook]).to eq(version)
-  end
-end

data/features/step_definitions/cli_steps.rb

@@ -1,18 +0,0 @@
-Then /^the exit status should be "(.+)"$/ do |name|
-  error = name.split("::").reduce(Berkshelf) { |klass, id| klass.const_get(id) }
-  expect(last_command_started).to have_exit_status(error.status_code)
-end
-
-Then /^the results should have the cookbooks:$/ do |cookbooks|
-  list = last_command_started.stdout
-  cookbooks.split("\n").each do |cookbook|
-    expect(list).to include(cookbook)
-  end
-end
-
-Then /^the results should each start with "(.+)"$/ do |prefix|
-  list = last_command_started.stdout
-  list.split("\n").each do |cookbook|
-    expect(cookbook).to start_with(prefix)
-  end
-end

data/features/step_definitions/config_steps.rb

@@ -1,46 +0,0 @@
-require "tempfile"
-
-Given /^I already have a Berkshelf config file$/ do
-  path   = Tempfile.new("berkshelf").path
-  config = Berkshelf::Config.new(path)
-  config.save
-
-  Berkshelf.config = config
-
-  ENV["BERKSHELF_CONFIG"] = path
-  set_environment_variable "BERKSHELF_CONFIG", path
-end
-
-Given /^I have a Berkshelf config file containing:$/ do |contents|
-  path = Berkshelf.config.path
-  FileUtils.mkdir_p(Pathname.new(path).dirname.to_s)
-
-  File.open(path, "w+") { |f| f.write(contents) }
-
-  Berkshelf.config = Berkshelf::Config.from_file(path)
-end
-
-Then /^a Berkshelf config file should exist and contain:$/ do |table|
-  # Have to reload the config...
-  Berkshelf.config.reload
-
-  check_file_presence([Berkshelf.config.path], true)
-
-  table.raw.each do |key, value|
-    if value == "BOOLEAN[true]"
-      value = true
-    end
-    expect(Berkshelf.config[key]).to eq(value)
-  end
-end
-
-Then /^a Berkshelf config file should exist at "(.+)" and contain:$/ do |path, table|
-  check_file_presence([path], true)
-
-  path             = File.join(@dirs.first, path)
-  Berkshelf.config = Berkshelf::Config.from_file(path)
-
-  table.raw.each do |key, value|
-    expect(Berkshelf.config[key]).to eq(value)
-  end
-end

data/features/step_definitions/environment_steps.rb

@@ -1,11 +0,0 @@
-Given /^the environment variable (.+) is nil$/ do |variable|
-  set_environment_variable(variable, nil)
-end
-
-Given /^the environment variable (.+) is "(.+)"$/ do |variable, value|
-  set_environment_variable(variable, value)
-end
-
-Given /^the environment variable (.+) is \$TEST_BERKSHELF_ARTIFACTORY_API_KEY$/ do |variable|
-  set_environment_variable(variable, ENV["TEST_BERKSHELF_ARTIFACTORY_API_KEY"])
-end

data/features/step_definitions/filesystem_steps.rb

@@ -1,286 +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 cookbook "(.*?)" "(.*?)" is vendored without a metadata.rb$/) do |name, version|
-  cookbook_path = File.join(cookbook_store.storage_path, "#{name}-#{version}")
-  cookbook = Berkshelf::CachedCookbook.from_path(cookbook_path)
-  cookbook.compile_metadata()
-  metadata_file = File.join(cookbook_path, "metadata.rb")
-  File.unlink(metadata_file) if File.file?(metadata_file)
-end
-
-Given(/^the cookbook store cookbook "(.*?)" "(.*?)" is vendored with a metadata.rb$/) do |name, version|
-  cookbook_path = File.join(cookbook_store.storage_path, "#{name}-#{version}")
-  cookbook = Berkshelf::CachedCookbook.from_path(cookbook_path)
-  cookbook.compile_metadata()
-  metadata_file = File.join(cookbook_path, "metadata.rb")
-  raise "internal error, fixture cookbook should have a metadata.rb" unless File.file?(metadata_file)
-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,json}" 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,json}" 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
-      if content.respond_to?(:raw)
-        content.raw.flatten.each { |string| contains string }
-      else
-        contains(content)
-      end
-    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