berkshelf 3.0.0.beta2 → 3.0.0.beta3

data/features/help.feature

@@ -1,20 +1,11 @@
 Feature: Appending -h or --help to a command
-  As a user
-  I want to be able to run berkshelf like my existing Unix CLI tools
-  So that I don't have remember thor's stupid argument ordering
-
-  Scenario: Specifying the --help option
-    Given I successfully run `berks --help`
-    Then the output should be the same as `berks help`
-
-  Scenario: Specifying the -h option
-    Given I successfully run `berks -h`
-    Then the output should be the same as `berks help`
-
-  Scenario: Specifying the --help option to a sub-command
-    Given I successfully run `berks cookbook --help`
-    Then the output should be the same as `berks help cookbook`
-
-  Scenario: Specifying the -h option to a sub-command
-    Given I successfully run `berks cookbook -h`
-    Then the output should be the same as `berks help cookbook`
+  Scenario Outline: Using various help switches
+    Then the output from `<actual>` should be the same as `<expected>`
+    Examples:
+      | actual                | expected |
+      | berks --help          | berks help |
+      | berks -h              | berks help |
+      | berks cookbook --help | berks help cookbook |
+      | berks cookbook -h     | berks help cookbook |
+      | berks shelf --help    | berks shelf help |
+      | berks shelf -h        | berks shelf help |

data/features/json_formatter.feature

@@ -1,18 +1,13 @@
 Feature: --format json
-  As a user
-  I want to be able to get all output in JSON format
-  So I can easily parse the output in scripts
-
   Background:
-    Given the Berkshelf API server's cache is empty
-    And the Chef Server is empty
-    And the cookbook store is empty
+    * the Berkshelf API server's cache is empty
+    * the Chef Server is empty
+    * the cookbook store is empty
+
 
   Scenario: JSON output installing a cookbook from the default location
-    Given I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'berkshelf', '1.0.0'
       """
     And the Chef Server has cookbooks:
@@ -37,13 +32,12 @@ Feature: --format json
       }
       """
 
+
   Scenario: JSON output installing a cookbook we already have
     Given the cookbook store has the cookbooks:
       | berkshelf-cookbook-fixture   | 1.0.0 |
-    And I write to "Berksfile" with:
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'berkshelf-cookbook-fixture', '1.0.0'
       """
     When I successfully run `berks install --format json`
@@ -65,25 +59,16 @@ Feature: --format json
       }
       """
 
+
   Scenario: JSON output when running the show command
     Given the cookbook store has the cookbooks:
       | fake | 1.0.0 |
-    And I write to "Berksfile" with:
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'fake', '1.0.0'
       """
-    And I write to "Berksfile.lock" with:
-      """
-      {
-        "dependencies": {
-          "fake": {
-            "locked_version": "1.0.0"
-          }
-        }
-      }
-      """
+    And the Lockfile has:
+      | fake | 1.0.0 |
     When I successfully run `berks show fake --format json`
     Then the output should contain JSON:
       """
@@ -106,11 +91,10 @@ Feature: --format json
       }
       """
 
+
   Scenario: JSON output when running the upload command
-    Given I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'example_cookbook', path: '../../fixtures/cookbooks/example_cookbook-0.5.0'
       """
     When I successfully run `berks upload --format json`
@@ -134,6 +118,7 @@ Feature: --format json
       }
       """
 
+
   Scenario: JSON output when running the outdated command
     Given the cookbook store has the cookbooks:
       | seth | 0.1.0 |
@@ -142,31 +127,21 @@ Feature: --format json
       | seth | 0.2.9 |
       | seth | 1.0.0 |
     And the Berkshelf API server's cache is up to date
-    And I write to "Berksfile" with:
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'seth', '~> 0.1'
       """
-    And I write to "Berksfile.lock" with:
-      """
-      {
-        "dependencies": {
-          "seth": {
-            "locked_version": "0.1.0"
-          }
-        }
-      }
-      """
+    And the Lockfile has:
+      | seth | 0.1.0 |
     And I successfully run `berks outdated --format json`
