chef 16.10.8-universal-mingw32 → 17.0.242-universal-mingw32

data/spec/functional/resource/windows_service_spec.rb

@@ -1,105 +0,0 @@
-#
-# Author:: Chris Doherty (<cdoherty@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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 "spec_helper"
-
-describe Chef::Resource::WindowsService, :windows_only, :system_windows_service_gem_only do
-
-  include_context "using Win32::Service"
-
-  let(:username) { "service_spec_user" }
-  let(:qualified_username) { "#{ENV["COMPUTERNAME"]}\\#{username}" }
-  let(:password) { "1a2b3c4X!&narf" }
-
-  let(:user_resource) do
-    r = Chef::Resource::User::WindowsUser.new(username, run_context)
-    r.username(username)
-    r.password(password)
-    r.comment("temp spec user")
-    r
-  end
-
-  let(:global_service_file_path) do
-    "#{ENV["WINDIR"]}\\temp\\#{File.basename(test_service[:service_file_path])}"
-  end
-
-  let(:service_params) do
-
-    id = "#{$$}_#{rand(1000)}"
-
-    test_service.merge( {
-      run_as_user: qualified_username,
-      run_as_password: password,
-      service_name: "spec_service_#{id}",
-      service_display_name: "windows_service spec #{id}}",
-      service_description: "Test service for running the windows_service functional spec.",
-      service_file_path: global_service_file_path,
-      } )
-  end
-
-  let(:manager) do
-    Chef::Application::WindowsServiceManager.new(service_params)
-  end
-
-  let(:service_resource) do
-    r = Chef::Resource::WindowsService.new(service_params[:service_name], run_context)
-    %i{run_as_user run_as_password}.each { |prop| r.send(prop, service_params[prop]) }
-    r
-  end
-
-  let(:run_context) do
-    Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
-  end
-
-  before do
-    user_resource.run_action(:create)
-
-    # the service executable has to be outside the current user's home
-    # directory in order for the logon user to execute it.
-    FileUtils.copy_file(test_service[:service_file_path], global_service_file_path)
-
-    # if you don't make the file executable by the service user, you'll get
-    # the not-very-helpful "service did not respond fast enough" error.
-
-    # #mode may break in a post-Windows 8.1 release, and have to be replaced
-    # with the rights stuff in the file resource.
-    file = Chef::Resource::File.new(global_service_file_path, run_context)
-    file.mode("0777")
-
-    file.run_action(:create)
-
-    manager.run(%w{--action install})
-  end
-
-  after do
-    user_resource.run_action(:remove)
-    manager.run(%w{--action uninstall})
-    File.delete(global_service_file_path)
-  end
-
-  describe "logon as a service" do
-    it "successfully runs a service as another user" do
-      service_resource.run_action(:start)
-    end
-
-    it "grants the user the log on as service right" do
-      service_resource.run_action(:start)
-      expect(Chef::ReservedNames::Win32::Security.get_account_right(qualified_username)).to include("SeServiceLogonRight")
-    end
-  end
-end

data/spec/functional/win32/service_manager_spec.rb

