cheffish 0.7.1 → 0.8

data/spec/integration/chef_mirror_spec.rb

@@ -0,0 +1,244 @@
+require 'support/spec_support'
+require 'chef/resource/chef_mirror'
+require 'chef/provider/chef_mirror'
+
+describe Chef::Resource::ChefMirror do
+  extend SpecSupport
+
+  when_the_chef_server 'is in multi-org mode', :osc_compat => false, :single_org => false do
+    organization 'foo'
+
+    before :each do
+      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, '/organizations/foo').to_s
+    end
+
+    context 'and is empty' do
+      when_the_repository 'is full of stuff' do
+        file 'nodes/x.json', {}
+        file 'roles/x.json', {}
+
+        it "Download grabs defaults" do
+          run_recipe do
+            chef_mirror '' do
+              action :download
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :download)
+          expect(File.exist?(path_to('groups/admins.json'))).to be true
+          expect(File.exist?(path_to('environments/_default.json'))).to be true
+        end
+
+        it "Upload uploads everything" do
+          run_recipe do
+            chef_mirror '' do
+              action :upload
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :upload)
+          expect { get('nodes/x') }.not_to raise_error
+          expect { get('roles/x') }.not_to raise_error
+        end
+
+        it 'chef_mirror with concurrency 0 fails with a reasonable message' do
+          expect {
+            run_recipe do
+              chef_mirror '' do
+                concurrency 0
+                action :download
+              end
+            end
+          }.to raise_error /chef_mirror.concurrency must be above 0/
+        end
+      end
+
+      when_the_repository 'has stuff but no chef_repo_path' do
+        file 'repo/nodes/x.json', {}
+        file 'repo/roles/x.json', {}
+        file 'repo2/nodes/y.json', {}
+        file 'repo2/roles/y.json', {}
+
+        before do
+          Chef::Config.delete(:chef_repo_path)
+          Chef::Config.delete(:node_path)
+          Chef::Config.delete(:cookbook_path)
+          Chef::Config.delete(:role_path)
+        end
+
+        it "Upload with chef_repo_path('repo') uploads everything" do
+          repo_path = path_to('repo')
+          run_recipe do
+            chef_mirror '' do
+              chef_repo_path repo_path
+              action :upload
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :upload)
+          expect { get('nodes/x') }.not_to raise_error
+          expect { get('roles/x') }.not_to raise_error
+          expect { get('nodes/y') }.to raise_error
+          expect { get('roles/y') }.to raise_error
+        end
+
+        it "Upload with chef_repo_path(:chef_repo_path) with multiple paths uploads everything" do
+          repo_path = path_to('repo')
+          repo2_path = path_to('repo2')
+          run_recipe do
+            chef_mirror '' do
+              chef_repo_path :chef_repo_path => [ repo_path, repo2_path ]
+              action :upload
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :upload)
+          expect { get('nodes/x') }.not_to raise_error
+          expect { get('roles/x') }.not_to raise_error
+          expect { get('nodes/y') }.not_to raise_error
+          expect { get('roles/y') }.not_to raise_error
+        end
+
+        it "Upload with chef_repo_path(:node_path, :role_path) uploads everything" do
+          repo_path = path_to('repo')
+          repo2_path = path_to('repo2')
+
+          run_recipe do
+            chef_mirror '' do
+              chef_repo_path :chef_repo_path => '/blahblah',
+                             :node_path => "#{repo_path}/nodes",
+                             :role_path => "#{repo2_path}/roles"
+              action :upload
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :upload)
+          expect { get('nodes/x') }.not_to raise_error
+          expect { get('roles/x') }.to raise_error
+          expect { get('nodes/y') }.to raise_error
+          expect { get('roles/y') }.not_to raise_error
+        end
+
+        it "Upload with chef_repo_path(:chef_repo_path, :role_path) uploads everything" do
+          repo_path = path_to('repo')
+          repo2_path = path_to('repo2')
+
+          run_recipe do
+            chef_mirror '' do
+              chef_repo_path :chef_repo_path => repo_path,
+                             :role_path => "#{repo2_path}/roles"
+              action :upload
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :upload)
+          expect { get('nodes/x') }.not_to raise_error
+          expect { get('roles/x') }.to raise_error
+          expect { get('nodes/y') }.to raise_error
+          expect { get('roles/y') }.not_to raise_error
+        end
+
+        it "Upload with chef_repo_path(:node_path, :role_path) with multiple paths uploads everything" do
+          repo_path = path_to('repo')
+          repo2_path = path_to('repo2')
+
+          run_recipe do
+            chef_mirror '' do
+              chef_repo_path :chef_repo_path => [ 'foo', 'bar' ],
+                             :node_path => [ "#{repo_path}/nodes", "#{repo2_path}/nodes" ],
+                             :role_path => [ "#{repo_path}/roles", "#{repo2_path}/roles" ]
+              action :upload
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :upload)
+          expect { get('nodes/x') }.not_to raise_error
+          expect { get('roles/x') }.not_to raise_error
+          expect { get('nodes/y') }.not_to raise_error
+          expect { get('roles/y') }.not_to raise_error
+        end
+      end
+    end
+
+    context 'and has stuff' do
+      node 'x', {}
+      role 'x', {}
+
+      when_the_repository 'is empty' do
+        it "Download grabs stuff" do
+          run_recipe do
+            chef_mirror '' do
+              action :download
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :download)
+          expect(File.exist?(path_to('nodes/x.json'))).to be true
+          expect(File.exist?(path_to('roles/x.json'))).to be true
+        end
+
+        it "Upload uploads nothing" do
+          run_recipe do
+            chef_mirror '' do
+              action :upload
+            end
+          end
+          expect(chef_run).not_to have_updated('chef_mirror[]', :upload)
+        end
+      end
+    end
+
+    context 'and has nodes and roles named x' do
+      node 'x', {}
+      role 'x', {}
+
+      when_the_repository 'has nodes and roles named y' do
+        file 'nodes/y.json', {}
+        file 'roles/y.json', {}
+
+        it "Download grabs the x's" do
+          run_recipe do
+            chef_mirror '' do
+              action :download
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :download)
+          expect(File.exist?(path_to('nodes/x.json'))).to be true
+          expect(File.exist?(path_to('roles/x.json'))).to be true
+          expect(File.exist?(path_to('nodes/y.json'))).to be true
+          expect(File.exist?(path_to('roles/y.json'))).to be true
+        end
+
+        it "Upload uploads the y's" do
+          run_recipe do
+            chef_mirror '' do
+              action :upload
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :upload)
+          expect { get('nodes/x') }.not_to raise_error
+          expect { get('roles/x') }.not_to raise_error
+          expect { get('nodes/y') }.not_to raise_error
+          expect { get('roles/y') }.not_to raise_error
+        end
+
+        it "Download with purge grabs the x's and deletes the y's" do
+          run_recipe do
+            chef_mirror '' do
+              purge true
+              action :download
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[]', :download)
+          expect(File.exist?(path_to('nodes/x.json'))).to be true
+          expect(File.exist?(path_to('roles/x.json'))).to be true
+        end
+
+        it "Upload with :purge uploads the y's and deletes the x's" do
+          run_recipe do
+            chef_mirror '*/*.json' do
+              purge true
+              action :upload
+            end
+          end
+          expect(chef_run).to have_updated('chef_mirror[*/*.json]', :upload)
+          expect { get('nodes/y') }.not_to raise_error
+          expect { get('roles/y') }.not_to raise_error
+        end
+      end
+    end
+
+  end
+end

