chef 11.4.4 → 11.6.0.hotfix.1

data/spec/unit/resource/template_spec.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -22,7 +22,7 @@ describe Chef::Resource::Template do
 
   before(:each) do
     @resource = Chef::Resource::Template.new("fakey_fakerton")
-  end  
+  end
 
   describe "initialize" do
     it "should create a new Chef::Resource::Template" do
@@ -47,20 +47,20 @@ describe Chef::Resource::Template do
       r.source.should eql("fakey_fakerton.erb")
     end
   end
-  
+
   describe "variables" do
     it "should accept a hash for the variable list" do
       @resource.variables({ :reluctance => :awkward })
       @resource.variables.should == { :reluctance => :awkward }
     end
   end
-  
+
   describe "cookbook" do
     it "should accept a string for the cookbook name" do
       @resource.cookbook("foo")
       @resource.cookbook.should == "foo"
     end
-    
+
     it "should default to nil" do
       @resource.cookbook.should == nil
     end
@@ -76,7 +76,7 @@ describe Chef::Resource::Template do
       @resource.local.should == false
     end
   end
-  
+
   describe "when it has a path, owner, group, mode, and checksum" do
     before do
       @resource.path("/tmp/foo.txt")
@@ -104,5 +104,108 @@ describe Chef::Resource::Template do
     it "returns the file path as its identity" do
       @resource.identity.should == "/tmp/foo.txt"
     end
-  end 
+  end
+
+  describe "defining helper methods" do
+
+    module ExampleHelpers
+      def static_example
+        "static_example"
+      end
+    end
+
+    it "collects helper method bodies as blocks" do
+      @resource.helper(:example_1) { "example_1" }
+      @resource.helper(:example_2) { "example_2" }
+      @resource.inline_helper_blocks[:example_1].call.should == "example_1"
+      @resource.inline_helper_blocks[:example_2].call.should == "example_2"
+    end
+
+    it "compiles helper methods into a module" do
+      @resource.helper(:example_1) { "example_1" }
+      @resource.helper(:example_2) { "example_2" }
+      modules = @resource.helper_modules
+      modules.should have(1).module
+      o = Object.new
+      modules.each {|m| o.extend(m)}
+      o.example_1.should == "example_1"
+      o.example_2.should == "example_2"
+    end
+
+    it "compiles helper methods with arguments into a module" do
+      @resource.helper(:shout) { |quiet| quiet.upcase }
+      modules = @resource.helper_modules
+      o = Object.new
+      modules.each {|m| o.extend(m)}
+      o.shout("shout").should == "SHOUT"
+    end
+
+    it "raises an error when attempting to define a helper method without a method body" do
+      lambda { @resource.helper(:example) }.should raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "raises an error when attempting to define a helper method with a non-Symbod method name" do
+      lambda { @resource.helper("example") { "fail" } }.should raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "collects helper module bodies as blocks" do
+      @resource.helpers do
+        def example_1
+          "example_1"
+        end
+      end
+      module_body = @resource.inline_helper_modules.first
+      module_body.should be_a(Proc)
+    end
+
+    it "compiles helper module bodies into modules" do
+      @resource.helpers do
+        def example_1
+          "example_1"
+        end
+      end
+      modules = @resource.helper_modules
+      modules.should have(1).module
+      o = Object.new
+      modules.each {|m| o.extend(m)}
+      o.example_1.should == "example_1"
+    end
+
+    it "raises an error when no block or module name is given for helpers definition" do
+      lambda { @resource.helpers() }.should raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "raises an error when a non-module is given for helpers definition" do
+      lambda { @resource.helpers("NotAModule") }.should raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "raises an error when a module name and block are both given for helpers definition" do
+      lambda { @resource.helpers(ExampleHelpers) { module_code } }.should raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "collects helper modules" do
+      @resource.helpers(ExampleHelpers)
+      @resource.helper_modules.should include(ExampleHelpers)
+    end
+
+    it "combines all helpers into a set of compiled modules" do
+      @resource.helpers(ExampleHelpers)
+      @resource.helpers do
+        def inline_module
+          "inline_module"
+        end
+      end
+      @resource.helper(:inline_method) { "inline_method" }
+      @resource.should have(3).helper_modules
+
+      o = Object.new
+      @resource.helper_modules.each {|m| o.extend(m)}
+      o.static_example.should == "static_example"
+      o.inline_module.should == "inline_module"
+      o.inline_method.should == "inline_method"
+    end
+
+
+  end
+
 end

