Add organization, acl, group, container rspec macrosrspec_enterprise

3 files changed, 198 insertions, 44 deletions

diff --git a/lib/chef_zero/endpoints/acl_endpoint.rb b/lib/chef_zero/endpoints/acl_endpoint.rb
index 8e97344..f1c0013 100644
--- a/lib/chef_zero/endpoints/acl_endpoint.rb
+++ b/lib/chef_zero/endpoints/acl_endpoint.rb
@@ -16,9 +16,9 @@ module ChefZero
     # Where PERM is create,read,update,delete,grant
     class AclEndpoint < RestBase
       def validate_request(request)
-        path = request.rest_path[0..-3]
+        path = request.rest_path[0..-3] # Strip off _acl/PERM
         path = path[0..1] if path.size == 3 && path[0] == 'organizations' && %w(organization organizations).include?(path[2])
-        acl_path = ChefData::AclPath.get_acl_data_path(path) # Strip off _acl/PERM
+        acl_path = ChefData::AclPath.get_acl_data_path(path)
         perm = request.rest_path[-1]
         if !acl_path || !%w(read create update delete grant).include?(perm)
           raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
diff --git a/lib/chef_zero/rspec.rb b/lib/chef_zero/rspec.rb
index e67fdc2..6a78a78 100644
--- a/lib/chef_zero/rspec.rb
+++ b/lib/chef_zero/rspec.rb
@@ -24,6 +24,11 @@ module ChefZero
     end
 
     def when_the_chef_server(description, *tags, &block)
+      if tags.last.is_a?(Hash)
+        opts = tags.last
+      else
+        opts = {}
+      end
       context "When the Chef server #{description}", *tags do
         before :each do
 
@@ -33,6 +38,7 @@ module ChefZero
           else
             default_opts
           end
+          server_opts = server_opts.merge(opts)
 
           if ChefZero::RSpec.server && server_opts != ChefZero::RSpec.server.options
             ChefZero::RSpec.server.stop
@@ -77,79 +83,194 @@ module ChefZero
           end
         end
 
-        def self.organization(name, org = '{}')
-          before(:each) do
-            ChefZero::RSpec.server.data_store.set([ 'organizations', name, 'org' ], dejsonize(org), :create_dir, :create)
-            @current_org = name
+        def self.organization(name, org = '{}', &block)
+          before(:each) { organization(name, org, &block) }
+        end
+
+        def organization(name, org = '{}', &block)
+          ChefZero::RSpec.server.data_store.set([ 'organizations', name, 'org' ], dejsonize(org), :create_dir, :create)
+          prev_org_name = @current_org
+          @current_org = name
+          prev_object_path = @current_object_path
+          @current_object_path = "organizations/#{name}"
+          if block_given?
+            begin
+              instance_eval(&block)
+            ensure
+              @current_org = prev_org_name
+              @current_object_path = prev_object_path
+            end
           end
         end
 
-        def self.acl(path, acl)
-          before(:each) do
-            path = [ 'organizations', @current_org || 'chef' ] + path.split('/')
-            ChefZero::RSpec.server.data_store.set(ChefData::AclPath.get_acl_data_path(path), acl)
+        def self.acl_for(path, data)
+          before(:each) { acl_for(path, data) }
+        end
+
+        def acl_for(path, data)
+          ChefZero::RSpec.server.load_data({ 'acls' => { path => data } }, current_org)
+        end
+
+        def acl(data)
+          acl_for(@current_object_path, data)
+        end
+
+        def self.client(name, data, &block)
+          before(:each) { client(name, data, &block) }
+        end
+
+        def client(name, data, &block)
+          with_object_path("clients/#{name}") do
+            ChefZero::RSpec.server.load_data({ 'clients' => { name => data } }, current_org)
+            instance_eval(&block) if block_given?
           end
         end
 
-        def self.group(name, group)
-          before(:each) do
-            path = [ 'organizations', @current_org || 'chef' ] + path.split('/')
-            ChefZero::RSpec.server.data_store.set([ 'organizations', @current_org || 'chef', 'groups', name ], dejsonize(group), :create)
+        def self.container(name, data, &block)
+          before(:each) { container(name, data, &block) }
+        end
+
+        def container(name, data, &block)
+          with_object_path("containers/#{name}") do
+            ChefZero::RSpec.server.load_data({ 'containers' => { name => data } }, current_org)
+            instance_eval(&block) if block_given?
           end
         end
 
