berkshelf 3.0.0.beta2 → 3.0.0.beta3

data/features/resolver.feature

@@ -0,0 +1,28 @@
+Feature: Berkshelf resolver
+  Background:
+    * the Berkshelf API server's cache is empty
+    * the Chef Server has cookbooks:
+      | berkshelf | 1.0.0 |
+      | berkshelf | 2.0.0 |
+    * the Berkshelf API server's cache is up to date
+    * I have a Berksfile pointing at the local Berkshelf API with:
+      """
+      cookbook 'berkshelf'
+      """
+
+  Scenario: with DEBUG_RESOLVER=1
+    Given the environment variable DEBUG_RESOLVER is "1"
+    When I successfully run `berks install`
+    Then the output should contain:
+      """
+      Attempting to find a solution
+      Adding constraint berkshelf >= 0.0.0 from root
+      """
+
+  Scenario: without DEBUG_RESOLVER
+    Given the environment variable DEBUG_RESOLVER is nil
+    When I successfully run `berks install`
+    Then the output should not contain:
+      """
+      Attempting to find a solution
+      """

data/features/step_definitions/berksfile_steps.rb

@@ -0,0 +1,39 @@
+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://0.0.0.0:#{BERKS_API_PORT}'
+
+      #{content}
+      """
+  }
+end

data/features/step_definitions/chef/config_steps.rb

@@ -3,7 +3,7 @@ Given(/^I do not have a Berkshelf config$/) do
 end
 
 Given /^I do not have a Chef config$/ do
-	path = tmp_path.join('knife.rb').to_s
+  path = tmp_path.join('knife.rb').to_s
   Berkshelf.chef_config = Ridley::Chef::Config.new(path)
   Berkshelf.chef_config.save
 

data/features/step_definitions/chef_server_steps.rb

@@ -1,4 +1,4 @@
-World(Berkshelf::RSpec::ChefAPI)
+World(Berkshelf::RSpec::ChefServer)
 
 Given(/^the Chef Server is empty$/) do
   Berkshelf::RSpec::ChefServer.reset!
@@ -6,48 +6,48 @@ end
 
 Given /^the Chef Server has cookbooks:$/ do |cookbooks|
   cookbooks.raw.each do |name, version|
-    purge_cookbook(name, version)
-    cb_path = generate_cookbook(tmp_path, name, version)
-    upload_cookbook(cb_path, freeze: false, force: true)
+    chef_cookbook(name, { 'metadata.rb' => "version '#{version}'" })
   end
 end
 
 Given /^the Chef Server has frozen cookbooks:$/ do |cookbooks|
   cookbooks.raw.each do |name, version|
-    purge_cookbook(name, version)
-    cb_path = generate_cookbook(tmp_path, name, version)
-    upload_cookbook(cb_path, freeze: true, force: true)
+    chef_cookbook(name, { 'metadata.rb' => "version '#{version}'", frozen: true })
   end
- end
+end
 
-Then /^the Chef Server should have the cookbooks:$/ do |cookbooks|
-  cookbooks.raw.each do |name, version|
-    expect(server_has_cookbook?(name, version)).to be_true
-  end
+Given(/^the Chef Server has an environment named "(.*?)"$/) do |name|
+  chef_environment(name, { 'description' => 'This is an environment' })
 end
 
-Then /^the Chef Server should not have the cookbooks:$/ do |cookbooks|
-  cookbooks.raw.each do |name, version|
-    expect(server_has_cookbook?(name, version)).to be_false
+Given(/^the Chef Server does not have an environment named "(.*?)"$/) do |name|
+  if chef_server.data_store.exists?(['environments', name])
+    chef_server.data_store.delete(['environments', name])
   end
 end
 
-Then(/^the version locks in the "(.*?)" environment should be:$/) do |environment_name, version_locks|
-  environment_cookbook_versions = environment(environment_name).cookbook_versions
-  version_locks.hashes.each do |hash|
-    expect(environment_cookbook_versions[hash['cookbook']]).to eq(hash['version_lock'])
+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
 
-Given(/^The Chef Server has an environment named "(.*?)"$/) do |environment_name|
-  delete_environment(environment_name)
-  begin
-    create_environment(environment_name)
-  rescue Ridley::Errors::HTTPConflict; 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
 
-Given(/^The Chef Server does not have an environment named "(.*?)"$/) do |environment_name|
-  if environment_exists?(environment_name)
-    delete_environment(environment_name)
+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/config_steps.rb

@@ -27,6 +27,9 @@ Then /^a Berkshelf config file should exist and contain:$/ do |table|
   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

data/features/step_definitions/filesystem_steps.rb

@@ -208,6 +208,16 @@ Then /^I should have a new cookbook skeleton "(.*?)" with no Vagrant support$/ d
   }
 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

data/features/step_definitions/json_steps.rb

@@ -14,13 +14,6 @@ class Hash
   end
 end
 
-Then /^the file "(.*?)" should contain JSON:$/ do |file, data|
-  target = JSON.pretty_generate(JSON.parse(data).sort_by_key)
-  actual = JSON.pretty_generate(JSON.parse(File.read(File.join(current_dir, file))).sort_by_key)
-
-  expect(actual).to eq(target)
-end
-
 Then /^the output should contain JSON:$/ do |data|
   target = JSON.pretty_generate(JSON.parse(data).sort_by_key)
   actual = JSON.pretty_generate(JSON.parse(all_output).sort_by_key)

data/features/step_definitions/lockfile_steps.rb

@@ -2,3 +2,56 @@ Then(/^the output should warn about the old lockfile format$/) do
   message = Berkshelf::Lockfile.class_eval('LockfileLegacy.send(:warning_message)')
   expect(all_output).to include(message)
 end
+
+Given /^the Lockfile has:$/ do |table|
+  result = { 'dependencies' => {} }
+
+  table.raw.each do |name, locked_or_path, ref, rel|
+    result['dependencies'][name] = {}
+
+    if locked_or_path =~ /(\d+\.){2}\d/
+      result['dependencies'][name]['locked_version'] = locked_or_path
+    else
+      result['dependencies'][name]['path'] = locked_or_path
+    end
+
+    unless ref.nil?
+      result['dependencies'][name]['rel'] = ref
+    end
+
+    unless rel.nil?
+      result['dependencies'][name]['rel'] = rel
+    end
+  end
+
+  File.open(File.join(current_dir, 'Berksfile.lock'), 'w') do |file|
+    file.write(JSON.pretty_generate(result) + "\n")
+  end
+end
+
+Then /^the Lockfile should have:$/ do |table|
+  hash = JSON.parse(File.read(File.join(current_dir, 'Berksfile.lock')))
+  dependencies = hash['dependencies']
+
+  table.raw.each do |name, locked_or_path, ref, rel|
+    expect(dependencies).to have_key(name)
+
+    if locked_or_path =~ /(\d+\.){2}\d/
+      expect(dependencies[name]).to have_key('locked_version')
+      expect(dependencies[name]['locked_version']).to eq(locked_or_path)
+    else
+      expect(dependencies[name]).to have_key('path')
+      expect(dependencies[name]['path']).to eq(locked_or_path)
+    end
+
+    unless ref.nil?
+      expect(dependencies[name]).to have_key('ref')
+      expect(dependencies[name]['ref']).to eq(ref)
+    end
+
+    unless rel.nil?
+      expect(dependencies[name]).to have_key('rel')
+      expect(dependencies[name]['rel']).to eq(rel)
+    end
+  end
+end

data/features/step_definitions/utility_steps.rb

@@ -2,8 +2,8 @@ Given /^pending\s+"([^\"]+)"$/ do |msg|
   pending
 end
 
-Then /^the output should be the same as \`(.+)\`$/ do |command|
-  run_simple(command)
-  output = output_from(command)
-  expect(all_output).to include(output)
+Then /the output from \`(.+)\` should be the same as \`(.+)\`/ do |actual, expected|
+  run_simple(actual)
+  run_simple(expected)
+  expect(output_from(actual)).to eq(output_from(expected))
 end

data/features/support/env.rb

@@ -36,6 +36,7 @@ Spork.prefork do
     Berkshelf.initialize_filesystem
     Berkshelf::CookbookStore.instance.initialize_filesystem
     reload_configs
+    Berkshelf::CachedCookbook.instance_variable_set(:@loaded_cookbooks, nil)
 
     endpoints = [
       {

data/generator_files/Berksfile.erb

@@ -1,4 +1,4 @@
-source "http://api.berkshelf.com"
+source "https://api.berkshelf.com"
 <% if options[:chef_minitest] -%>
 
 group :integration do

data/generator_files/README.md.erb

@@ -1,13 +1,69 @@
-# <%= name %> cookbook
+<%= name %> cookbook
+<%= '='*"#{name} cookbook".length %>
+TODO: Enter the cookbook description here.
 
-# Requirements
+e.g.
+This cookbook makes your favorite breakfast sandwich.
 
-# Usage
+Requirements
+------------
+TODO: List your cookbook requirements. Be sure to include any requirements this cookbook has on platforms, libraries, other cookbooks, packages, operating systems, etc.
 
-# Attributes
+e.g.
+#### packages
+- `toaster` - <%= name %> needs toaster to brown your bagel.
 
-# Recipes
+Attributes
+----------
+TODO: List you cookbook attributes here.
 
-# Author
+e.g.
+#### <%= name %>::default
+<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
+TODO: Write usage instructions for each cookbook.
+
+e.g.
+Just include `<%= name %>` in your node's `run_list`:
+
+```json
+{
+  "name":"my_node",
+  "run_list": [
+    "recipe[<%= name %>]"
+  ]
+}
+```
+
+Contributing
+------------
+TODO: (optional) If this is a public cookbook, detail the process for contributing. If this is a private cookbook, remove this section.
+
+e.g.
+
+1. Fork the repository on Github
+2. Create a named feature branch (like `add_component_x`)
+3. Write you change
+4. Write tests for your change (if applicable)
+5. Run the tests, ensuring they all pass
+6. Submit a Pull Request using Github
+
+License and Authors
+-------------------
 Author:: <%= maintainer %> (<<%= maintainer_email %>>)

data/generator_files/Vagrantfile.erb

@@ -8,6 +8,17 @@ Vagrant.configure("2") do |config|
 
   config.vm.hostname = "<%= "#{cookbook_name.gsub('_','-')}-berkshelf" %>"
 
+  # Set the version of chef to install using the vagrant-omnibus plugin
+<% if berkshelf_config.vagrant.omnibus.enabled -%>
+<% if berkshelf_config.vagrant.omnibus.version == "latest" -%>
+  config.omnibus.chef_version = :latest
+<% else %>
+  config.omnibus.chef_version = "<%= berkshelf_config.vagrant.omnibus.version %>"
+<% end -%>
+<% else %>
+  #config.omnibus.chef_version = :latest
+<% end -%>
+
   # Every Vagrant virtual environment requires a box to build off of.
   config.vm.box = "<%= berkshelf_config.vagrant.vm.box %>"
 
@@ -96,10 +107,10 @@ Vagrant.configure("2") do |config|
 <% 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'
+      mysql: {
+        server_root_password: 'rootpass',
+        server_debian_password: 'debpass',
+        server_repl_password: 'replpass'
       }
     }
 

data/lib/berkshelf.rb

@@ -1,6 +1,5 @@
 require 'buff/extensions'
 require 'archive/tar/minitar'
-require 'celluloid'
 require 'digest/md5'
 require 'forwardable'
 require 'hashie'
@@ -42,7 +41,7 @@ module Berkshelf
       @ui ||= Thor::Base.shell.new
     end
 
-    # Returns the filepath to the location Berskhelf will use for
+    # Returns the filepath to the location Berkshelf will use for
     # storage; temp files will go here, Cookbooks will be downloaded
     # to or uploaded from here. By default this is '~/.berkshelf' but
     # can be overridden by specifying a value for the ENV variable
@@ -143,7 +142,6 @@ require_relative 'berkshelf/api_client'
 require_relative 'berkshelf/base_generator'
 require_relative 'berkshelf/berksfile'
 require_relative 'berkshelf/cached_cookbook'
-require_relative 'berkshelf/chef'
 require_relative 'berkshelf/cli'
 require_relative 'berkshelf/community_rest'
 require_relative 'berkshelf/cookbook_generator'
@@ -165,5 +163,5 @@ require_relative 'berkshelf/source_uri'
 require_relative 'berkshelf/ui'
 require_relative 'berkshelf/version'
 
-Ridley.logger = Celluloid.logger = Berkshelf.logger = Logger.new(STDOUT)
+Ridley.logger = Berkshelf.logger = Logger.new(STDOUT)
 Berkshelf.logger.level = Logger::WARN

data/lib/berkshelf/api_client.rb

@@ -1,15 +1,13 @@
-require 'addressable/uri'
-
 module Berkshelf
   # Used to communicate with a remotely hosted [Berkshelf API Server](https://github.com/riotgames/berkshelf-api).
   #
   # @example
-  #   client = Berkshelf::APIClient.new("http://api.berkshelf.com")
+  #   client = Berkshelf::APIClient.new("https://api.berkshelf.com")
   #   client.universe #=> [...]
   class APIClient < Faraday::Connection
     require_relative 'api_client/remote_cookbook'
 
-    # @return [Addressable::URI]
+    # @return [String]
     attr_reader :url
 
     # @return [Integer]
@@ -28,11 +26,11 @@ module Berkshelf
     #   how long to wait (in seconds) between each retry
     def initialize(url, options = {})
       options         = options.reverse_merge(retries: 5, retry_interval: 0.5)
-      @url            = Addressable::URI.parse(url)
+      @url            = url
       @retries        = options[:retries]
       @retry_interval = options[:retry_interval]
 
-      builder = Faraday::Builder.new do |b|
+      options[:builder] ||= Faraday::Builder.new do |b|
         b.response :parse_json
         b.response :gzip
         b.request :retry,
@@ -43,7 +41,7 @@ module Berkshelf
         b.adapter :net_http
       end
 
-      super(self.url, builder: builder)
+      super(self.url, options)
     end
 
     # Retrieves the entire universe of known cookbooks from the API source