@@ -1,220 +0,0 @@
-#
-# Author:: Serdar Sutay (<serdar@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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 "spec_helper"
-if ChefUtils.windows?
-  require "chef/application/windows_service_manager"
-end
-
-#
-# ATTENTION:
-# This test creates a windows service for testing purposes and runs it
-# as Local System (or an otherwise specified user) on windows boxes.
-# This test will fail if you run the tests inside a Windows VM by
-# sharing the code from your host since Local System account by
-# default can't see the mounted partitions.
-# Run this test by copying the code to a local VM directory or setup
-# Local System account to see the maunted partitions for the shared
-# directories.
-#
-
-describe "Chef::Application::WindowsServiceManager", :windows_only, :system_windows_service_gem_only do
-
-  include_context "using Win32::Service"
-
-  context "with invalid service definition" do
-    it "throws an error when initialized with no service definition" do
-      expect { Chef::Application::WindowsServiceManager.new(nil) }.to raise_error(ArgumentError)
-    end
-
-    it "throws an error with required missing options" do
-      %i{service_name service_display_name service_description service_file_path}.each do |key|
-        service_def = test_service.dup
-        service_def.delete(key)
-
-        expect { Chef::Application::WindowsServiceManager.new(service_def) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  context "with valid definition" do
-    before(:each) do
-      @service_manager_output = [ ]
-      # Uncomment below lines to debug this test
-      # original_puts = $stdout.method(:puts)
-      allow($stdout).to receive(:puts) do |message|
-        @service_manager_output << message
-        # original_puts.call(message)
-      end
-    end
-
-    after(:each) do
-      cleanup
-    end
-
-    context "when service doesn't exist" do
-      it "default => should say service don't exist" do
-        service_manager.run
-
-        expect(@service_manager_output.grep(/doesn't exist on the system/).length).to be > 0
-      end
-
-      it "install => should install the service" do
-        service_manager.run(["-a", "install"])
-
-        expect(test_service_exists?).to be_truthy
-      end
-
-      it "other actions => should say service doesn't exist" do
-        %w{delete start stop pause resume uninstall}.each do |action|
-          service_manager.run(["-a", action])
-          expect(@service_manager_output.grep(/doesn't exist on the system/).length).to be > 0
-          @service_manager_output = [ ]
-        end
-      end
-    end
-
-    context "when service exists" do
-      before(:each) do
-        service_manager.run(["-a", "install"])
-      end
-
-      it "should have an own-process, non-interactive type" do
-        status = ::Win32::Service.status("spec-service")
-        expect(status[:service_type]).to eq("own process")
-        expect(status[:interactive]).to be_falsey
-      end
-
-      it "install => should say service already exists" do
-        service_manager.run(["-a", "install"])
-        expect(@service_manager_output.grep(/already exists/).length).to be > 0
-      end
-
-      context "and service is stopped" do
-        %w{delete uninstall}.each do |action|
-          it "#{action} => should remove the service", :volatile do
-            service_manager.run(["-a", action])
-            expect(test_service_exists?).to be_falsey
-          end
-        end
-
-        it "default, status => should say service is stopped" do
-          service_manager.run([ ])
-          expect(@service_manager_output.grep(/stopped/).length).to be > 0
-          @service_manager_output = [ ]
-
-          service_manager.run(["-a", "status"])
-          expect(@service_manager_output.grep(/stopped/).length).to be > 0
-        end
-
-        it "start should start the service", :volatile do
-          service_manager.run(["-a", "start"])
-          expect(test_service_state).to eq("running")
-          expect(File.exist?(test_service_file)).to be_truthy
-        end
-
-        it "stop should not affect the service" do
-          service_manager.run(["-a", "stop"])
-          expect(test_service_state).to eq("stopped")
-        end
-
-        %w{pause resume}.each do |action|
-          it "#{action} => should raise error" do
-            expect { service_manager.run(["-a", action]) }.to raise_error(SystemCallError)
-          end
-        end
-
-        context "and service is started", :volatile do
-          before(:each) do
-            service_manager.run(["-a", "start"])
-          end
-
-          %w{delete uninstall}.each do |action|
-            it "#{action} => should remove the service", :volatile do
-              service_manager.run(["-a", action])
-              expect(test_service_exists?).to be_falsey
-            end
-          end
-
-          it "default, status => should say service is running" do
-            service_manager.run([ ])
-            expect(@service_manager_output.grep(/running/).length).to be > 0
-            @service_manager_output = [ ]
-
-            service_manager.run(["-a", "status"])
-            expect(@service_manager_output.grep(/running/).length).to be > 0
-          end
-
-          it "stop should stop the service" do
-            service_manager.run(["-a", "stop"])
-            expect(test_service_state).to eq("stopped")
-          end
-
-          it "pause should pause the service" do
-            service_manager.run(["-a", "pause"])
-            expect(test_service_state).to eq("paused")
-          end
-
-          it "resume should have no affect" do
-            service_manager.run(["-a", "resume"])
-            expect(test_service_state).to eq("running")
-          end
-        end
-
-        context "and service is paused", :volatile do
-          before(:each) do
-            service_manager.run(["-a", "start"])
-            service_manager.run(["-a", "pause"])
-          end
-
-          actions = %w{delete uninstall}
-          actions.each do |action|
-            it "#{action} => should remove the service" do
-              service_manager.run(["-a", action])
-              expect(test_service_exists?).to be_falsey
-            end
-          end
-
-          it "default, status => should say service is paused" do
-            service_manager.run([ ])
-            expect(@service_manager_output.grep(/paused/).length).to be > 0
-            @service_manager_output = [ ]
-
-            service_manager.run(["-a", "status"])
-            expect(@service_manager_output.grep(/paused/).length).to be > 0
-          end
-
-          it "stop should stop the service" do
-            service_manager.run(["-a", "stop"])
-            expect(test_service_state).to eq("stopped")
-          end
-
-          it "pause should not affect the service" do
-            service_manager.run(["-a", "pause"])
-            expect(test_service_state).to eq("paused")
-          end
-
-          it "start should raise an error" do
-            expect { service_manager.run(["-a", "start"]) }.to raise_error(::Win32::Service::Error)
-          end
-
-        end
-      end
-    end
-  end
-end

data/spec/integration/knife/chef_fs_data_store_spec.rb

@@ -1,557 +0,0 @@
-#
-# Author:: John Keiser (<jkeiser@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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 "spec_helper"
-require "support/shared/integration/integration_helper"
-require "chef/knife/list"
-require "chef/knife/delete"
-require "chef/knife/show"
-require "chef/knife/raw"
-require "chef/knife/cookbook_upload"
-
-describe "ChefFSDataStore tests", :workstation do
-  include IntegrationSupport
-  include KnifeSupport
-
-  let(:cookbook_x_100_metadata_rb) { cb_metadata("x", "1.0.0") }
-  let(:cookbook_z_100_metadata_rb) { cb_metadata("z", "1.0.0") }
-
-  describe "with repo mode 'hosted_everything' (default)" do
-    before do
-      Chef::Config.chef_zero.osc_compat = false
-    end
-
-    when_the_repository "has one of each thing" do
-      before do
-        file "clients/x.json", {}
-        file "cookbook_artifacts/x-111/metadata.rb", cookbook_x_100_metadata_rb
-        file "cookbooks/x/metadata.rb", cookbook_x_100_metadata_rb
-        file "data_bags/x/y.json", {}
-        file "environments/x.json", {}
-        file "nodes/x.json", {}
-        file "roles/x.json", {}
-        # file "users/x.json", {}
-        file "containers/x.json", {}
-        file "groups/x.json", {}
-        file "containers/x.json", {}
-        file "groups/x.json", {}
-        file "policies/x-111.json", {}
-        file "policy_groups/x.json", {}
-      end
-
-      context "GET /TYPE" do
-        it "knife list -z -R returns everything" do
-          knife("list -z -Rfp /").should_succeed <<~EOM
-            /acls/
-            /acls/clients/
-            /acls/clients/x.json
-            /acls/containers/
-            /acls/containers/x.json
-            /acls/cookbook_artifacts/
-            /acls/cookbook_artifacts/x.json
-            /acls/cookbooks/
-            /acls/cookbooks/x.json
-            /acls/data_bags/
-            /acls/data_bags/x.json
-            /acls/environments/
-            /acls/environments/x.json
-            /acls/groups/
-            /acls/groups/x.json
-            /acls/nodes/
-            /acls/nodes/x.json
-            /acls/organization.json
-            /acls/policies/
-            /acls/policies/x.json
-            /acls/policy_groups/
-            /acls/policy_groups/x.json
-            /acls/roles/
-            /acls/roles/x.json
-            /clients/
-            /clients/x.json
-            /containers/
-            /containers/x.json
-            /cookbook_artifacts/
-            /cookbook_artifacts/x-111/
-            /cookbook_artifacts/x-111/metadata.rb
-            /cookbooks/
-            /cookbooks/x/
-            /cookbooks/x/metadata.rb
-            /data_bags/
-            /data_bags/x/
-            /data_bags/x/y.json
-            /environments/
-            /environments/x.json
-            /groups/
-            /groups/x.json
-            /invitations.json
-            /members.json
-            /nodes/
-            /nodes/x.json
-            /org.json
-            /policies/
-            /policies/x-111.json
-            /policy_groups/
-            /policy_groups/x.json
-            /roles/
-            /roles/x.json
-          EOM
-        end
-      end
-
-      context "DELETE /TYPE/NAME" do
-        it "knife delete -z /clients/x.json works" do
-          knife("delete -z /clients/x.json").should_succeed "Deleted /clients/x.json\n"
-          knife("list -z -Rfp /clients").should_succeed ""
-        end
-
-        it "knife delete -z -r /cookbooks/x works" do
-          knife("delete -z -r /cookbooks/x").should_succeed "Deleted /cookbooks/x\n"
-          knife("list -z -Rfp /cookbooks").should_succeed ""
-        end
-
-        it "knife delete -z -r /data_bags/x works" do
-          knife("delete -z -r /data_bags/x").should_succeed "Deleted /data_bags/x\n"
-          knife("list -z -Rfp /data_bags").should_succeed ""
-        end
-
-        it "knife delete -z /data_bags/x/y.json works" do
-          knife("delete -z /data_bags/x/y.json").should_succeed "Deleted /data_bags/x/y.json\n"
-          knife("list -z -Rfp /data_bags").should_succeed "/data_bags/x/\n"
-        end
-
-        it "knife delete -z /environments/x.json works" do
-          knife("delete -z /environments/x.json").should_succeed "Deleted /environments/x.json\n"
-          knife("list -z -Rfp /environments").should_succeed ""
-        end
-
-        it "knife delete -z /nodes/x.json works" do
-          knife("delete -z /nodes/x.json").should_succeed "Deleted /nodes/x.json\n"
-          knife("list -z -Rfp /nodes").should_succeed ""
-        end
-
-        it "knife delete -z /roles/x.json works" do
-          knife("delete -z /roles/x.json").should_succeed "Deleted /roles/x.json\n"
-          knife("list -z -Rfp /roles").should_succeed ""
-        end
-
-      end
-
-      context "GET /TYPE/NAME" do
-        it "knife show -z /clients/x.json works" do
-          knife("show -z /clients/x.json").should_succeed( /"x"/ )
-        end
-
-        it "knife show -z /cookbooks/x/metadata.rb works" do
-          knife("show -z /cookbooks/x/metadata.rb").should_succeed "/cookbooks/x/metadata.rb:\n#{cookbook_x_100_metadata_rb}\n"
-        end
-
-        it "knife show -z /data_bags/x/y.json works" do
-          knife("show -z /data_bags/x/y.json").should_succeed( /"y"/ )
-        end
-
-        it "knife show -z /environments/x.json works" do
-          knife("show -z /environments/x.json").should_succeed( /"x"/ )
-        end
-
-        it "knife show -z /nodes/x.json works" do
-          knife("show -z /nodes/x.json").should_succeed( /"x"/ )
-        end
-
-        it "knife show -z /roles/x.json works" do
-          knife("show -z /roles/x.json").should_succeed( /"x"/ )
-        end
-
-      end
-
-      context "PUT /TYPE/NAME" do
-        before do
-          file "empty.json", {}
-          file "dummynode.json", { "name" => "x", "chef_environment" => "rspec" , "json_class" => "Chef::Node", "normal" => { "foo" => "bar" } }
-          file "rolestuff.json", '{"description":"hi there","name":"x"}'
-          file "cookbooks_to_upload/x/metadata.rb", cookbook_x_100_metadata_rb
-        end
-
-        it "knife raw -z -i empty.json -m PUT /clients/x" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /clients/x").should_succeed( /"x"/ )
-          knife("list --local /clients").should_succeed "/clients/x.json\n"
-        end
-
-        it "knife cookbook upload works" do
-          knife("cookbook upload -z --cookbook-path #{path_to("cookbooks_to_upload")} x").should_succeed stderr: <<~EOM
-            Uploading x              [1.0.0]
-            Uploaded 1 cookbook.
-          EOM
-          knife("list --local -Rfp /cookbooks").should_succeed "/cookbooks/x/\n/cookbooks/x/metadata.json\n/cookbooks/x/metadata.rb\n"
-        end
-
-        it "knife raw -z -i empty.json -m PUT /data/x/y" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /data/x/y").should_succeed( /"y"/ )
-          knife("list --local -Rfp /data_bags").should_succeed "/data_bags/x/\n/data_bags/x/y.json\n"
-        end
-
-        it "knife raw -z -i empty.json -m PUT /environments/x" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /environments/x").should_succeed( /"x"/ )
-          knife("list --local /environments").should_succeed "/environments/x.json\n"
-        end
-
-        it "knife raw -z -i dummynode.json -m PUT /nodes/x" do
-          knife("raw -z -i #{path_to("dummynode.json")} -m PUT /nodes/x").should_succeed( /"x"/ )
-          knife("list --local /nodes").should_succeed "/nodes/x.json\n"
-          knife("show -z /nodes/x.json --verbose").should_succeed(/"bar"/)
-        end
-
-        it "knife raw -z -i empty.json -m PUT /roles/x" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /roles/x").should_succeed( /"x"/ )
-          knife("list --local /roles").should_succeed "/roles/x.json\n"
-        end
-
-        it "After knife raw -z -i rolestuff.json -m PUT /roles/x, the output is pretty" do
-          knife("raw -z -i #{path_to("rolestuff.json")} -m PUT /roles/x").should_succeed( /"x"/ )
-          expect(IO.read(path_to("roles/x.json"))).to eq <<~EOM.strip
-            {
-              "name": "x",
-              "description": "hi there"
-            }
-          EOM
-        end
-      end
-    end
-
-    when_the_repository "is empty" do
-      context "POST /TYPE/NAME" do
-        before do
-          file "empty.json", { "name" => "z" }
-          file "dummynode.json", { "name" => "z", "chef_environment" => "rspec" , "json_class" => "Chef::Node", "normal" => { "foo" => "bar" } }
-          file "empty_x.json", { "name" => "x" }
-          file "empty_id.json", { "id" => "z" }
-          file "rolestuff.json", '{"description":"hi there","name":"x"}'
-          file "cookbooks_to_upload/z/metadata.rb", cookbook_z_100_metadata_rb
-        end
-
-        it "knife raw -z -i empty.json -m POST /clients" do
-          knife("raw -z -i #{path_to("empty.json")} -m POST /clients").should_succeed( /uri/ )
-          knife("list --local /clients").should_succeed "/clients/z.json\n"
-        end
-
-        it "knife cookbook upload works" do
-          knife("cookbook upload -z --cookbook-path #{path_to("cookbooks_to_upload")} z").should_succeed stderr: <<~EOM
-            Uploading z            [1.0.0]
-            Uploaded 1 cookbook.
-          EOM
-          knife("list --local -Rfp /cookbooks").should_succeed "/cookbooks/z/\n/cookbooks/z/metadata.json\n/cookbooks/z/metadata.rb\n"
-        end
-
-        it "knife raw -z -i empty.json -m POST /data" do
-          knife("raw -z -i #{path_to("empty.json")} -m POST /data").should_succeed( /uri/ )
-          knife("list --local -Rfp /data_bags").should_succeed "/data_bags/z/\n"
-        end
-
-        it "knife raw -z -i empty.json -m POST /data/x" do
-          knife("raw -z -i #{path_to("empty_x.json")} -m POST /data").should_succeed( /uri/ )
-          knife("raw -z -i #{path_to("empty_id.json")} -m POST /data/x").should_succeed( /"z"/ )
-          knife("list --local -Rfp /data_bags").should_succeed "/data_bags/x/\n/data_bags/x/z.json\n"
-        end
-
-        it "knife raw -z -i empty.json -m POST /environments" do
-          knife("raw -z -i #{path_to("empty.json")} -m POST /environments").should_succeed( /uri/ )
-          knife("list --local /environments").should_succeed "/environments/z.json\n"
-        end
-
-        it "knife raw -z -i dummynode.json -m POST /nodes" do
-          knife("raw -z -i #{path_to("dummynode.json")} -m POST /nodes").should_succeed( /uri/ )
-          knife("list --local /nodes").should_succeed "/nodes/z.json\n"
-          knife("show -z /nodes/z.json").should_succeed(/"bar"/)
-        end
-
-        it "knife raw -z -i empty.json -m POST /roles" do
-          knife("raw -z -i #{path_to("empty.json")} -m POST /roles").should_succeed( /uri/ )
-          knife("list --local /roles").should_succeed "/roles/z.json\n"
-        end
-
-        it "After knife raw -z -i rolestuff.json -m POST /roles, the output is pretty" do
-          knife("raw -z -i #{path_to("rolestuff.json")} -m POST /roles").should_succeed( /uri/ )
-          expect(IO.read(path_to("roles/x.json"))).to eq <<~EOM.strip
-            {
-              "name": "x",
-              "description": "hi there"
-            }
-          EOM
-        end
-      end
-
-      it "knife list -z -R returns nothing" do
-        knife("list -z -Rfp /").should_succeed <<~EOM
-          /acls/
-          /acls/clients/
-          /acls/containers/
-          /acls/cookbook_artifacts/
-          /acls/cookbooks/
-          /acls/data_bags/
-          /acls/environments/
-          /acls/groups/
-          /acls/nodes/
-          /acls/organization.json
-          /acls/policies/
-          /acls/policy_groups/
-          /acls/roles/
-          /clients/
-          /containers/
-          /cookbook_artifacts/
-          /cookbooks/
-          /data_bags/
-          /environments/
-          /groups/
-          /invitations.json
-          /members.json
-          /nodes/
-          /org.json
-          /policies/
-          /policy_groups/
-          /roles/
-        EOM
-      end
-
-      context "DELETE /TYPE/NAME" do
-        it "knife delete -z /clients/x.json fails with an error" do
-          knife("delete -z /clients/x.json").should_fail "ERROR: /clients/x.json: No such file or directory\n"
-        end
-
-        it "knife delete -z -r /cookbooks/x fails with an error" do
-          knife("delete -z -r /cookbooks/x").should_fail "ERROR: /cookbooks/x: No such file or directory\n"
-        end
-
-        it "knife delete -z -r /data_bags/x fails with an error" do
-          knife("delete -z -r /data_bags/x").should_fail "ERROR: /data_bags/x: No such file or directory\n"
-        end
-
-        it "knife delete -z /data_bags/x/y.json fails with an error" do
-          knife("delete -z /data_bags/x/y.json").should_fail "ERROR: /data_bags/x/y.json: No such file or directory\n"
-        end
-
-        it "knife delete -z /environments/x.json fails with an error" do
-          knife("delete -z /environments/x.json").should_fail "ERROR: /environments/x.json: No such file or directory\n"
-        end
-
-        it "knife delete -z /nodes/x.json fails with an error" do
-          knife("delete -z /nodes/x.json").should_fail "ERROR: /nodes/x.json: No such file or directory\n"
-        end
-
-        it "knife delete -z /roles/x.json fails with an error" do
-          knife("delete -z /roles/x.json").should_fail "ERROR: /roles/x.json: No such file or directory\n"
-        end
-
-      end
-
-      context "GET /TYPE/NAME" do
-        it "knife show -z /clients/x.json fails with an error" do
-          knife("show -z /clients/x.json").should_fail "ERROR: /clients/x.json: No such file or directory\n"
-        end
-
-        it "knife show -z /cookbooks/x/metadata.rb fails with an error" do
-          knife("show -z /cookbooks/x/metadata.rb").should_fail "ERROR: /cookbooks/x/metadata.rb: No such file or directory\n"
-        end
-
-        it "knife show -z /data_bags/x/y.json fails with an error" do
-          knife("show -z /data_bags/x/y.json").should_fail "ERROR: /data_bags/x/y.json: No such file or directory\n"
-        end
-
-        it "knife show -z /environments/x.json fails with an error" do
-          knife("show -z /environments/x.json").should_fail "ERROR: /environments/x.json: No such file or directory\n"
-        end
-
-        it "knife show -z /nodes/x.json fails with an error" do
-          knife("show -z /nodes/x.json").should_fail "ERROR: /nodes/x.json: No such file or directory\n"
-        end
-
-        it "knife show -z /roles/x.json fails with an error" do
-          knife("show -z /roles/x.json").should_fail "ERROR: /roles/x.json: No such file or directory\n"
-        end
-
-      end
-
-      context "PUT /TYPE/NAME" do
-        before do
-          file "empty.json", {}
-        end
-
-        it "knife raw -z -i empty.json -m PUT /clients/x fails with 404" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /clients/x").should_fail( /404/ )
-        end
-
-        it "knife raw -z -i empty.json -m PUT /data/x/y fails with 404" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /data/x/y").should_fail( /404/ )
-        end
-
-        it "knife raw -z -i empty.json -m PUT /environments/x fails with 404" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /environments/x").should_fail( /404/ )
-        end
-
-        it "knife raw -z -i empty.json -m PUT /nodes/x fails with 404" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /nodes/x").should_fail( /404/ )
-        end
-
-        it "knife raw -z -i empty.json -m PUT /roles/x fails with 404" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /roles/x").should_fail( /404/ )
-        end
-
-      end
-    end
-  end
-
-  # We have to configure Zero for Chef 11 mode in order to test users because:
-  # 1. local mode overrides your `chef_server_url` to something like "http://localhost:PORT"
-  # 2. single org mode maps requests like "https://localhost:PORT/users" so
-  #   they're functionally equivalent to "https://localhost:PORT/organizations/DEFAULT/users"
-  # 3. Users are global objects in Chef 12, and should be accessed at URLs like
-  #   "https://localhost:PORT/users" (there is an org-specific users endpoint,
-  #   but it's for listing users in an org, not for managing users).
-  # 4. Therefore you can't hit the _real_ users endpoint in local mode when
-  #   configured for Chef Server 12 mode.
-  #
-  # Because of this, we have to configure Zero for Chef 11 OSC mode in order to
-  # test the users part of the data store with local mode.
-  describe "with repo mode 'everything'" do
-    before do
-      Chef::Config.repo_mode = "everything"
-      Chef::Config.chef_zero.osc_compat = true
-    end
-
-    when_the_repository "has one of each thing" do
-      before do
-        file "clients/x.json", {}
-        file "cookbooks/x/metadata.rb", cookbook_x_100_metadata_rb
-        file "data_bags/x/y.json", {}
-        file "environments/x.json", {}
-        file "nodes/x.json", {}
-        file "roles/x.json", {}
-        file "users/x.json", {}
-      end
-
-      context "GET /TYPE" do
-        it "knife list -z -R returns everything" do
-          knife("list -z -Rfp /").should_succeed <<~EOM
-            /clients/
-            /clients/x.json
-            /cookbooks/
-            /cookbooks/x/
-            /cookbooks/x/metadata.rb
-            /data_bags/
-            /data_bags/x/
-            /data_bags/x/y.json
-            /environments/
-            /environments/x.json
-            /nodes/
-            /nodes/x.json
-            /roles/
-            /roles/x.json
-            /users/
-            /users/x.json
-          EOM
-        end
-      end
-
-      context "DELETE /TYPE/NAME" do
-        it "knife delete -z /users/x.json works" do
-          knife("delete -z /users/x.json").should_succeed "Deleted /users/x.json\n"
-          knife("list -z -Rfp /users").should_succeed ""
-        end
-      end
-
-      context "GET /TYPE/NAME" do
-        it "knife show -z /users/x.json works" do
-          knife("show -z /users/x.json").should_succeed( /"x"/ )
-        end
-      end
-
-      context "PUT /TYPE/NAME" do
-        before do
-          file "empty.json", {}
-          file "dummynode.json", { "name" => "x", "chef_environment" => "rspec" , "json_class" => "Chef::Node", "normal" => { "foo" => "bar" } }
-          file "rolestuff.json", '{"description":"hi there","name":"x"}'
-          file "cookbooks_to_upload/x/metadata.rb", cookbook_x_100_metadata_rb
-        end
-
-        it "knife raw -z -i empty.json -m PUT /users/x" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /users/x").should_succeed( /"x"/ )
-          knife("list --local /users").should_succeed "/users/x.json\n"
-        end
-
-        it "After knife raw -z -i rolestuff.json -m PUT /roles/x, the output is pretty" do
-          knife("raw -z -i #{path_to("rolestuff.json")} -m PUT /roles/x").should_succeed( /"x"/ )
-          expect(IO.read(path_to("roles/x.json"))).to eq <<~EOM.strip
-            {
-              "name": "x",
-              "description": "hi there"
-            }
-          EOM
-        end
-      end
-    end
-
-    when_the_repository "is empty" do
-      context "POST /TYPE/NAME" do
-        before do
-          file "empty.json", { "name" => "z" }
-          file "dummynode.json", { "name" => "z", "chef_environment" => "rspec" , "json_class" => "Chef::Node", "normal" => { "foo" => "bar" } }
-          file "empty_x.json", { "name" => "x" }
-          file "empty_id.json", { "id" => "z" }
-          file "rolestuff.json", '{"description":"hi there","name":"x"}'
-          file "cookbooks_to_upload/z/metadata.rb", cookbook_z_100_metadata_rb
-        end
-
-        it "knife raw -z -i empty.json -m POST /users" do
-          knife("raw -z -i #{path_to("empty.json")} -m POST /users").should_succeed( /uri/ )
-          knife("list --local /users").should_succeed "/users/z.json\n"
-        end
-      end
-
-      it "knife list -z -R returns nothing" do
-        knife("list -z -Rfp /").should_succeed <<~EOM
-          /clients/
-          /cookbooks/
-          /data_bags/
-          /environments/
-          /nodes/
-          /roles/
-          /users/
-        EOM
-      end
-
-      context "DELETE /TYPE/NAME" do
-        it "knife delete -z /users/x.json fails with an error" do
-          knife("delete -z /users/x.json").should_fail "ERROR: /users/x.json: No such file or directory\n"
-        end
-      end
-
-      context "GET /TYPE/NAME" do
-        it "knife show -z /users/x.json fails with an error" do
-          knife("show -z /users/x.json").should_fail "ERROR: /users/x.json: No such file or directory\n"
-        end
-      end
-
-      context "PUT /TYPE/NAME" do
-        before do
-          file "empty.json", {}
-        end
-
-        it "knife raw -z -i empty.json -m PUT /users/x fails with 404" do
-          knife("raw -z -i #{path_to("empty.json")} -m PUT /users/x").should_fail( /404/ )
-        end
-      end
-    end
-  end
-end