knife-essentials 0.9.2 → 0.9.3

data/lib/chef_fs/file_system/nodes_dir.rb

@@ -28,20 +28,14 @@ module ChefFS
         super("nodes", parent, nil, ChefFS::DataHandler::NodeDataHandler.new)
       end
 
-      # Override children to respond to environment
-      # TODO let's not do this mmkay
-      def children
-        @children ||= begin
-          env_api_path = environment ? "environments/#{environment}/#{api_path}" : api_path
-          rest.get_rest(env_api_path).keys.sort.map { |key| RestListEntry.new("#{key}.json", self, true) }
-        rescue Net::HTTPServerException
-          if $!.response.code == "404"
-            raise ChefFS::FileSystem::NotFoundError.new(self, $!)
-          else
-            raise
-          end
-        end
-    end
+      # Override to respond to environment
+      def chef_collection
+        rest.get_rest(env_api_path)
+      end
+
+      def env_api_path
+        environment ? "environments/#{environment}/#{api_path}" : api_path
+      end
     end
   end
 end

data/lib/chef_fs/file_system/rest_list_dir.rb

@@ -44,7 +44,7 @@ module ChefFS
 
       def children
         begin
-          @children ||= rest.get_rest(api_path).keys.sort.map do |key|
+          @children ||= chef_collection.keys.sort.map do |key|
             _make_child_entry("#{key}.json", true)
           end
         rescue Net::HTTPServerException => e
@@ -56,6 +56,10 @@ module ChefFS
         end
       end
 
+      def chef_collection
+        rest.get_rest(api_path)
+      end
+
       def identity_key
         'name'
       end
@@ -64,7 +68,7 @@ module ChefFS
       # DataBagDir.create_child as well.
       def create_child(name, file_contents)
         begin
-          object = Chef::JSONCompat.from_json(file_contents).to_hash
+          object = JSON.parse(file_contents, :create_additions => false)
         rescue JSON::ParserError => e
           raise ChefFS::FileSystem::OperationFailedError.new(:create_child, self, e), "Parse error reading JSON creating child '#{name}': #{e}"
         end

data/lib/chef_fs/file_system/rest_list_entry.rb

@@ -74,7 +74,17 @@ module ChefFS
 
       def read
         # Minimize the value so the results don't look terrible
-        Chef::JSONCompat.to_json_pretty(minimize_value(chef_object.to_hash))
+        Chef::JSONCompat.to_json_pretty(minimize_value(chef_hash))
+      end
+
+      def chef_hash
+        JSON.parse(raw_request(api_path), :create_additions => false)
+      rescue Net::HTTPServerException => e
+        if $!.response.code == "404"
+          raise ChefFS::FileSystem::NotFoundError.new(self, $!)
+        else
+          raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e)
+        end
       end
 
       def chef_object
@@ -113,7 +123,8 @@ module ChefFS
         value = minimize_value(value)
         value_json = Chef::JSONCompat.to_json_pretty(value)
         begin
-          other_value = Chef::JSONCompat.from_json(other_value_json, :create_additions => false)
+          #other_value = Chef::JSONCompat.from_json(other_value_json, :create_additions => false)
+          other_value = JSON.parse(other_value_json, :create_additions => false)
         rescue JSON::ParserError => e
           Chef::Log.warn("Parse error reading #{other.path_for_printing} as JSON: #{e}")
           return [ nil, value_json, other_value_json ]
@@ -130,7 +141,8 @@ module ChefFS
 
       def write(file_contents)
         begin
-          object = Chef::JSONCompat.from_json(file_contents).to_hash
+          #object = Chef::JSONCompat.from_json(file_contents).to_hash
+          object = JSON.parse(file_contents, :create_additions => false)
         rescue JSON::ParserError => e
           raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "Parse error reading JSON: #{e}"
         end

data/lib/chef_fs/knife.rb

@@ -29,6 +29,11 @@ module ChefFS
         :long => '--repo-mode MODE',
         :default => "default",
         :description => "Specifies the local repository layout.  Values: default or full"