-    Then the output should contain:
+    Then the output should contain JSON:
       """
       {
         "cookbooks": [
           {
             "version": "0.2.9",
             "sources": {
-              "http://localhost:26210": {
+              "http://0.0.0.0:26210": {
                 "name": "seth",
                 "version": "0.2.9"
               }

data/features/licenses.feature

@@ -1,27 +1,20 @@
 Feature: Installing cookbooks with specific licenses
-  As a user
-  I want to ensure my company only uses cookbooks that fall in our legal realm
-  So that I can safely install and legally use community cookbooks
-
   Background:
-    Given the Berkshelf API server's cache is empty
-    And the Chef Server is empty
-    And the cookbook store is empty
-
-  Scenario: With licenses defined
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 0.1.0 | mit |
-    And I write to "Berksfile" with:
+    * the Berkshelf API server's cache is empty
+    * the Chef Server is empty
+    * the cookbook store is empty
+    * I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
-      cookbook 'berkshelf-cookbook-fixture', '~> 0.1'
+      cookbook 'fake', '1.0.0'
       """
+
+
+  Scenario: when licenses is defined
+    Given the cookbook store has the cookbooks:
+      | fake | 1.0.0 | mit |
     And I have a Berkshelf config file containing:
       """
-      {
-        "allowed_licenses": ["mit"]
-      }
+      { "allowed_licenses": ["mit"] }
       """
     When I successfully run `berks install`
     Then the output should not contain:
@@ -29,20 +22,13 @@ Feature: Installing cookbooks with specific licenses
       is not in your list of allowed licenses
       """
 
-  Scenario: With a license that is not listed
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 0.1.0 | mit |
-    And I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
-      cookbook 'berkshelf-cookbook-fixture', '~> 0.1'
-      """
+  Scenario: when a license is not listed
+    Given the cookbook store has the cookbooks:
+      | fake | 1.0.0 | mit |
     And I have a Berkshelf config file containing:
       """
-      {
-        "allowed_licenses": ["apache2"]
-      }
+      { "allowed_licenses": ["apache2"] }
       """
     When I successfully run `berks install`
     Then the output should contain:
@@ -50,21 +36,13 @@ Feature: Installing cookbooks with specific licenses
       'mit' is not in your list of allowed licenses
       """
 
-  Scenario: With raise_license_exception defined
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 0.1.0 | mit |
-    And I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
-      cookbook 'berkshelf-cookbook-fixture', '~> 0.1'
-      """
+  Scenario: when raise_license_exception is defined
+    Given the cookbook store has the cookbooks:
+      | fake | 1.0.0 | mit |
     And I have a Berkshelf config file containing:
       """
-      {
-        "allowed_licenses": ["mit"],
-        "raise_license_exception": true
-      }
+      { "allowed_licenses": ["mit"], "raise_license_exception": true }
       """
     When I successfully run `berks install`
     Then the output should not contain:
@@ -72,21 +50,13 @@ Feature: Installing cookbooks with specific licenses
       is not in your list of allowed licenses
       """
 
-  Scenario: With a license that is not listed
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 0.1.0 | mit |
-    And I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
-      cookbook 'berkshelf-cookbook-fixture', '~> 0.1'
-      """
+  Scenario: when raise_license_exception is defined and a license is not listed
+    Given the cookbook store has the cookbooks:
+      | fake | 1.0.0 | mit |
     And I have a Berkshelf config file containing:
       """
-      {
-        "allowed_licenses": ["apache2"],
-        "raise_license_exception": true
-      }
+      { "allowed_licenses": ["apache2"], "raise_license_exception": true }
       """
     When I run `berks install`
     Then the output should contain:
@@ -95,21 +65,17 @@ Feature: Installing cookbooks with specific licenses
       """
     And the exit status should be "LicenseNotAllowed"
 
-  Scenario: With a :path location
+
+  Scenario: when the cookbook is a path location
     Given the cookbook store has the cookbooks:
       | fake | 0.1.0 | mit |
-    And I write to "Berksfile" with:
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'fake', path: '../../tmp/berkshelf/cookbooks/fake-0.1.0'
       """
     And I have a Berkshelf config file containing:
       """
-      {
-        "allowed_licenses": ["apache2"],
-        "raise_license_exception": true
-      }
+      { "allowed_licenses": ["apache2"], "raise_license_exception": true }
       """
     When I successfully run `berks install`
     Then the output should not contain:

data/features/lockfile.feature

@@ -1,36 +1,29 @@
 Feature: Creating and reading the Berkshelf lockfile
-  As a user
-  I want my versions to be locked even when I don't specify versions in my Berksfile
-  So when I share my repository, all other developers get the same versions that I did when I installed.
+  Background:
+    * the cookbook store has the cookbooks:
+      | fake | 0.1.0 |
+      | fake | 0.2.0 |
+      | fake | 1.0.0 |
+    * the cookbook store has the git cookbooks:
+      | berkshelf-cookbook-fixture | 0.2.0 | 70a527e17d91f01f031204562460ad1c17f972ee |
+      | berkshelf-cookbook-fixture | 1.0.0 | 919afa0c402089df23ebdf36637f12271b8a96b4 |
+      | berkshelf-cookbook-fixture | 1.0.0 | a97b9447cbd41a5fe58eee2026e48ccb503bd3bc |
+      | berkshelf-cookbook-fixture | 1.0.0 | 93f5768b7d14df45e10d16c8bf6fe98ba3ff809a |
+
 
   Scenario: Writing the Berksfile.lock
-    Given the cookbook store has the cookbooks:
-      | fake | 1.0.0 |
-    And I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'fake', '1.0.0'
       """
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "fake":{
-            "locked_version":"1.0.0"
-          }
-        }
-      }
-      """
-
-  Scenario: Wiring the Berksfile.lock when a 1.0 lockfile is present
-    Given the cookbook store has the cookbooks:
+    Then the Lockfile should have:
       | fake | 1.0.0 |
-    And I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
+
+  Scenario: Writing the Berksfile.lock when a 1.0 lockfile is present
+    Given I have a Berksfile pointing at the local Berkshelf API with:
+      """
       cookbook 'fake', '1.0.0'
       """
     And I write to "Berksfile.lock" with:
@@ -39,54 +32,14 @@ Feature: Creating and reading the Berkshelf lockfile
       """
     When I successfully run `berks install`
     Then the output should warn about the old lockfile format
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies": {
-          "fake": {
-            "locked_version": "1.0.0"
-          }
-        }
-      }
-      """
-
-  Scenario: Wiring the Berksfile.lock when a 2.0 lockfile is present
-    Given the cookbook store has the cookbooks:
+    And the Lockfile should have:
       | fake | 1.0.0 |
-    And I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
-      cookbook 'fake', '1.0.0'
-      """
-    And I write to "Berksfile.lock" with:
-      """
-      {
-        "dependencies": {
-          "fake": {
-            "locked_version": "1.0.0"
-          }
-        }
-      }
-      """
-    When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies": {
-          "fake": {
-            "locked_version": "1.0.0"
-          }
-        }
-      }
-      """
 
-  Scenario: Writing the Berksfile.lock when an old lockfile is present and contains a full path
+  Scenario: Writing the Berksfile.lock when a 1.0 lockfile is present and contains a full path
     Given a cookbook named "fake"