data/spec/integration/chef_node_spec.rb

@@ -5,140 +5,162 @@ require 'chef/provider/chef_node'
 describe Chef::Resource::ChefNode do
   extend SpecSupport
 
-  when_the_chef_server 'is empty' do
-    context 'and we run a recipe that creates node "blah"' do
-      with_converge do
-        chef_node 'blah'
-      end
+  when_the_chef_server 'is in multi-org mode', :osc_compat => false, :single_org => false do
+    organization 'foo'
 
-      it 'the node gets created' do
-        expect(chef_run).to have_updated 'chef_node[blah]', :create
-        expect(get('/nodes/blah')['name']).to eq('blah')
-      end
+    before :each do
+      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, '/organizations/foo').to_s
     end
 
-    # TODO why-run mode
-
-    context 'and another chef server is running on port 8899' do
-      before :each do
-        @server = ChefZero::Server.new(:port => 8899)
-        @server.start_background
-      end
-
-      after :each do
-        @server.stop
-      end
-
-      context 'and a recipe is run that creates node "blah" on the second chef server using with_chef_server' do
-
+    context 'and is empty' do
+      context 'and we run a recipe that creates node "blah"' do
         with_converge do
-          with_chef_server 'http://127.0.0.1:8899'
           chef_node 'blah'
         end
 