+
+      option :chef_repo_path,
+        :long => '--chef-repo-path PATH',
+        :default => nil,
+        :description => 'Overrides the location of chef repo. Default is specified by chef_repo_paths in the config'
     end
 
     def chef_fs
@@ -37,16 +42,16 @@ module ChefFS
 
     def chef_repo_paths
       @chef_repo_paths ||= begin
-        result = config_paths(:chef_repo_path)
-        if result
-          result
-        else
-          if Chef::Config[:cookbook_path]
-            Array(Chef::Config[:cookbook_path]).flatten.map { |path| File.expand_path('..', path) }
-          else
-            nil
-          end
-        end
+                             result = config_paths(:chef_repo_path)
+                             if result
+                               result
+                             else
+                               if Chef::Config[:cookbook_path]
+                                 Array(Chef::Config[:cookbook_path]).flatten.map { |path| File.expand_path('..', path) }
+                               else
+                                 nil
+                               end
+                             end
       end
     end
 
@@ -78,14 +83,20 @@ module ChefFS
           object_names = %w(cookbooks data_bags environments roles)
         end
         object_names.each do |object_name|
-          variable_name = "#{object_name[0..-2]}_path" # cookbooks -> cookbook_path
-          paths = config_paths(variable_name.to_sym)
-          if !paths
-            if !chef_repo_paths
-              Chef::Log.error("Must specify either chef_repo_path or #{variable_name} in Chef config file")
-              exit(1)
+          # If --chef-repo-path is passed in the command line, then override *everything*
+          # and assume all the subdirectory is contained in that directory.
+          if config[:chef_repo_path]
+            paths = [ "#{config[:chef_repo_path]}/#{object_name}" ]
+          else
+            variable_name = "#{object_name[0..-2]}_path" # cookbooks -> cookbook_path
+            paths = config_paths(variable_name.to_sym)
+            if !paths
+              if !chef_repo_paths
+                Chef::Log.error("Must specify either chef_repo_path or #{variable_name} in Chef config file")
+                exit(1)
+              end
+              paths = chef_repo_paths.map { |path| File.join(path, object_name) }
             end
-            paths = chef_repo_paths.map { |path| File.join(path, object_name) }
           end
           paths = paths.flatten.map { |path| File.expand_path(path) }
           result[object_name] = paths

data/lib/chef_fs/version.rb

@@ -1,3 +1,3 @@
 module ChefFS
-  VERSION = "0.9.2"
+  VERSION = "0.9.3"
 end

data/spec/chef_fs/file_system/chef_server_root_dir_spec.rb

@@ -20,6 +20,24 @@ require 'support/spec_helper'
 require 'chef_fs/file_system/chef_server_root_dir'
 
 describe ChefFS::FileSystem::ChefServerRootDir do
+
+  let(:should_receive_children) { endpoint.should_receive(:chef_collection).once.and_return(chef_collection) }
+  let(:should_receive_read) { endpoint_leaf.should_receive(:chef_hash).once.and_return(chef_hash) }
+  let(:should_throw_404) do
+    nonexistent_child.should_receive(:raw_request).
+      with("#{endpoint_name}/blah").
+      once.and_raise(Net::HTTPServerException.new(nil,Net::HTTPResponse.new(nil,'404',nil)))
+  end
+
+  let(:chef_collection) do
+    {
+      "achild" => "http://opscode.com/achild",
+      "bchild" => "http://opscode.com/bchild"
+    }
+  end
+
+  let(:chef_hash) { { 'a' => 'b' } }
+
   shared_examples 'a json endpoint dir leaf' do
     it 'parent is endpoint' do
       endpoint_leaf.parent.should == endpoint
@@ -41,10 +59,7 @@ describe ChefFS::FileSystem::ChefServerRootDir do
       endpoint_leaf.exists?.should be_true
     end
     it 'read returns content' do
-      @rest.should_receive(:get_rest).with("#{endpoint_name}/#{endpoint_leaf_name}").once.and_return(
-        {
-          'a' => 'b'
-        })
+      should_receive_read
       endpoint_leaf.read.should == '{
   "name": "achild",
   "a": "b"