-    And I write to "Berksfile" with:
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'fake', '0.0.0', path: './fake'
       """
     And I write to "Berksfile.lock" with:
@@ -95,391 +48,205 @@ Feature: Creating and reading the Berkshelf lockfile
       """
     When I successfully run `berks install`
     Then the output should warn about the old lockfile format
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "fake":{
-            "path":"./fake"
-          }
-        }
-      }
-      """
+    Then the Lockfile should have:
+      | fake | ./fake |
 
-  Scenario: Reading the Berksfile.lock when it contains an invalid path location
-    Given the cookbook store has the cookbooks:
-      | fake | 1.0.0 |
-    And I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
-      cookbook 'fake'
+  Scenario: Writing the Berksfile.lock when a 2.0 lockfile is present
+    Given I have a Berksfile pointing at the local Berkshelf API with:
+      """
+      cookbook 'fake', '1.0.0'
       """
     And I write to "Berksfile.lock" with:
       """
       {
-        "dependencies":{
-          "non-existent":{
-            "path":"/this/path/does/not/exist"
+        "sources": {
+          "fake": {
+            "locked_version": "1.0.0"
           }
         }
       }
       """
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
+    Then the Lockfile should have:
+      | fake | 1.0.0 |
+
+
+  Scenario: Reading the Berksfile.lock when it contains an invalid path location
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      {
-        "dependencies":{
-          "fake":{
-            "locked_version":"1.0.0"
-          }
-        }
-      }
+      cookbook 'fake'
       """
+    And the Lockfile has:
+      | non-existent | /this/path/does/not/exist |
+    When I successfully run `berks install`
+    Then the Lockfile should have:
+      | fake | 1.0.0 |
+
 
   Scenario: Installing a cookbook with dependencies
     Given the cookbook store has the cookbooks:
       | dep | 1.0.0 |
     And the cookbook store contains a cookbook "fake" "1.0.0" with dependencies:
       | dep | ~> 1.0.0 |
-    And I write to "Berksfile" with:
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'fake', '1.0.0'
       """
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies": {
-          "fake":{
-            "locked_version": "1.0.0"
-          },
-          "dep":{
-            "locked_version": "1.0.0"
-          }
-        }
-      }
-      """
+    Then the Lockfile should have:
+      | fake | 1.0.0 |
+      | dep  | 1.0.0 |
 
-  Scenario: Writing the Berksfile.lock with a pessimistic lock
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 1.0.0 |
-    And I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
-      cookbook 'berkshelf-cookbook-fixture', '~> 1.0.0'
-      """
-    And I write to "Berksfile.lock" with:
+  Scenario: Writing the Berksfile.lock with a pessimistic lock
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "locked_version":"1.0.0"
-          }
-        }
-      }
+      cookbook 'fake', '~> 1.0.0'
       """
+    And the Lockfile has:
+      | fake | 1.0.0 |
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "locked_version":"1.0.0"
-          }
-        }
-      }
-      """
+    Then the Lockfile should have:
+      | fake | 1.0.0 |
 
-  Scenario: Updating with a Berksfile.lock with pessimistic lock
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 0.2.0 |
-      | berkshelf-cookbook-fixture | 1.0.0 |
-    And I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
-      cookbook 'berkshelf-cookbook-fixture', '~> 0.1'
-      """
-    And I write to "Berksfile.lock" with:
-      """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "locked_version":"0.1.0"
-          }
-        }
-      }
-      """
-    When I successfully run `berks update berkshelf-cookbook-fixture`
-    Then the file "Berksfile.lock" should contain JSON:
+  Scenario: Updating with a Berksfile.lock with pessimistic lock
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "locked_version":"0.2.0"
-          }
-        }
-      }
+      cookbook 'fake', '~> 0.1'
       """
+    And the Lockfile has:
+      | fake | 0.1.0 |
+    When I successfully run `berks update fake`
+    Then the Lockfile should have:
+      | fake | 0.2.0 |
 
-  Scenario: Updating with a Berksfile.lock with hard lock
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 1.0.0 |
-    And I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
-      cookbook 'berkshelf-cookbook-fixture', '1.0.0'
-      """
-    And I write to "Berksfile.lock" with:
-      """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "locked_version":"1.0.0"
-          }
-        }
-      }
+  Scenario: Updating with a Berksfile.lock with hard lock
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-    When I successfully run `berks update berkshelf-cookbook-fixture`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "locked_version":"1.0.0"
-          }
-        }
-      }
+      cookbook 'fake', '0.1.0'
       """