-        it 'the node is created on the second chef server but not the first' do
+        it 'the node gets created' do
           expect(chef_run).to have_updated 'chef_node[blah]', :create
-          expect { get('/nodes/blah') }.to raise_error(Net::HTTPServerException)
-          expect(get('http://127.0.0.1:8899/nodes/blah')['name']).to eq('blah')
+          expect(get('nodes/blah')['name']).to eq('blah')
         end
       end
 
-      context 'and a recipe is run that creates node "blah" on the second chef server using chef_server' do
+      # TODO why-run mode
 
-        with_converge do
-          chef_node 'blah' do
-            chef_server({ :chef_server_url => 'http://127.0.0.1:8899' })
-          end
+      context 'and another chef server is running on port 8899' do
+        before :each do
+          @server = ChefZero::Server.new(:port => 8899)
+          @server.start_background
         end
 
-        it 'the node is created on the second chef server but not the first' do
-          expect(chef_run).to have_updated 'chef_node[blah]', :create
-          expect { get('/nodes/blah') }.to raise_error(Net::HTTPServerException)
-          expect(get('http://127.0.0.1:8899/nodes/blah')['name']).to eq('blah')
+        after :each do
+          @server.stop
         end
-      end
 
-    end
-  end
+        context 'and a recipe is run that creates node "blah" on the second chef server using with_chef_server' do
 
-  when_the_chef_server 'has a node named "blah"' do
-    node 'blah', {}
+          with_converge do
+            with_chef_server 'http://127.0.0.1:8899'
+            chef_node 'blah'
+          end
 
-    with_converge do
-      chef_node 'blah'
-    end
+          it 'the node is created on the second chef server but not the first' do
+            expect(chef_run).to have_updated 'chef_node[blah]', :create
+            expect { get('nodes/blah') }.to raise_error(Net::HTTPServerException)
+            expect(get('http://127.0.0.1:8899/nodes/blah')['name']).to eq('blah')
+          end
+        end
+
+        context 'and a recipe is run that creates node "blah" on the second chef server using chef_server' do
 
-    it 'chef_node "blah" does not get created or updated' do
-      expect(chef_run).not_to have_updated 'chef_node[blah]', :create
+          with_converge do
+            chef_node 'blah' do
+              chef_server({ :chef_server_url => 'http://127.0.0.1:8899' })
+            end
+          end
+
+          it 'the node is created on the second chef server but not the first' do
+            expect(chef_run).to have_updated 'chef_node[blah]', :create
+            expect { get('nodes/blah') }.to raise_error(Net::HTTPServerException)
+            expect(get('http://127.0.0.1:8899/nodes/blah')['name']).to eq('blah')
+          end
+        end
+      end
     end
-  end
 
-  when_the_chef_server 'has a node named "blah" with tags' do
-    node 'blah', {
-      'normal' => { 'tags' => [ 'a', 'b' ] }
-    }
+    context 'and has a node named "blah"' do
+      node 'blah', {}
 
-    context 'with chef_node "blah" that sets attributes' do
       with_converge do
-        chef_node 'blah' do
-          attributes({})
-        end
+        chef_node 'blah'
       end
 
-      it 'the tags in attributes are used' do
-        expect(get('/nodes/blah')['normal']['tags']).to eq([ 'a', 'b' ])
+      it 'chef_node "blah" does not get created or updated' do
+        expect(chef_run).not_to have_updated 'chef_node[blah]', :create
       end
     end
 