@@ -52,6 +67,7 @@ describe ChefFS::FileSystem::ChefServerRootDir do
     end
   end
 
+
   shared_examples 'a json rest endpoint dir' do
     it 'parent is root' do
       endpoint.parent.should == root_dir
@@ -81,17 +97,13 @@ describe ChefFS::FileSystem::ChefServerRootDir do
       endpoint.can_have_child?('blah', true).should be_false
       endpoint.can_have_child?('blah.json', true).should be_false
     end
-    let(:should_receive_children) {
-      @rest.should_receive(:get_rest).with(endpoint_name).once.and_return(
-        {
-          "achild" => "http://opscode.com/achild",
-          "bchild" => "http://opscode.com/bchild"
-        })
-    }
+
+
     it 'has correct children' do
       should_receive_children
       endpoint.children.map { |child| child.name }.should =~ %w(achild.json bchild.json)
     end
+
     context 'achild in endpoint.children' do
       let(:endpoint_leaf_name) { 'achild' }
       let(:endpoint_leaf) do
@@ -121,7 +133,7 @@ describe ChefFS::FileSystem::ChefServerRootDir do
         nonexistent_child.dir?.should be_false
       end
       it 'read returns NotFoundError' do
-        @rest.should_receive(:get_rest).with("#{endpoint_name}/blah").once.and_raise(Net::HTTPServerException.new(nil,Net::HTTPResponse.new(nil,'404',nil)))
+        should_throw_404
         expect { nonexistent_child.read }.to raise_error(ChefFS::FileSystem::NotFoundError)
       end
     end
@@ -135,10 +147,12 @@ describe ChefFS::FileSystem::ChefServerRootDir do
       :client_key => 'key'
     }, 'everything')
   }
+
   before(:each) do
     @rest = double("rest")
     Chef::REST.stub(:new).with('url','username','key') { @rest }
   end
+
   context 'the root directory' do
     it 'has no parent' do
       root_dir.parent.should == nil

data/spec/chef_fs/file_system/cookbook_dir_spec.rb