data/spec/unit/resource/user_spec.rb

@@ -59,6 +59,13 @@ describe Chef::Resource::User, "initialize" do
       @resource.allowed_actions.detect { |a| a == action.to_sym }.should eql(action.to_sym)
     end
   end
+
+  it "should accept domain users (@ or \ separator) on non-windows" do
+    lambda { @resource.username "domain\@user" }.should_not raise_error(ArgumentError)
+    @resource.username.should == "domain\@user"
+    lambda { @resource.username "domain\\user" }.should_not raise_error(ArgumentError)
+    @resource.username.should  == "domain\\user"
+  end
 end
 
 %w{username comment home shell password}.each do |attrib|

data/spec/unit/resource_collection_spec.rb

@@ -7,9 +7,9 @@
 # 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.
@@ -20,49 +20,49 @@
 require 'spec_helper'
 
 describe Chef::ResourceCollection do
-  
+
   before(:each) do
     @rc = Chef::ResourceCollection.new()
     @resource = Chef::Resource::ZenMaster.new("makoto")
   end
-  
+
   describe "initialize" do
     it "should return a Chef::ResourceCollection" do
       @rc.should be_kind_of(Chef::ResourceCollection)
     end
   end
-  
+
   describe "[]" do
     it "should accept Chef::Resources through [index]" do
       lambda { @rc[0] = @resource }.should_not raise_error
       lambda { @rc[0] = "string" }.should raise_error
     end
-    
+
     it "should allow you to fetch Chef::Resources by position" do
       @rc[0] = @resource
       @rc[0].should eql(@resource)
     end
   end
-  
+
   describe "push" do
     it "should accept Chef::Resources through pushing" do
       lambda { @rc.push(@resource) }.should_not raise_error
       lambda { @rc.push("string") }.should raise_error
     end
   end
-  
+
   describe "<<" do
     it "should accept the << operator" do
       lambda { @rc << @resource }.should_not raise_error
     end
   end
-  
-  describe "insert" do 
+
+  describe "insert" do
     it "should accept only Chef::Resources" do
       lambda { @rc.insert(@resource) }.should_not raise_error
       lambda { @rc.insert("string") }.should raise_error
     end
-    
+
     it "should append resources to the end of the collection when not executing a run" do
       zmr = Chef::Resource::ZenMaster.new("there is no spoon")
       @rc.insert(@resource)
@@ -70,18 +70,18 @@ describe Chef::ResourceCollection do
       @rc[0].should eql(@resource)
       @rc[1].should eql(zmr)
     end
-    
+
     it "should insert resources to the middle of the collection if called while executing a run" do
       resource_to_inject = Chef::Resource::ZenMaster.new("there is no spoon")
       zmr = Chef::Resource::ZenMaster.new("morpheus")
       dummy = Chef::Resource::ZenMaster.new("keanu reeves")
       @rc.insert(zmr)
       @rc.insert(dummy)
-      
+
       @rc.execute_each_resource do |resource|
         @rc.insert(resource_to_inject) if resource == zmr
       end
-      
+
       @rc[0].should eql(zmr)
       @rc[1].should eql(resource_to_inject)
       @rc[2].should eql(dummy)
@@ -92,7 +92,7 @@ describe Chef::ResourceCollection do
     it "should allow you to iterate over every resource in the collection" do
       load_up_resources
       results = Array.new