-    context 'with chef_node "blah" that sets attributes with tags in them' do
-      with_converge do
-        chef_node 'blah' do
-          attributes 'tags' => [ 'c', 'd' ]
+    context 'and has a node named "blah" with tags' do
+      node 'blah', {
+        'normal' => { 'tags' => [ 'a', 'b' ] }
+      }
+
+      context 'with chef_node "blah" that sets attributes' do
+        with_converge do
+          chef_node 'blah' do
+            attributes({})
+          end
+        end
+
+        it 'the tags in attributes are used' do
+          expect(get('nodes/blah')['normal']['tags']).to eq([ 'a', 'b' ])
         end
       end
 
-      it 'the tags in attributes are used' do
-        expect(get('/nodes/blah')['normal']['tags']).to eq([ 'c', 'd' ])
+      context 'with chef_node "blah" that sets attributes with tags in them' do
+        with_converge do
+          chef_node 'blah' do
+            attributes 'tags' => [ 'c', 'd' ]
+          end
+        end
+
+        it 'the tags in attributes are used' do
+          expect(get('nodes/blah')['normal']['tags']).to eq([ 'c', 'd' ])
+        end
       end
     end
-  end
 
-  when_the_chef_server 'has a node named "blah" with everything in it' do
-    node 'blah', {
-      'chef_environment' => 'blah',
-      'run_list'  => [ 'recipe[bjork]' ],
-      'normal'    => { 'foo' => 'bar', 'tags' => [ 'a', 'b' ] },
-      'default'   => { 'foo2' => 'bar2' },
-      'automatic' => { 'foo3' => 'bar3' },
-      'override'  => { 'foo4' => 'bar4' }
-    }
-
-    context 'with chef_node "blah"' do
-      with_converge do
-        chef_node 'blah'
+    context 'has a node named "blah" with everything in it' do
+      node 'blah', {
+        'chef_environment' => 'blah',
+        'run_list'  => [ 'recipe[bjork]' ],
+        'normal'    => { 'foo' => 'bar', 'tags' => [ 'a', 'b' ] },
+        'default'   => { 'foo2' => 'bar2' },
+        'automatic' => { 'foo3' => 'bar3' },
+        'override'  => { 'foo4' => 'bar4' }
+      }
+
+      context 'with chef_node "blah"' do
+        with_converge do
+          chef_node 'blah'
+        end
+
+        it 'nothing gets updated' do
+          expect(chef_run).not_to have_updated 'chef_node[blah]', :create
+        end
       end
 
-      it 'nothing gets updated' do
-        expect(chef_run).not_to have_updated 'chef_node[blah]', :create
+      context 'with chef_node "blah" with complete true' do
+        with_converge do
+          chef_node 'blah' do
+            complete true
+          end
+        end
+
+        it 'default, automatic and override attributes are left alone' do
+          expect(chef_run).to have_updated 'chef_node[blah]', :create
+          node = get('nodes/blah')
+          expect(node['chef_environment']).to eq('_default')
+          expect(node['run_list']).to eq([])
+          expect(node['normal']).to eq({ 'tags' => [ 'a', 'b' ] })
+          expect(node['default']).to eq({ 'foo2' => 'bar2' })
+          expect(node['automatic']).to eq({ 'foo3' => 'bar3' })
+          expect(node['override']).to eq({ 'foo4' => 'bar4' })
+        end
       end
     end
+  end
 
-    context 'with chef_node "blah" with complete true' do
-      with_converge do
-        chef_node 'blah' do
-          complete true
+  when_the_chef_server 'is in OSC mode' do
+    context 'and is empty' do
+      context 'and we run a recipe that creates node "blah"' do
+        with_converge do
+          chef_node 'blah'
         end
-      end
 
-      it 'default, automatic and override attributes are left alone' do
-        expect(chef_run).to have_updated 'chef_node[blah]', :create
-        node = get('/nodes/blah')
-        expect(node['chef_environment']).to eq('_default')
-        expect(node['run_list']).to eq([])
-        expect(node['normal']).to eq({ 'tags' => [ 'a', 'b' ] })
-        expect(node['default']).to eq({ 'foo2' => 'bar2' })
-        expect(node['automatic']).to eq({ 'foo3' => 'bar3' })
-        expect(node['override']).to eq({ 'foo4' => 'bar4' })
+        it 'the node gets created' do
+          expect(chef_run).to have_updated 'chef_node[blah]', :create
+          expect(get('nodes/blah')['name']).to eq('blah')
+        end
       end
     end
   end