@@ -0,0 +1,582 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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 'support/spec_helper'
+require 'chef_fs/file_system/chef_server_root_dir'
+require 'chef_fs/file_system'
+
+describe ChefFS::FileSystem::CookbookDir do
+  let(:root_dir) {
+    ChefFS::FileSystem::ChefServerRootDir.new('remote',
+    {
+      :chef_server_url => 'url',
+      :node_name => 'username',
+      :client_key => 'key'
+    },
+    'everything')
+  }
+
+  let(:cookbook_response) do
+      {
+        "achild" => {
+          "url" => "http://example.com/cookbooks/achild",
+          'versions' => [
+            { "version" => '2.0.0', 'url' => 'http://example.com/cookbooks/achild/2.0.0' },
+            { "version" => '1.0.0', 'url' => 'http://example.com/cookbooks/achild/2.0.0' }, ] },
+        "bchild" => {
+          "url" => "http://example.com/cookbokks/bchild",
+          'versions' => [ { "version" => '1.0.0', 'url' => 'http://example.com/cookbooks/achild/2.0.0' }, ] },
+
+      }
+  end
+
+  let(:cookbooks_dir) { root_dir.child('cookbooks') }
+  let(:should_list_cookbooks) { rest.should_receive(:get_rest).with('cookbooks').once.and_return(cookbook_response) }
+
+  let(:rest)  { double 'rest' }
+  before(:each) { Chef::REST.stub(:new).with('url','username','key') { rest } }
+
+  # Cookbook dir (/cookbooks/<blah>)
+  shared_examples_for 'a segment directory' do
+    it 'has cookbook as parent' do
+      segment_dir.parent.should == cookbook_dir
+    end
+    it 'exists' do
+      segment_dir.exists?.should be_true
+    end
+    it 'is a directory' do
+      segment_dir.dir?.should be_true
+    end
+    it 'name is correct' do
+      segment_dir.name.should == segment_dir_name
+    end
+    it 'path is correct' do
+      segment_dir.path.should == "/cookbooks/#{cookbook_dir_name}/#{segment_dir_name}"
+    end
+    it 'path_for_printing is correct' do
+      segment_dir.path_for_printing.should == "remote/cookbooks/#{cookbook_dir_name}/#{segment_dir_name}"
+    end
+    it 'has the right children' do
+      segment_dir.children =~ %w(a.rb b.txt subdir)
+    end
+    it 'children are identical to child()' do
+      segment_dir.child('a.rb').should == segment_dir.children.select { |child| child.name == 'a.rb' }.first
+      segment_dir.child('b.txt').should == segment_dir.children.select { |child| child.name == 'b.txt' }.first
+      segment_dir.child('subdir').should == segment_dir.children.select { |child| child.name == 'subdir' }.first
+    end
+    context 'subdirectory' do
+      it 'has segment as a parent' do
+        segment_dir.child('subdir').parent.should == segment_dir
+      end
+      it 'exists' do
+        segment_dir.child('subdir').exists?.should be_true
+      end
+      it 'is a directory' do
+        segment_dir.child('subdir').dir?.should be_true
+      end
+      it 'name is subdir' do
+        segment_dir.child('subdir').name.should == 'subdir'
+      end
+      it 'path is correct' do
+        segment_dir.child('subdir').path.should == "/cookbooks/#{cookbook_dir_name}/#{segment_dir_name}/subdir"
+      end
+      it 'path_for_printing is correct' do
+        segment_dir.child('subdir').path_for_printing.should == "remote/cookbooks/#{cookbook_dir_name}/#{segment_dir_name}/subdir"
+      end
+      it 'has the right children' do
+        segment_dir.child('subdir').children =~ %w(a.rb b.txt)
+      end
+      it 'children are identical to child()' do
+        segment_dir.child('subdir').child('a.rb').should == segment_dir.child('subdir').children.select { |child| child.name == 'a.rb' }.first
+        segment_dir.child('subdir').child('b.txt').should == segment_dir.child('subdir').children.select { |child| child.name == 'b.txt' }.first
+      end
+    end
+  end
+
+  shared_examples_for 'a cookbook' do
+    it 'has cookbooks as parent' do
+      cookbook_dir.parent == cookbooks_dir
+    end
+    it 'is a directory' do
+      should_list_cookbooks
+      cookbook_dir.dir?.should be_true
+    end
+    it 'exists' do
+      should_list_cookbooks
+      cookbook_dir.exists?.should be_true
+    end
+    it 'has name <cookbook name>' do
+      cookbook_dir.name.should == cookbook_dir_name
+    end
+    it 'has path /cookbooks/<cookbook name>' do
+      cookbook_dir.path.should == "/cookbooks/#{cookbook_dir_name}"
+    end
+    it 'has path_for_printing remote/cookbooks/<cookbook name>' do
+      cookbook_dir.path_for_printing.should == "remote/cookbooks/#{cookbook_dir_name}"
+    end
+    it 'can have segment directories as children' do
+      cookbook_dir.can_have_child?('attributes', true).should be_true
+      cookbook_dir.can_have_child?('definitions', true).should be_true
+      cookbook_dir.can_have_child?('recipes', true).should be_true
+      cookbook_dir.can_have_child?('libraries', true).should be_true
+      cookbook_dir.can_have_child?('templates', true).should be_true
+      cookbook_dir.can_have_child?('files', true).should be_true
+      cookbook_dir.can_have_child?('resources', true).should be_true
+      cookbook_dir.can_have_child?('providers', true).should be_true
+    end
+    it 'cannot have arbitrary directories as children' do
+      cookbook_dir.can_have_child?('blah', true).should be_false
+      cookbook_dir.can_have_child?('root_files', true).should be_false
+    end
+    it 'can have files as children' do
+      cookbook_dir.can_have_child?('blah', false).should be_true
+      cookbook_dir.can_have_child?('root_files', false).should be_true
+      cookbook_dir.can_have_child?('attributes', false).should be_true
+      cookbook_dir.can_have_child?('definitions', false).should be_true
+      cookbook_dir.can_have_child?('recipes', false).should be_true
+      cookbook_dir.can_have_child?('libraries', false).should be_true
+      cookbook_dir.can_have_child?('templates', false).should be_true
+      cookbook_dir.can_have_child?('files', false).should be_true
+      cookbook_dir.can_have_child?('resources', false).should be_true
+      cookbook_dir.can_have_child?('providers', false).should be_true
+    end
+    # TODO test empty parts, cross-contamination (root_files named templates/x.txt, libraries named recipes/blah.txt)
+    context 'with a full directory structure' do
+
+      let(:manifest) do
+        {
+          :attributes  => json_files('attributes'),
+          :definitions => json_files('definitions'),
+          :files       => json_files('files'),
+          :libraries   => json_files('libraries'),
+          :providers   => json_files('providers'),
+          :recipes     => json_files('recipes'),
+          :resources   => json_files('resources'),
+          :templates   => json_files('templates'),
+          :root_files  => root_files.map { |f| json_file(f, file_checksums[f]) }
+        }
+      end
+
+      def json_file(path, checksum)
+        {
+          :name => basename(path),
+          :url => "cookbook_file:#{path}",
+          :checksum => checksum,
+          :path => path,
+          :specificity => "default"
+        }
+      end
+
+      def json_files(segment)
+        files.
+          select { |f| /^#{segment}\//.match(f) }.
+          map    { |f| json_file(f, file_checksums[f]) }
+      end
+
+      def basename(path)
+        ChefFS::PathUtils.split(path)[-1]
+      end
+
+      let(:segments) { %w(attributes definitions files libraries providers recipes resources templates) }
+      let(:some_filenames) { %w(a.rb b.txt subdir/a.rb subdir/b.txt) }
+      let(:root_files) { ['root_files'] + some_filenames }
+
+      # Generate a sample cookbook
+      let(:files) { [root_files, segment_files].flatten }
+      let(:segment_files) { segments.map { |s| some_filenames.map { |f| "#{s}/#{f}" } } }
+
+      # Make a hash where { filename => checksum }
+      let(:file_checksums) { Hash[*(files.each_with_index.map(&filename_with_checksum).flatten)] }
+      let(:filename_with_checksum) { lambda { |f, i| [f, i.to_s(16)] } }
+
+      let(:cookbook) { double('cookbook').tap { |c| c.should_receive(:manifest).and_return(manifest) } }
+      let(:api_url) do
+        if Chef::Config[:versioned_cookbooks]
+          "cookbooks/?num_versions=all"
+        else
+          "cookbooks/#{cookbook_dir_name}/_latest"
+        end
+      end
+
+      let(:should_get_cookbook) do
+        rest.should_receive(:get_rest).with(api_url).once.and_return(cookbook)
+      end
+
+      it 'has correct children' do
+        should_get_cookbook
+        cookbook_dir.children.map { |child| child.name }.should =~ %w(attributes definitions files libraries providers recipes resources templates a.rb b.txt subdir root_files)
+      end
+      it 'children and child() yield the exact same objects' do
+        should_get_cookbook
+        cookbook_dir.children.each { |child| child.should == cookbook_dir.child(child.name) }
+      end
+      it 'all files exist (recursive) and have correct parent, path, path_for_printing, checksum and type' do
+        should_get_cookbook
+        file_checksums.each do |path, checksum|
+          file = ChefFS::FileSystem.resolve_path(cookbook_dir, path)
+          file_parts = path.split('/')
+          if file_parts.length == 3
+            file.parent.parent.parent.should == cookbook_dir
+          elsif file_parts.length == 2
+            file.parent.parent.should == cookbook_dir
+          else
+            file.parent.should == cookbook_dir
+          end
+          file.exists?.should be_true
+          file.dir?.should be_false
+          file.name.should == file_parts[-1]
+          file.path.should == "/cookbooks/#{cookbook_dir_name}/#{path}"
+          file.path_for_printing.should == "remote/cookbooks/#{cookbook_dir_name}/#{path}"
+          file.checksum.should == checksum
+        end
+      end
+      it 'all files can be read' do
+        should_get_cookbook
+        files.each do |path|
+          cookbook_file = double(path)
+          cookbook_file.should_receive(:open).with(no_args()).once
+          cookbook_file.should_receive(:read).with(no_args()).once.and_return("This is #{path}'s content")
+          cookbook_file.should_receive(:close!).with(no_args()).once
+          rest.should_receive(:get_rest).with("cookbook_file:#{path}", true).once.and_return(cookbook_file)
+          rest.should_receive(:sign_on_redirect).with(no_args()).once.and_return(true)
+          rest.should_receive(:sign_on_redirect=).with(false).once
+          rest.should_receive(:sign_on_redirect=).with(true).once
+          file = ChefFS::FileSystem.resolve_path(cookbook_dir, path)
+          file.read.should == "This is #{path}'s content"
+        end
+      end
+
+      context 'the attributes segment' do
+        let(:segment_dir) { cookbook_dir.child('attributes') }
+        let(:segment_dir_name) { 'attributes' }
+        it_behaves_like 'a segment directory'
+
+        before(:each) do
+          should_get_cookbook
+        end
+
+        it 'can have ruby files' do
+          should_get_cookbook
+          segment_dir.can_have_child?('blah.rb', false).should be_true
+          segment_dir.can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'cannot have non-ruby files' do
+          should_get_cookbook
+          segment_dir.can_have_child?('blah.txt', false).should be_false
+          segment_dir.can_have_child?('.blah.txt', false).should be_false
+        end
+        it 'cannot have subdirectories' do
+          should_get_cookbook
+          segment_dir.can_have_child?('blah', true).should be_false
+        end
+      end
+
+      context 'the definitions segment' do
+        let(:segment_dir) { cookbook_dir.child('definitions') }
+        let(:segment_dir_name) { 'definitions' }
+        it_behaves_like 'a segment directory'
+
+        before(:each) do
+          should_get_cookbook
+        end
+
+        it 'can have ruby files' do
+          segment_dir.can_have_child?('blah.rb', false).should be_true
+          segment_dir.can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'cannot have non-ruby files' do
+          segment_dir.can_have_child?('blah.txt', false).should be_false
+          segment_dir.can_have_child?('.blah.txt', false).should be_false
+        end
+        it 'cannot have subdirectories' do
+          segment_dir.can_have_child?('blah', true).should be_false
+        end
+      end
+
+      context 'the files segment' do
+        let(:segment_dir) { cookbook_dir.child('files') }
+        let(:segment_dir_name) { 'files' }
+        it_behaves_like 'a segment directory'
+
+        before(:each) do
+          should_get_cookbook
+        end
+
+        it 'can have ruby files' do
+          segment_dir.can_have_child?('blah.rb', false).should be_true
+          segment_dir.can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'can have non-ruby files' do
+          segment_dir.can_have_child?('blah.txt', false).should be_true
+          segment_dir.can_have_child?('.blah.txt', false).should be_true
+        end
+        it 'can have subdirectories' do
+          segment_dir.can_have_child?('blah', true).should be_true
+        end
+        it 'subdirectories can have ruby files' do
+          segment_dir.child('subdir').can_have_child?('blah.rb', false).should be_true
+          segment_dir.child('subdir').can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'subdirectories can have non-ruby files' do
+          segment_dir.child('subdir').can_have_child?('blah.txt', false).should be_true
+          segment_dir.child('subdir').can_have_child?('.blah.txt', false).should be_true
+        end
+        it 'subdirectories can have subdirectories' do
+          segment_dir.child('subdir').can_have_child?('blah', true).should be_true
+        end
+      end
+
+      context 'the libraries segment' do
+        let(:segment_dir) { cookbook_dir.child('libraries') }
+        let(:segment_dir_name) { 'libraries' }
+        it_behaves_like 'a segment directory'
+
+        before(:each) do
+          should_get_cookbook
+        end
+
+        it 'can have ruby files' do
+          segment_dir.can_have_child?('blah.rb', false).should be_true
+          segment_dir.can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'cannot have non-ruby files' do
+          segment_dir.can_have_child?('blah.txt', false).should be_false
+          segment_dir.can_have_child?('.blah.txt', false).should be_false
+        end
+        it 'cannot have subdirectories' do
+          segment_dir.can_have_child?('blah', true).should be_false
+        end
+      end
+
+      context 'the providers segment' do
+        let(:segment_dir) { cookbook_dir.child('providers') }
+        let(:segment_dir_name) { 'providers' }
+        it_behaves_like 'a segment directory'
+
+        before(:each) do
+          should_get_cookbook
+        end
+
+        it 'can have ruby files' do
+          segment_dir.can_have_child?('blah.rb', false).should be_true
+          segment_dir.can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'cannot have non-ruby files' do
+          segment_dir.can_have_child?('blah.txt', false).should be_false
+          segment_dir.can_have_child?('.blah.txt', false).should be_false
+        end
+        it 'can have subdirectories' do
+          segment_dir.can_have_child?('blah', true).should be_true
+        end
+        it 'subdirectories can have ruby files' do
+          segment_dir.child('subdir').can_have_child?('blah.rb', false).should be_true
+          segment_dir.child('subdir').can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'subdirectories cannot have non-ruby files' do
+          segment_dir.child('subdir').can_have_child?('blah.txt', false).should be_false
+          segment_dir.child('subdir').can_have_child?('.blah.txt', false).should be_false
+        end
+        it 'subdirectories can have subdirectories' do
+          segment_dir.child('subdir').can_have_child?('blah', true).should be_true
+        end
+      end
+
+      context 'the recipes segment' do
+        let(:segment_dir) { cookbook_dir.child('recipes') }
+        let(:segment_dir_name) { 'recipes' }
+        it_behaves_like 'a segment directory'
+
+        before(:each) do
+          should_get_cookbook
+        end
+
+        it 'can have ruby files' do
+          segment_dir.can_have_child?('blah.rb', false).should be_true
+          segment_dir.can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'cannot have non-ruby files' do
+          segment_dir.can_have_child?('blah.txt', false).should be_false
+          segment_dir.can_have_child?('.blah.txt', false).should be_false
+        end
+        it 'cannot have subdirectories' do
+          segment_dir.can_have_child?('blah', true).should be_false
+        end
+      end
+
+      context 'the resources segment' do
+        let(:segment_dir) { cookbook_dir.child('resources') }
+        let(:segment_dir_name) { 'resources' }
+        it_behaves_like 'a segment directory'
+
+        before(:each) do
+          should_get_cookbook
+        end
+
+        it 'can have ruby files' do
+          segment_dir.can_have_child?('blah.rb', false).should be_true
+          segment_dir.can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'cannot have non-ruby files' do
+          segment_dir.can_have_child?('blah.txt', false).should be_false
+          segment_dir.can_have_child?('.blah.txt', false).should be_false
+        end
+        it 'can have subdirectories' do
+          segment_dir.can_have_child?('blah', true).should be_true
+        end
+        it 'subdirectories can have ruby files' do
+          segment_dir.child('subdir').can_have_child?('blah.rb', false).should be_true
+          segment_dir.child('subdir').can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'subdirectories cannot have non-ruby files' do
+          segment_dir.child('subdir').can_have_child?('blah.txt', false).should be_false
+          segment_dir.child('subdir').can_have_child?('.blah.txt', false).should be_false
+        end
+        it 'subdirectories can have subdirectories' do
+          segment_dir.child('subdir').can_have_child?('blah', true).should be_true
+        end
+      end
+
+      context 'the templates segment' do
+        let(:segment_dir) { cookbook_dir.child('templates') }
+        let(:segment_dir_name) { 'templates' }
+        it_behaves_like 'a segment directory'
+
+        before(:each) do
+          should_get_cookbook
+        end
+
+        it 'can have ruby files' do
+          segment_dir.can_have_child?('blah.rb', false).should be_true
+          segment_dir.can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'can have non-ruby files' do
+          segment_dir.can_have_child?('blah.txt', false).should be_true
+          segment_dir.can_have_child?('.blah.txt', false).should be_true
+        end
+        it 'can have subdirectories' do
+          segment_dir.can_have_child?('blah', true).should be_true
+        end
+        it 'subdirectories can have ruby files' do
+          segment_dir.child('subdir').can_have_child?('blah.rb', false).should be_true
+          segment_dir.child('subdir').can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'subdirectories can have non-ruby files' do
+          segment_dir.child('subdir').can_have_child?('blah.txt', false).should be_true
+          segment_dir.child('subdir').can_have_child?('.blah.txt', false).should be_true
+        end
+        it 'subdirectories can have subdirectories' do
+          segment_dir.child('subdir').can_have_child?('blah', true).should be_true
+        end
+      end
+
+      context 'root subdirectories' do
+        let(:root_subdir) { cookbook_dir.child('subdir') }
+
+        before(:each) do
+          should_get_cookbook
+        end
+
+        # Really, since these shouldn't exist in the first place,
+        # it doesn't matter; but these REALLY shouldn't be able to
+        # have any files in them at all.
+        it 'can have ruby files' do
+          root_subdir.can_have_child?('blah.rb', false).should be_true
+          root_subdir.can_have_child?('.blah.rb', false).should be_true
+        end
+        it 'can have non-ruby files' do
+          root_subdir.can_have_child?('blah.txt', false).should be_true
+          root_subdir.can_have_child?('.blah.txt', false).should be_true
+        end
+        it 'cannot have subdirectories' do
+          root_subdir.can_have_child?('blah', true).should be_false
+        end
+      end
+    end
+  end
+
+  context 'achild from cookbooks_dir.children' do
+    let(:cookbook_dir_name) { 'achild' }
+    let(:cookbook_dir) do
+      should_list_cookbooks
+      cookbooks_dir.children.select { |child| child.name == 'achild' }.first
+    end
+    it_behaves_like 'a cookbook'
+  end
+
+  context 'cookbooks_dir.child(achild)' do
+    let(:cookbook_dir_name) { 'achild' }
+    let(:cookbook_dir) { cookbooks_dir.child('achild') }
+    it_behaves_like 'a cookbook'
+  end
+  context 'nonexistent cookbooks_dir.child()' do
+    let(:nonexistent_child) { cookbooks_dir.child('blah') }
+    it 'has correct parent, name, path and path_for_printing' do
+      nonexistent_child.parent.should == cookbooks_dir
+      nonexistent_child.name.should == "blah"
+      nonexistent_child.path.should == "/cookbooks/blah"
+      nonexistent_child.path_for_printing.should == "remote/cookbooks/blah"
+    end
+    it 'does not exist' do
+      should_list_cookbooks
+      nonexistent_child.exists?.should be_false
+    end
+    it 'is a directory' do
+      should_list_cookbooks
+      nonexistent_child.dir?.should be_false
+    end
+    it 'read returns NotFoundError' do
+      should_list_cookbooks
+      expect { nonexistent_child.read }.to raise_error(ChefFS::FileSystem::NotFoundError)
+    end
+  end
+
+  describe 'VALID_VERSIONED_COOKBOOK_NAME' do
+    subject { valid_versioned_cookbook_name.match(cookbook_name) }
+    let(:valid_versioned_cookbook_name) { ChefFS::FileSystem::CookbookDir::VALID_VERSIONED_COOKBOOK_NAME }
+
+    def self.should_accept(_cookbook_name)
+      context "with a cookbook name of '#{_cookbook_name}'" do
+        let(:cookbook_name) { _cookbook_name }
+        it 'should accept' do
+          should_not be_nil
+        end
+      end
+    end
+
+    def self.should_reject(_cookbook_name)
+      context "with a cookbook name of '#{_cookbook_name}'" do
+        let(:cookbook_name) { _cookbook_name }
+        it 'should reject' do
+          should be_nil
+        end
+      end
+    end
+
+    should_accept 'apt-1.8.4'
+    should_accept 'APT-1.8.4'
+    should_accept 'apt-100.83.4'
+    should_accept 'apt-2.0.0-1.8.4'
+    should_accept 'apt---1.8.4'
+
+    should_reject 'apt'
+    should_reject 'apt-1'
+    should_reject 'apt-1.2'
+    should_reject 'apt-1.2.x'
+
+  end
+end