-      lambda { 
+      lambda {
         @rc.each do |r|
           results << r.name
         end
@@ -109,15 +109,15 @@ describe Chef::ResourceCollection do
       end
     end
   end
-  
+
   describe "each_index" do
     it "should allow you to iterate over every resource by index" do
       load_up_resources
       results = Array.new
-      lambda { 
+      lambda {
         @rc.each_index do |i|
           results << @rc[i].name
-        end 
+        end
       }.should_not raise_error()
       results.each_index do |i|
         case i
@@ -131,7 +131,7 @@ describe Chef::ResourceCollection do
       end
     end
   end
-  
+
   describe "lookup" do
     it "should allow you to find resources by name via lookup" do
       zmr = Chef::Resource::ZenMaster.new("dog")
@@ -141,21 +141,21 @@ describe Chef::ResourceCollection do
       zmr = Chef::Resource::ZenMaster.new("cat")
       @rc[0] = zmr
       @rc.lookup(zmr).should eql(zmr)
-    
+
       zmr = Chef::Resource::ZenMaster.new("monkey")
       @rc.push(zmr)
       @rc.lookup(zmr).should eql(zmr)
     end
-  
+
     it "should raise an exception if you send something strange to lookup" do
       lambda { @rc.lookup(:symbol) }.should raise_error(ArgumentError)
     end
-  
+
     it "should raise an exception if it cannot find a resource with lookup" do
       lambda { @rc.lookup("zen_master[dog]") }.should raise_error(Chef::Exceptions::ResourceNotFound)
     end
   end
-  
+
   describe "resources" do
 
     it "should find a resource by symbol and name (:zen_master => monkey)" do
@@ -195,11 +195,11 @@ describe Chef::ResourceCollection do
       results.length.should eql(2)
       check_by_names(results, "monkey", "something")
     end
-  
+
     it "should raise an exception if you pass a bad name to resources" do
-      lambda { @rc.resources("michael jackson") }.should raise_error(ArgumentError)    
+      lambda { @rc.resources("michael jackson") }.should raise_error(ArgumentError)
     end
-  
+
     it "should raise an exception if you pass something other than a string or hash to resource" do
       lambda { @rc.resources([Array.new]) }.should raise_error(ArgumentError)
     end
@@ -209,7 +209,36 @@ describe Chef::ResourceCollection do
     end
 
   end
-  
+
+  describe "when validating a resource query object" do
+    it "accepts a string of the form 'resource_type[resource_name]'" do
+      @rc.validate_lookup_spec!("resource_type[resource_name]").should be_true
+    end
+
+    it "accepts a single-element :resource_type => 'resource_name' Hash" do
+      @rc.validate_lookup_spec!(:service => "apache2").should be_true
+    end
+
+
+    it "accepts a chef resource object" do
+      res = Chef::Resource.new("foo", nil)
+      @rc.validate_lookup_spec!(res).should be_true
+    end
+
+    it "rejects a malformed query string" do
+      lambda do
+        @rc.validate_lookup_spec!("resource_type[missing-end-bracket")
+      end.should raise_error(Chef::Exceptions::InvalidResourceSpecification)
+    end
+
+    it "rejects an argument that is not a String, Hash, or Chef::Resource" do
+      lambda do
+        @rc.validate_lookup_spec!(Object.new)
+      end.should raise_error(Chef::Exceptions::InvalidResourceSpecification)
+    end
+
+  end
+
   describe "to_json" do
     it "should serialize to json" do
       json = @rc.to_json
@@ -217,7 +246,7 @@ describe Chef::ResourceCollection do
       json.should =~ /instance_vars/
     end
   end
-  
+
   describe "self.from_json" do
     it "should deserialize itself from json" do
       @rc << @resource
@@ -227,13 +256,13 @@ describe Chef::ResourceCollection do
       s_rc[0].name.should eql(@resource.name)
     end
   end
-  
+
   describe "provides access to the raw resources array" do
     it "returns the resources via the all_resources method" do
       @rc.all_resources.should equal(@rc.instance_variable_get(:@resources))
     end
   end
-  
+
   describe "provides access to stepable iterator" do
     it "returns the iterator object" do
       @rc.instance_variable_set(:@iterator, :fooboar)
@@ -246,12 +275,12 @@ describe Chef::ResourceCollection do
       results.detect{ |res| res.name == res_name }.should_not eql(nil)
     end
   end
-  
+
   def load_up_resources
     %w{dog cat monkey}.each do |n|
        @rc << Chef::Resource::ZenMaster.new(n)
     end
     @rc << Chef::Resource::File.new("something")
   end
-    
+
 end

data/spec/unit/resource_reporter_spec.rb

@@ -38,11 +38,18 @@ describe Chef::ResourceReporter do
     @rest_client = mock("Chef::REST (mock)")
     @rest_client.stub!(:post_rest).and_return(true)
     @resource_reporter = Chef::ResourceReporter.new(@rest_client)
+    @run_id = @resource_reporter.run_id
     @new_resource      = Chef::Resource::File.new("/tmp/a-file.txt")
     @new_resource.cookbook_name = "monkey"
     @cookbook_version = mock("Cookbook::Version", :version => "1.2.3")
     @new_resource.stub!(:cookbook_version).and_return(@cookbook_version)
     @current_resource  = Chef::Resource::File.new("/tmp/a-file.txt")
+    @start_time = Time.new
+    @end_time = Time.new + 20
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @run_status = Chef::RunStatus.new(@node, @events)
+    Time.stub!(:now).and_return(@start_time, @end_time)
   end
 
   context "when first created" do
@@ -80,23 +87,23 @@ describe Chef::ResourceReporter do
 
   context "when chef fails" do
     before do
-      @rest_client.stub!(:create_url).and_return("reports/nodes/spitfire/runs/ABC123");
+      @rest_client.stub!(:create_url).and_return("reports/nodes/spitfire/runs/#{@run_id}");
       @rest_client.stub!(:raw_http_request).and_return({"result"=>"ok"});
-      @rest_client.stub!(:post_rest).and_return({"uri"=>"https://example.com/reports/nodes/spitfire/runs/ABC123"});
+      @rest_client.stub!(:post_rest).and_return({"uri"=>"https://example.com/reports/nodes/spitfire/runs/#{@run_id}"});
 
-      @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
     end
 
     context "before converging any resources" do
       before do
+        @resource_reporter.run_started(@run_status)
         @exception = Exception.new
         @resource_reporter.run_failed(@exception)
       end
-      
+
       it "sets the run status to 'failure'" do
         @resource_reporter.status.should == "failure"
       end
-      
+
       it "keeps the exception data" do
         @resource_reporter.exception.should == @exception
       end
@@ -117,13 +124,13 @@ describe Chef::ResourceReporter do
 
       it "collects the desired state of the resource" do
         update_record = @resource_reporter.updated_resources.first
-        update_record.new_resource.should == @new_resource        
+        update_record.new_resource.should == @new_resource
       end
     end
 
     # TODO: make sure a resource that is skipped because of `not_if` doesn't
     # leave us in a bad state.
-    
+
     context "once the a resource's current state is loaded" do
       before do
         @resource_reporter.resource_action_start(@new_resource, :create)
@@ -151,12 +158,12 @@ describe Chef::ResourceReporter do
         it "collects the updated resource" do
           @resource_reporter.should have(1).updated_resources
         end
-        
+
         it "collects the old state of the resource" do
-          update_record = @resource_reporter.updated_resources.first          
+          update_record = @resource_reporter.updated_resources.first
           update_record.current_resource.should == @current_resource
         end
-        
+
         it "collects the new state of the resource" do
           update_record = @resource_reporter.updated_resources.first
           update_record.new_resource.should == @new_resource
@@ -170,19 +177,19 @@ describe Chef::ResourceReporter do
             @resource_reporter.resource_failed(@next_new_resource, :create, @exception)
             @resource_reporter.resource_completed(@next_new_resource)
           end
-          
+
           it "collects the desired state of the failed resource" do
             failed_resource_update = @resource_reporter.updated_resources.last
             failed_resource_update.new_resource.should == @next_new_resource
           end
-          
+
           it "does not have the current state of the failed resource" do
             failed_resource_update = @resource_reporter.updated_resources.last
             failed_resource_update.current_resource.should be_nil
           end
         end
       end
-    
+
       # Some providers, such as RemoteDirectory and some LWRPs use other
       # resources for their implementation. These should be hidden from reporting
       # since we only care about the top-level resource and not the sub-resources
@@ -213,7 +220,7 @@ describe Chef::ResourceReporter do
           @resource_reporter.resource_updated(@new_resource, :create)
           @resource_reporter.resource_completed(@new_resource)
         end
-        
+
         it "does not collect data about the nested resource" do
           @resource_reporter.should have(1).updated_resources
         end
@@ -226,16 +233,16 @@ describe Chef::ResourceReporter do
           @resource_reporter.resource_failed(@new_resource, :create, @exception)
           @resource_reporter.resource_completed(@new_resource)
         end
-        
+
         it "collects the resource as an updated resource" do
           @resource_reporter.should have(1).updated_resources
         end
-        
+
         it "collects the desired state of the resource" do
           update_record = @resource_reporter.updated_resources.first
           update_record.new_resource.should == @new_resource
         end
-        
+
         it "collects the current state of the resource" do
           update_record = @resource_reporter.updated_resources.first
           update_record.current_resource.should == @current_resource
@@ -248,13 +255,13 @@ describe Chef::ResourceReporter do
   describe "when generating a report for the server" do
 
     before do
-      @rest_client.stub!(:create_url).and_return("reports/nodes/spitfire/runs/ABC123");
+      @rest_client.stub!(:create_url).and_return("reports/nodes/spitfire/runs/#{@run_id}");
       @rest_client.stub!(:raw_http_request).and_return({"result"=>"ok"});
-      @rest_client.stub!(:post_rest).and_return({"uri"=>"https://example.com/reports/nodes/spitfire/runs/ABC123"});
-      
-      @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
+      @rest_client.stub!(:post_rest).and_return({"uri"=>"https://example.com/reports/nodes/spitfire/runs/#{@run_id}"});
+
+      @resource_reporter.run_started(@run_status)
     end
-    
+
     context "for a successful client run" do
       before do
         # TODO: add inputs to generate expected output.
@@ -291,6 +298,7 @@ describe Chef::ResourceReporter do
         @resource_reporter.resource_current_state_loaded(@new_resource, :create, @current_resource)
         @resource_reporter.resource_updated(@new_resource, :create)
         @resource_reporter.resource_completed(@new_resource)
+        @run_status.stop_clock
         @report = @resource_reporter.prepare_run_data
         @first_update_report = @report["resources"].first
       end
@@ -357,8 +365,14 @@ describe Chef::ResourceReporter do
 
       it "includes the run_list" do
         @report.should have_key("run_list")
-        @report["run_list"].should == @node.run_list.to_json
+        @report["run_list"].should == @run_status.node.run_list.to_json
       end
+
+      it "includes the end_time" do
+        @report.should have_key("end_time")
+        @report["end_time"].should == @run_status.end_time.to_s
+      end
+
     end
 
     context "for an unsuccessful run" do
@@ -394,15 +408,68 @@ describe Chef::ResourceReporter do
 
       it "includes the error inspector output in the event data" do
         @report["data"]["exception"].should have_key("description")
-        @report["data"]["exception"]["description"].should include({"title"=>"Error expanding the run_list:", "sections"=>[["Unexpected Error:", "RSpec::Mocks::Mock: Object not found"]]})
+        @report["data"]["exception"]["description"].should include({"title"=>"Error expanding the run_list:", "sections"=>[{"Unexpected Error:" => "RSpec::Mocks::Mock: Object not found"}]})
       end
 
     end
 
+    context "when new_resource does not have a cookbook_name" do
+      before do
+        @bad_resource = Chef::Resource::File.new("/tmp/a-file.txt")
+        @bad_resource.cookbook_name = nil
+
+        @resource_reporter.resource_action_start(@bad_resource, :create)
+        @resource_reporter.resource_current_state_loaded(@bad_resource, :create, @current_resource)
+        @resource_reporter.resource_updated(@bad_resource, :create)
+        @resource_reporter.resource_completed(@bad_resource)
+        @run_status.stop_clock
+        @report = @resource_reporter.prepare_run_data
+        @first_update_report = @report["resources"].first
+      end
+
+      it "includes an updated resource's initial state" do
+        @first_update_report["before"].should == @current_resource.state
+      end
+
+      it "includes an updated resource's final state" do
+        @first_update_report["after"].should == @new_resource.state
+      end
+
+      it "includes the resource's name" do
+        @first_update_report["name"].should == @new_resource.name
+      end
+
+      it "includes the resource's id attribute" do
+        @first_update_report["id"].should == @new_resource.identity
+      end
+
+      it "includes the elapsed time for the resource to converge" do
+        # TODO: API takes integer number of milliseconds as a string. This
+        # should be an int.
+        @first_update_report.should have_key("duration")
+        @first_update_report["duration"].to_i.should be_within(100).of(0)
+      end
+
+      it "includes the action executed by the resource" do
+        # TODO: rename as "action"
+        @first_update_report["result"].should == "create"
+      end
+
+      it "does not include a cookbook name for the resource" do
+        @first_update_report.should_not have_key("cookbook_name")
+      end
+
+      it "does not include a cookbook version for the resource" do
+        @first_update_report.should_not have_key("cookbook_version")
+      end
+    end
+
   end
 
   describe "when updating resource history on the server" do
     before do
+      @resource_reporter.run_started(@run_status)
+      @run_status.start_clock
     end
 
     context "when the server does not support storing resource history" do
@@ -411,24 +478,26 @@ describe Chef::ResourceReporter do
         @response = Net::HTTPNotFound.new("a response body", "404", "Not Found")
         @error = Net::HTTPServerException.new("404 message", @response)
         @rest_client.should_receive(:post_rest).
-          with("reports/nodes/spitfire/runs", {:action => :begin}).
+          with("reports/nodes/spitfire/runs", {:action => :start, :run_id => @run_id,
+                                               :start_time => @start_time.to_s},
+               {'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION}).
           and_raise(@error)
       end
 
       it "assumes the feature is not enabled" do
-        @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
+        @resource_reporter.run_started(@run_status)
         @resource_reporter.reporting_enabled?.should be_false
       end
 
       it "does not send a resource report to the server" do
-        @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
+        @resource_reporter.run_started(@run_status)
         @rest_client.should_not_receive(:post_rest)
         @resource_reporter.run_completed(@node)
       end
 
       it "prints an error about the 404" do
         Chef::Log.should_receive(:debug).with(/404/)
-        @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
+        @resource_reporter.run_started(@run_status)
       end
 
     end
@@ -439,24 +508,25 @@ describe Chef::ResourceReporter do
         @response = Net::HTTPInternalServerError.new("a response body", "500", "Internal Server Error")
         @error = Net::HTTPServerException.new("500 message", @response)
         @rest_client.should_receive(:post_rest).
-          with("reports/nodes/spitfire/runs", {:action => :begin}).
+          with("reports/nodes/spitfire/runs", {:action => :start, :run_id => @run_id, :start_time => @start_time.to_s},
+               {'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION}).
           and_raise(@error)
       end
 
       it "assumes the feature is not enabled" do
-        @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
+        @resource_reporter.run_started(@run_status)
         @resource_reporter.reporting_enabled?.should be_false
       end
 
       it "does not send a resource report to the server" do
-        @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
+        @resource_reporter.run_started(@run_status)
         @rest_client.should_not_receive(:post_rest)
         @resource_reporter.run_completed(@node)
       end
 
       it "prints an error about the error" do
         Chef::Log.should_receive(:info).with(/500/)
-        @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
+        @resource_reporter.run_started(@run_status)
       end
     end
 
@@ -468,7 +538,8 @@ describe Chef::ResourceReporter do
         @response = Net::HTTPInternalServerError.new("a response body", "500", "Internal Server Error")
         @error = Net::HTTPServerException.new("500 message", @response)
         @rest_client.should_receive(:post_rest).
-          with("reports/nodes/spitfire/runs", {:action => :begin}).
+          with("reports/nodes/spitfire/runs", {:action => :start, :run_id => @run_id, :start_time => @start_time.to_s},
+               {'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION}).
           and_raise(@error)
       end
 
@@ -479,23 +550,23 @@ describe Chef::ResourceReporter do
       it "fails the run and prints an message about the error" do
         Chef::Log.should_receive(:error).with(/500/)
         lambda {
-          @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
+          @resource_reporter.run_started(@run_status)
         }.should raise_error(Net::HTTPServerException)
       end
     end
 
     context "after creating the run history document" do
       before do
-        response = {"uri"=>"https://example.com/reports/nodes/spitfire/runs/ABC123"}
+        response = {"uri"=>"https://example.com/reports/nodes/spitfire/runs/@run_id"}
         @rest_client.should_receive(:post_rest).
-          with("reports/nodes/spitfire/runs", {:action => :begin}).
+          with("reports/nodes/spitfire/runs", {:action => :start, :run_id => @run_id, :start_time => @start_time.to_s},
+               {'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION}).
           and_return(response)
-
-        @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
+        @resource_reporter.run_started(@run_status)
       end
 
       it "creates a run document on the server at the start of the run" do
-        @resource_reporter.run_id.should == "ABC123"
+        @resource_reporter.run_id.should == @run_id
       end
 
       it "updates the run document with resource updates at the end of the run" do
@@ -504,19 +575,22 @@ describe Chef::ResourceReporter do
         @resource_reporter.resource_current_state_loaded(@new_resource, :create, @current_resource)
         @resource_reporter.resource_updated(@new_resource, :create)
 
+        @resource_reporter.stub!(:end_time).and_return(@end_time)
         @expected_data = @resource_reporter.prepare_run_data
 
         post_url = "https://chef_server/example_url"
         response = {"result"=>"ok"}
 
         @rest_client.should_receive(:create_url).
-          with("reports/nodes/spitfire/runs/ABC123").
+          with("reports/nodes/spitfire/runs/#{@run_id}").
           ordered.
           and_return(post_url)
         @rest_client.should_receive(:raw_http_request).ordered do |method, url, headers, data|
           method.should eq(:POST)
           url.should eq(post_url)
-          headers.should eq({'Content-Encoding' => 'gzip'})
+          headers.should eq({'Content-Encoding' => 'gzip',
+                             'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION
+          })
           data_stream = Zlib::GzipReader.new(StringIO.new(data))
           data = data_stream.read
           data.should eq(@expected_data.to_json)
@@ -526,66 +600,5 @@ describe Chef::ResourceReporter do
         @resource_reporter.run_completed(@node)
       end
     end
-
-    context "after creating the run history document when summary_only is set to true" do
-      before do
-        response = {"uri"=>"https://example.com/reports/nodes/spitfire/runs/ABC123", "summary_only"=>"true"}
-        @rest_client.should_receive(:post_rest).
-          with("reports/nodes/spitfire/runs", {:action => :begin}).
-          and_return(response)
-
-        @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
-      end
-
-      it "enables summary only reporting" do
-        @resource_reporter.summary_only.should == "true"
-      end
-
-      it "updates the run document with resource updates at the end of the run" do
-        # update some resources...
-        @resource_reporter.resource_action_start(@new_resource, :create)
-        @resource_reporter.resource_current_state_loaded(@new_resource, :create, @current_resource)
-        @resource_reporter.resource_updated(@new_resource, :create)
-
-        post_url = "reports/nodes/spitfire/runs/ABC123"
-        response = {"result"=>"ok"}
-
-        @rest_client.should_receive(:post_rest).ordered do |url, data|
-          url.should eq(post_url)
-          data.should have_key("action")
-          data["action"].should == "end"
-          data.should have_key("status")
-          data.should have_key("resources")
-          data["resources"].should == []
-          data.should have_key("total_res_count")
-          data["total_res_count"].should == "1"
-          data.should have_key("data")
-          data["data"].should == {}
-          data.should have_key("updated_res_count")
-          data["updated_res_count"].should == "0"
-          data.should have_key("post_size")
-          response
-        end
-
-        @resource_reporter.run_completed(@node)
-      end
-    end
-
-    context "after creating the run history document when summary_only is set to false" do
-      before do
-        response = {"uri"=>"https://example.com/reports/nodes/spitfire/runs/ABC123", "summary_only"=>"false"}
-        @rest_client.should_receive(:post_rest).
-          with("reports/nodes/spitfire/runs", {:action => :begin}).
-          and_return(response)
-
-        @resource_reporter.node_load_completed(@node, :expanded_run_list, :config)
-      end
-
-      it "disables summary_only reporting" do
-        @resource_reporter.summary_only.should == "false"
-      end
-     end
-
   end
-
 end