-        def self.org_invite(username)
-          before(:each) do
-            ChefZero::RSpec.server.data_store.set([ 'organizations', @current_org || 'chef', 'users', username ], '{}', :create)
+        def self.cookbook(name, version, data, options = {}, &block)
+          before(:each) { cookbook(name, version, data, &block) }
+        end
+
+        def cookbook(name, version, data, options = {}, &block)
+          with_object_path("cookbooks/#{name}") do
+            ChefZero::RSpec.server.load_data({ 'cookbooks' => { "#{name}-#{version}" => data.merge(options) }}, current_org)
+            instance_eval(&block) if block_given?
           end
         end
 
-        def self.org_members(name, *members)
-          before(:each) do
-            members.each do |member|
-              ChefZero::RSpec.server.set([ 'organizations', @current_org || 'chef', 'users', member], '{}')
-            end
+        def self.data_bag(name, data, &block)
+          before(:each) { data_bag(name, data, &block) }
+        end
+
+        def data_bag(name, data, &block)
+          with_object_path("data/#{name}") do
+            ChefZero::RSpec.server.load_data({ 'data' => { name => data }}, current_org)
+            instance_eval(&block) if block_given?
           end
         end
 
-        def self.client(name, client)
-          before(:each) { ChefZero::RSpec.server.load_data({ 'clients' => { name => client }}, @current_org) }
+        def self.environment(name, data, &block)
+          before(:each) { environment(name, data, &block) }
         end
 
-        def self.cookbook(name, version, cookbook, options = {})
-          before(:each) { ChefZero::RSpec.server.load_data({ 'cookbooks' => { "#{name}-#{version}" => cookbook.merge(options) }}, @current_org) }
+        def environment(name, data, &block)
+          with_object_path("environments/#{name}") do
+            ChefZero::RSpec.server.load_data({ 'environments' => { name => data } }, current_org)
+            instance_eval(&block) if block_given?
+          end
+        end
+
+        def self.group(name, data, &block)
+          before(:each) { group(name, data, &block) }
         end
 
-        def self.data_bag(name, data_bag)
-          before(:each) { ChefZero::RSpec.server.load_data({ 'data' => { name => data_bag }}, @current_org) }
+        def group(name, data, &block)
+          with_object_path("groups/#{name}") do
+            ChefZero::RSpec.server.load_data({ 'groups' => { name => data } }, current_org)
+            instance_eval(&block) if block_given?
+          end
         end
 
-        def self.environment(name, environment)
-          before(:each) { ChefZero::RSpec.server.load_data({ 'environments' => { name => environment }}, @current_org) }
+        def self.node(name, data, &block)
+          before(:each) { node(name, data, &block) }
         end
 
-        def self.node(name, node)
-          before(:each) { ChefZero::RSpec.server.load_data({ 'nodes' => { name => node }}, @current_org) }
+        def node(name, data, &block)
+          with_object_path("nodes/#{name}") do
+            ChefZero::RSpec.server.load_data({ 'nodes' => { name => data } }, current_org)
+            instance_eval(&block) if block_given?
+          end
         end
 
-        def self.role(name, role)
-          before(:each) { ChefZero::RSpec.server.load_data({ 'roles' => { name => role }}, @current_org) }
+        def self.org_invite(*usernames)
+          before(:each) { org_invite(*usernames) }
         end
 
-        def self.user(name, user)
+        def org_invite(*usernames)
+          ChefZero::RSpec.server.load_data({ 'invites' => usernames }, current_org)
+        end
+
+        def self.org_member(*usernames)
+          before(:each) { org_member(*usernames) }
+        end
+
+        def org_member(*usernames)
+          ChefZero::RSpec.server.load_data({ 'members' => usernames }, current_org)
+        end
+
+        def self.role(name, data, &block)
+          before(:each) { role(name, data, &block) }
+        end
+
+        def role(name, data, &block)
+          with_object_path("roles/#{name}") do
+            ChefZero::RSpec.server.load_data({ 'roles' => { name => data } }, current_org)
+            instance_eval(&block) if block_given?
+          end
+        end
+
+        def self.sandbox(name, data, &block)
+          before(:each) { sandbox(name, data, &block) }
+        end
+
+        def sandbox(name, data, &block)
+          with_object_path("sandboxes/#{name}") do
+            ChefZero::RSpec.server.load_data({ 'sandboxes' => { name => data } }, current_org)
+            instance_eval(&block) if block_given?
+          end
+        end
+
+        def self.user(name, data, &block)
+          before(:each) { user(name, data, &block) }
+        end
+
+        def user(name, data, &block)
           if ChefZero::RSpec.server.options[:osc_compat]
-            before(:each) { ChefZero::RSpec.server.load_data({ 'users' => { name => user }}, @current_org) }
+            with_object_path("users/#{name}") do
+              ChefZero::RSpec.server.load_data({ 'users' => { name => data }}, current_org)
+              instance_eval(&block) if block_given?
+            end
           else