+    And the Lockfile has:
+      | fake | 0.1.0 |
+    When I successfully run `berks update fake`
+    Then the Lockfile should have:
+      | fake | 0.1.0 |
+
 
   Scenario: Updating a Berksfile.lock with a git location
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 1.0.0 |
-    And I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'berkshelf-cookbook-fixture', git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git', ref: '919afa0c4'
       """
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "git":"git://github.com/RiotGames/berkshelf-cookbook-fixture.git",
-            "ref":"919afa0c402089df23ebdf36637f12271b8a96b4",
-            "locked_version":"1.0.0"
-          }
-        }
-      }
-      """
+    Then the Lockfile should have:
+      | berkshelf-cookbook-fixture | 1.0.0 | 919afa0c402089df23ebdf36637f12271b8a96b4 |
+
 
   Scenario: Updating a Berksfile.lock with a git location and a branch
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 1.0.0 |
-    And I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'berkshelf-cookbook-fixture', git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git', branch: 'master'
       """
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "git":"git://github.com/RiotGames/berkshelf-cookbook-fixture.git",
-            "ref":"a97b9447cbd41a5fe58eee2026e48ccb503bd3bc",
-            "locked_version":"1.0.0"
-          }
-        }
-      }
-      """
+    Then the Lockfile should have:
+      | berkshelf-cookbook-fixture | 1.0.0 | a97b9447cbd41a5fe58eee2026e48ccb503bd3bc |
+
 
   Scenario: Updating a Berksfile.lock with a git location and a branch
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 70a527e17d91f01f031204562460ad1c17f972ee |
-    And I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'berkshelf-cookbook-fixture', git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git', tag: 'v0.2.0'
       """
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "git":"git://github.com/RiotGames/berkshelf-cookbook-fixture.git",
-            "ref":"70a527e17d91f01f031204562460ad1c17f972ee",
-            "locked_version":"0.2.0"
-          }
-        }
-      }
-      """
+    Then the Lockfile should have:
+      | berkshelf-cookbook-fixture | 0.2.0 | 70a527e17d91f01f031204562460ad1c17f972ee |
+
 
   Scenario: Updating a Berksfile.lock with a GitHub location
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 919afa0c402089df23ebdf36637f12271b8a96b4 |
-    And I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'berkshelf-cookbook-fixture', github: 'RiotGames/berkshelf-cookbook-fixture', ref: '919afa0c4'
       """
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "git":"git://github.com/RiotGames/berkshelf-cookbook-fixture.git",
-            "ref":"919afa0c402089df23ebdf36637f12271b8a96b4",
-            "locked_version":"1.0.0"
-          }
-        }
-      }
-      """
+    Then the Lockfile should have:
+      | berkshelf-cookbook-fixture | 1.0.0 | 919afa0c402089df23ebdf36637f12271b8a96b4 |
+
 
   Scenario: Updating a Berksfile.lock when a git location with :rel
-    Given I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'berkshelf-cookbook-fixture', github: 'RiotGames/berkshelf-cookbook-fixture', branch: 'rel', rel: 'cookbooks/berkshelf-cookbook-fixture'
       """
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "berkshelf-cookbook-fixture":{
-            "git":"git://github.com/RiotGames/berkshelf-cookbook-fixture.git",
-            "ref":"93f5768b7d14df45e10d16c8bf6fe98ba3ff809a",
-            "rel":"cookbooks/berkshelf-cookbook-fixture",
-            "locked_version":"1.0.0"
-          }
-        }
-      }
-      """
+    Then the Lockfile should have:
+      | berkshelf-cookbook-fixture | 1.0.0 | 93f5768b7d14df45e10d16c8bf6fe98ba3ff809a | cookbooks/berkshelf-cookbook-fixture |
+
 
   Scenario: Updating a Berksfile.lock with a path location
     Given a cookbook named "fake"