-            before(:each) { ChefZero::RSpec.server.set([ 'users', name ], dejsonize(user)) }
+            old_object_path = @current_object_path
+            @current_object_path = "users/#{name}"
+            begin
+              ChefZero::RSpec.server.load_data({ 'users' => { name => data }}, current_org)
+              instance_eval(&block) if block_given?
+            ensure
+              @current_object_path = old_object_path
+            end
           end
         end
 
-        def self.dejsonize(data)
+        def dejsonize(data)
           if data.is_a?(String)
             data
           else
-            JSON.pretty_generate(value)
+            JSON.pretty_generate(data)
+          end
+        end
+
+        def current_org
+          @current_org || 'chef'
+        end
+
+        def with_object_path(object_path)
+          old_object_path = @current_object_path
+          @current_object_path = object_path
+          begin
+            yield if block_given?
           end
+          @current_object_path = old_object_path
         end
 
 #        after :each do
diff --git a/lib/chef_zero/server.rb b/lib/chef_zero/server.rb
index dc8fe7f..e4c5aab 100644
--- a/lib/chef_zero/server.rb
+++ b/lib/chef_zero/server.rb
@@ -28,6 +28,7 @@ require 'webrick/https'
 
 require 'chef_zero'
 require 'chef_zero/chef_data/cookbook_data'
+require 'chef_zero/chef_data/acl_path'
 require 'chef_zero/rest_router'
 require 'chef_zero/data_store/memory_store_v2'
 require 'chef_zero/data_store/v1_to_v2_adapter'
@@ -99,7 +100,6 @@ module ChefZero
         @options[:osc_compat] = true
       end
       @options.freeze
-
       ChefZero::Log.level = @options[:log_level].to_sym
     end
 
@@ -357,13 +357,42 @@ module ChefZero
     #   }
     # }
     def load_data(contents, org_name = 'chef')
-      %w(clients environments nodes roles users).each do |data_type|
+      %w(clients containers environments groups nodes roles sandboxes).each do |data_type|
         if contents[data_type]
           dejsonize_children(contents[data_type]).each_pair do |name, data|
             data_store.set(['organizations', org_name, data_type, name], data, :create)
           end
         end
       end
+      if contents['users']
+        dejsonize_children(contents['users']).each_pair do |name, data|
+          if options[:osc_compat]
+            data_store.set(['organizations', org_name, 'users', name], data, :create)
+          else
+            # Create the user and put them in the org
+            data_store.set(['users', name], data, :create)
+            data_store.set(['organizations', org_name, 'users', name], '{}', :create)
+          end
+        end
+      end
+
+      if contents['members']
+        contents['members'].each do |name|
+          data_store.set(['organizations', org_name, 'users', name], '{}', :create)
+        end
+      end
+      if contents['invites']
+        contents['invites'].each do |name|
+          data_store.set(['organizations', org_name, 'association_requests', "#{current_org}-#{username}"], '{}', :create)
+        end
+      end
+      if contents['acls']
+        dejsonize_children(contents['acls']).each do |path, acl|
+          path = [ 'organizations', org_name ] + path.split('/')
+          path = ChefData::AclPath.get_acl_data_path(path)
+          ChefZero::RSpec.server.data_store.set(path, acl)
+        end
+      end
       if contents['data']
         contents['data'].each_pair do |key, data_bag|
           data_store.create_dir(['organizations', org_name, 'data'], key, :recursive)
@@ -425,8 +454,8 @@ module ChefZero
           [ "/organizations/*/users/*", OrganizationUserEndpoint.new(self) ],
           [ "/users", ActorsEndpoint.new(self, 'username') ],
           [ "/users/*", ActorEndpoint.new(self, 'username') ],
-          [ "/users/_acl", AclsEndpoint.new(self) ],
-          [ "/users/_acl/*", AclEndpoint.new(self) ],
+          [ "/users/*/_acl", AclsEndpoint.new(self) ],
+          [ "/users/*/_acl/*", AclEndpoint.new(self) ],
           [ "/users/*/association_requests", UserAssociationRequestsEndpoint.new(self) ],
           [ "/users/*/association_requests/count", UserAssociationRequestsCountEndpoint.new(self) ],
           [ "/users/*/association_requests/*", UserAssociationRequestEndpoint.new(self) ],
@@ -533,11 +562,15 @@ module ChefZero
     def dejsonize_children(hash)
       result = {}
       hash.each_pair do |key, value|
-        result[key] = value.is_a?(Hash) ? JSON.pretty_generate(value) : value
+        result[key] = dejsonize(value)
       end
       result
     end
 
+    def dejsonize(value)
+      value.is_a?(Hash) ? JSON.pretty_generate(value) : value
+    end
+
     def get_file(directory, path)
       value = directory
       path.split('/').each do |part|