-    And I write to "Berksfile" with:
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'fake', path: './fake'
       """
     When I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies":{
-          "fake":{
-            "path":"./fake"
-          }
-        }
-      }
-      """
+    Then the Lockfile should have:
+      | fake | ./fake |
+
 
   Scenario: Installing a Berksfile with a metadata location
     Given a cookbook named "fake"
-    And the cookbook "fake" has the file "Berksfile" with:
+    And I cd to "fake"
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       metadata
       """
-    When I cd to "fake"
-    And I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies": {
-          "fake": {
-            "path": "."
-          }
-        }
-      }
-      """
+    When I successfully run `berks install`
+    Then the Lockfile should have:
+      | fake | . |
+
 
   Scenario: Installing a Berksfile with a metadata location
     Given a cookbook named "fake"
-    And the cookbook "fake" has the file "Berksfile" with:
+    And I cd to "fake"
+    And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       metadata
       """
-    And the cookbook "fake" has the file "Berksfile.lock" with:
-      """
-      {
-        "dependencies": {
-          "fake": {
-            "path": "."
-          }
-        }
-      }
-      """
-    When I cd to "fake"
-    And I successfully run `berks install`
-    Then the file "Berksfile.lock" should contain JSON:
-      """
-      {
-        "dependencies": {
-          "fake": {
-            "path": "."
-          }
-        }
-      }
-      """
+    And the Lockfile has:
+      | fake | . |
+    When I successfully run `berks install`
+    Then the Lockfile should have:
+      | fake | . |
 
-  Scenario: Installing when the locked version is no longer satisfied
-    Given the cookbook store has the cookbooks:
-      | berkshelf-cookbook-fixture | 1.0.0 |
-    Given I write to "Berksfile" with:
-      """
-      source "http://localhost:26210"
 
-      cookbook 'berkshelf-cookbook-fixture', '1.0.0'
-      """
-    And I successfully run `berks install`
-    And I write to "Berksfile" with:
+  Scenario: Installing when the locked version is no longer satisfied
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
-      cookbook 'berkshelf-cookbook-fixture', '~> 1.3.0'
+      cookbook 'fake', '~> 1.3.0'
       """
+    And the Lockfile has:
+      | fake | 1.0.0 |
     When I run `berks install`
     Then the output should contain:
       """
-      Berkshelf could not find compatible versions for cookbook 'berkshelf-cookbook-fixture':
+      Berkshelf could not find compatible versions for cookbook 'fake':
         In Berksfile:
-          berkshelf-cookbook-fixture (~> 1.3.0)
+          fake (~> 1.3.0)
 
         In Berksfile.lock:
-          berkshelf-cookbook-fixture (1.0.0)
+          fake (1.0.0)
 
-      Try running `berks update berkshelf-cookbook-fixture, which will try to find 'berkshelf-cookbook-fixture' matching '~> 1.3.0'
+      Try running `berks update fake`, which will try to find 'fake' matching '~> 1.3.0'
       """
     And the exit status should be "OutdatedDependency"
 
+
   Scenario: Installing when the Lockfile is empty
-    Given the cookbook store has the cookbooks:
-      | fake | 1.0.0 |
-    And I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'fake', '1.0.0'
       """
     And an empty file named "Berksfile.lock"
@@ -489,11 +256,10 @@ Feature: Creating and reading the Berkshelf lockfile
       Using fake (1.0.0)
       """
 
+
   Scenario: Installing when the Lockfile is in a bad state
-    Given I write to "Berksfile" with:
+    Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      source "http://localhost:26210"
-
       cookbook 'fake', '1.0.0'
       """
     Given I write to "Berksfile.lock" with: