chef 14.15.6 → 15.0.293

data/spec/unit/audit/audit_reporter_spec.rb

@@ -1,444 +0,0 @@
-#
-# Author:: Tyler Ball (<tball@chef.io>)
-# Author:: Claire McQuin (<claire@chef.io>)
-#
-# Copyright:: Copyright 2014-2018, 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::Audit::AuditReporter do
-
-  let(:rest) { double("rest") }
-  let(:reporter) { described_class.new(rest) }
-  let(:node) { double("node", name: "sofreshsoclean") }
-  let(:run_id) { 0 }
-  let(:start_time) { Time.new(2014, 12, 3, 9, 31, 05, "-08:00") }
-  let(:end_time) { Time.new(2014, 12, 3, 9, 36, 14, "-08:00") }
-  let(:run_status) do
-    instance_double(Chef::RunStatus, node: node, run_id: run_id,
-                                     start_time: start_time, end_time: end_time)
-  end
-
-  describe "#audit_phase_start" do
-
-    it "notifies audit phase start to trace log" do
-      expect(Chef::Log).to receive(:trace).with(/Audit Reporter starting/)
-      reporter.audit_phase_start(run_status)
-    end
-
-    it "initializes an AuditData object" do
-      expect(Chef::Audit::AuditData).to receive(:new).with(run_status.node.name, run_status.run_id)
-      reporter.audit_phase_start(run_status)
-    end
-
-    it "saves the run status" do
-      reporter.audit_phase_start(run_status)
-      expect(reporter.instance_variable_get(:@run_status)).to eq run_status
-    end
-  end
-
-  describe "#run_completed" do
-
-    let(:audit_data) { Chef::Audit::AuditData.new(node.name, run_id) }
-    let(:run_data) { audit_data.to_h }
-
-    before do
-      allow(reporter).to receive(:auditing_enabled?).and_return(true)
-      allow(reporter).to receive(:run_status).and_return(run_status)
-      allow(rest).to receive(:post).and_return(true)
-      allow(reporter).to receive(:audit_data).and_return(audit_data)
-      allow(reporter).to receive(:run_status).and_return(run_status)
-      allow(audit_data).to receive(:to_h).and_return(run_data)
-    end
-
-    describe "a successful run with auditing enabled" do
-      it "sets run start and end times" do
-        iso_start_time = "2014-12-03T17:31:05Z"
-        iso_end_time = "2014-12-03T17:36:14Z"
-
-        reporter.run_completed(node)
-        expect(audit_data.start_time).to eq iso_start_time
-        expect(audit_data.end_time).to eq iso_end_time
-      end
-
-      it "posts audit data to server endpoint" do
-        headers = {
-          "X-Ops-Audit-Report-Protocol-Version" => Chef::Audit::AuditReporter::PROTOCOL_VERSION,
-        }
-
-        expect(rest).to receive(:post)
-          .with("controls", run_data, headers)
-        reporter.run_completed(node)
-      end
-
-      context "when audit phase failed" do
-
-        let(:audit_error) do
-          double("AuditError", class: "Chef::Exceptions::AuditError",
-                               message: "Audit phase failed with error message: derpderpderp",
-                               backtrace: ["/path/recipe.rb:57", "/path/library.rb:106"])
-        end
-
-        before do
-          reporter.instance_variable_set(:@audit_phase_error, audit_error)
-        end
-
-        it "reports an error" do
-          reporter.run_completed(node)
-          expect(run_data).to have_key(:error)
-          expect(run_data).to have_key(:error)
-          expect(run_data[:error]).to eq <<~EOM.strip!
-            Chef::Exceptions::AuditError: Audit phase failed with error message: derpderpderp
-            /path/recipe.rb:57
-            /path/library.rb:106
-          EOM
-        end
-
-      end
-
-      context "when unable to post to server" do
-
-        let(:error) do
-          e = StandardError.new
-          e.set_backtrace(caller)
-          e
-        end
-
-        before do
-          expect(rest).to receive(:post).and_raise(error)
-          allow(error).to receive(:respond_to?).and_call_original
-        end
-
-        context "the error is an http error" do
-
-          let(:response) { double("response", code: code) }
-
-          before do
-            expect(Chef::Log).to receive(:trace).with(/Sending audit report/)
-            expect(Chef::Log).to receive(:trace).with(/Audit Report/)
-            allow(error).to receive(:response).and_return(response)
-            expect(error).to receive(:respond_to?).with(:response).and_return(true)
-          end
-
-          context "when the code is 404" do
-
-            let(:code) { "404" }
-
-            it "logs that the server doesn't support audit reporting" do
-              expect(Chef::Log).to receive(:trace).with(/Server doesn't support audit reporting/)
-              reporter.run_completed(node)
-            end
-          end
-
-          shared_examples "non-404 error code" do
-
-            it "saves the error report" do
-              expect(Chef::FileCache).to receive(:store)
-                .with("failed-audit-data.json", an_instance_of(String), 0640)
-                .and_return(true)
-              expect(Chef::FileCache).to receive(:load)
-                .with("failed-audit-data.json", false)
-                .and_return(true)
-              expect(Chef::Log).to receive(:error).with(/Failed to post audit report to server/)
-              reporter.run_completed(node)
-            end
-
-          end
-
-          context "when the code is not 404" do
-            include_examples "non-404 error code" do
-              let(:code) { "505" }
-            end
-          end
-
-          context "when there is no code" do
-            include_examples "non-404 error code" do
-              let(:code) { nil }
-            end
-          end
-
-        end
-
-        context "the error is not an http error" do
-
-          it "logs the error" do
-            expect(error).to receive(:respond_to?).with(:response).and_return(false)
-            expect(Chef::Log).to receive(:error).with(/Failed to post audit report to server/)
-            reporter.run_completed(node)
-          end
-
-        end
-
-        context "when reporting url fatals are enabled" do
-
-          before do
-            allow(Chef::Config).to receive(:[])
-              .with(:enable_reporting_url_fatals)
-              .and_return(true)
-          end
-
-          it "raises the error" do
-            expect(error).to receive(:respond_to?).with(:response).and_return(false)
-            allow(Chef::Log).to receive(:error).and_return(true)
-            expect(Chef::Log).to receive(:error).with(/Reporting fatals enabled. Aborting run./)
-            expect { reporter.run_completed(node) }.to raise_error(error)
-          end
-
-        end
-      end
-    end
-
-    context "when auditing is not enabled" do
-
-      before do
-        allow(Chef::Log).to receive(:trace)
-      end
-
-      it "doesn't send reports" do
-        expect(reporter).to receive(:auditing_enabled?).and_return(false)
-        expect(Chef::Log).to receive(:trace).with("Audit Reports are disabled. Skipping sending reports.")
-        reporter.run_completed(node)
-      end
-
-    end
-
-    context "when the run fails before audits" do
-
-      before do
-        allow(Chef::Log).to receive(:trace)
-      end
-
-      it "doesn't send reports" do
-        expect(reporter).to receive(:auditing_enabled?).and_return(true)
-        expect(reporter).to receive(:run_status).and_return(nil)
-        expect(Chef::Log).to receive(:trace).with("Run failed before audit mode was initialized, not sending audit report to server")
-        reporter.run_completed(node)
-      end
-
-    end
-  end
-
-  describe "#run_failed" do
-
-    let(:audit_data) { Chef::Audit::AuditData.new(node.name, run_id) }
-    let(:run_data) { audit_data.to_h }
-
-    let(:audit_error) do
-      double("AuditError", class: "Chef::Exceptions::AuditError",
-                           message: "Audit phase failed with error message: derpderpderp",
-                           backtrace: ["/path/recipe.rb:57", "/path/library.rb:106"])
-    end
-
-    let(:run_error) do
-      double("RunError", class: "Chef::Exceptions::RunError",
-                         message: "This error shouldn't be reported.",
-                         backtrace: ["fix it", "fix it", "fix it"])
-    end
-
-    before do
-      allow(reporter).to receive(:auditing_enabled?).and_return(true)
-      allow(reporter).to receive(:run_status).and_return(run_status)
-      allow(reporter).to receive(:audit_data).and_return(audit_data)
-      allow(audit_data).to receive(:to_h).and_return(run_data)
-    end
-
-    context "when no prior exception is stored" do
-      it "reports no error" do
-        expect(rest).to receive(:post)
-        reporter.run_failed(run_error)
-        expect(run_data).to_not have_key(:error)
-      end
-    end
-
-    context "when some prior exception is stored" do
-      before do
-        reporter.instance_variable_set(:@audit_phase_error, audit_error)
-      end
-
-      it "reports the prior error" do
-        expect(rest).to receive(:post)
-        reporter.run_failed(run_error)
-        expect(run_data).to have_key(:error)
-        expect(run_data[:error]).to eq <<~EOM.strip!
-          Chef::Exceptions::AuditError: Audit phase failed with error message: derpderpderp
-          /path/recipe.rb:57
-          /path/library.rb:106
-        EOM
-      end
-    end
-  end
-
-  shared_context "audit data" do
-
-    let(:control_group_foo) do
-      instance_double(Chef::Audit::ControlGroupData,
-        metadata: double("foo metadata"))
-    end
-    let(:control_group_bar) do
-      instance_double(Chef::Audit::ControlGroupData,
-        metadata: double("bar metadata"))
-    end
-
-    let(:ordered_control_groups) do
-      {
-        "foo" => control_group_foo,
-        "bar" => control_group_bar,
-      }
-    end
-
-    let(:audit_data) do
-      instance_double(Chef::Audit::AuditData,
-        add_control_group: true)
-    end
-
-    let(:run_context) do
-      instance_double(Chef::RunContext,
-        audits: ordered_control_groups)
-    end
-
-    before do
-      allow(reporter).to receive(:ordered_control_groups).and_return(ordered_control_groups)
-      allow(reporter).to receive(:audit_data).and_return(audit_data)
-      allow(reporter).to receive(:run_status).and_return(run_status)
-      allow(run_status).to receive(:run_context).and_return(run_context)
-    end
-  end
-
-  describe "#audit_phase_complete" do
-    include_context "audit data"
-
-    it "notifies audit phase finished to trace log" do
-      expect(Chef::Log).to receive(:trace).with(/Audit Reporter completed/)
-      reporter.audit_phase_complete("Output from audit mode")
-    end
-
-    it "collects audit data" do
-      ordered_control_groups.each_value do |group|
-        expect(audit_data).to receive(:add_control_group).with(group)
-      end
-      reporter.audit_phase_complete("Output from audit mode")
-    end
-  end
-
-  describe "#audit_phase_failed" do
-    include_context "audit data"
-
-    let(:error) { double("Exception") }
-
-    it "notifies audit phase failed to trace log" do
-      expect(Chef::Log).to receive(:trace).with(/Audit Reporter failed/)
-      reporter.audit_phase_failed(error, "Output from audit mode")
-    end
-
-    it "collects audit data" do
-      ordered_control_groups.each_value do |group|
-        expect(audit_data).to receive(:add_control_group).with(group)
-      end
-      reporter.audit_phase_failed(error, "Output from audit mode")
-    end
-  end
-
-  describe "#control_group_started" do
-    include_context "audit data"
-
-    let(:name) { "bat" }
-    let(:control_group) do
-      instance_double(Chef::Audit::ControlGroupData,
-        metadata: double("metadata"))
-    end
-
-    before do
-      allow(Chef::Audit::ControlGroupData).to receive(:new)
-        .with(name, control_group.metadata)
-        .and_return(control_group)
-    end
-
-    it "stores the control group" do
-      expect(ordered_control_groups).to receive(:key?).with(name).and_return(false)
-      allow(run_context.audits).to receive(:[]).with(name).and_return(control_group)
-      expect(ordered_control_groups).to receive(:store)
-        .with(name, control_group)
-        .and_call_original
-      reporter.control_group_started(name)
-      expect(ordered_control_groups[name]).to eq control_group
-    end
-
-    context "when a control group with the same name has been seen" do
-      it "raises an exception" do
-        expect(ordered_control_groups).to receive(:key?).with(name).and_return(true)
-        expect { reporter.control_group_started(name) }.to raise_error(Chef::Exceptions::AuditControlGroupDuplicate)
-      end
-    end
-  end
-
-  describe "#control_example_success" do
-    include_context "audit data"
-
-    let(:name) { "foo" }
-    let(:example_data) { double("example data") }
-
-    it "notifies the control group the example succeeded" do
-      expect(control_group_foo).to receive(:example_success).with(example_data)
-      reporter.control_example_success(name, example_data)
-    end
-  end
-
-  describe "#control_example_failure" do
-    include_context "audit data"
-
-    let(:name) { "bar" }
-    let(:example_data) { double("example data") }
-    let(:error) { double("Exception", message: "oopsie") }
-
-    it "notifies the control group the example failed" do
-      expect(control_group_bar).to receive(:example_failure)
-        .with(example_data, error.message)
-      reporter.control_example_failure(name, example_data, error)
-    end
-  end
-
-  describe "#auditing_enabled?" do
-    shared_examples "enabled?" do |true_or_false|
-
-      it "returns #{true_or_false}" do
-        expect(Chef::Config).to receive(:[])
-          .with(:audit_mode)
-          .and_return(audit_setting)
-        expect(reporter.auditing_enabled?).to be true_or_false
-      end
-    end
-
-    context "when auditing is disabled" do
-      include_examples "enabled?", false do
-        let(:audit_setting) { :disabled }
-      end
-    end
-
-    context "when auditing in audit-only mode" do
-      include_examples "enabled?", true do
-        let(:audit_setting) { :audit_only }
-      end
-    end
-
-    context "when auditing is enabled" do
-      include_examples "enabled?", true do
-        let(:audit_setting) { :enabled }
-      end
-    end
-  end
-
-end

data/spec/unit/audit/control_group_data_spec.rb

@@ -1,487 +0,0 @@
-#
-# Author:: Tyler Ball (<tball@chef.io>)
-# Author:: Claire McQuin (<claire@chef.io>)
-#
-# Copyright:: Copyright 2014-2018, 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 "securerandom"
-
-describe Chef::Audit::AuditData do
-
-  let(:node_name) { "noodles" }
-  let(:run_id) { SecureRandom.uuid }
-  let(:audit_data) { described_class.new(node_name, run_id) }
-
-  let(:control_group_1) { double("control group 1") }
-  let(:control_group_2) { double("control group 2") }
-
-  describe "#add_control_group" do
-    context "when no control groups have been added" do
-      it "stores the control group" do
-        audit_data.add_control_group(control_group_1)
-        expect(audit_data.control_groups).to include(control_group_1)
-      end
-
-    end
-
-    context "when adding additional control groups" do
-
-      before do
-        audit_data.add_control_group(control_group_1)
-      end
-
-      it "stores the control group" do
-        audit_data.add_control_group(control_group_2)
-        expect(audit_data.control_groups).to include(control_group_2)
-      end
-
-      it "stores all control groups" do
-        audit_data.add_control_group(control_group_2)
-        expect(audit_data.control_groups).to include(control_group_1)
-      end
-    end
-  end
-
-  describe "#to_h" do
-
-    let(:audit_data_hash) { audit_data.to_h }
-
-    it "returns a hash" do
-      expect(audit_data_hash).to be_a(Hash)
-    end
-
-    it "describes a Chef::Audit::AuditData object" do
-      keys = %i{node_name run_id start_time end_time control_groups}
-      expect(audit_data_hash.keys).to match_array(keys)
-    end
-
-    describe ":control_groups" do
-
-      let(:control_hash_1) { { name: "control group 1" } }
-      let(:control_hash_2) { { name: "control group 2" } }
-
-      let(:control_groups) { audit_data_hash[:control_groups] }
-
-      context "with no control groups added" do
-        it "is an empty list" do
-          expect(control_groups).to eq []
-        end
-      end
-
-      context "with one control group added" do
-
-        before do
-          allow(audit_data).to receive(:control_groups).and_return([control_group_1])
-        end
-
-        it "is a one-element list containing the control group hash" do
-          expect(control_group_1).to receive(:to_h).once.and_return(control_hash_1)
-          expect(control_groups.size).to eq 1
-          expect(control_groups).to include(control_hash_1)
-        end
-      end
-
-      context "with multiple control groups added" do
-
-        before do
-          allow(audit_data).to receive(:control_groups).and_return([control_group_1, control_group_2])
-        end
-
-        it "is a list of control group hashes" do
-          expect(control_group_1).to receive(:to_h).and_return(control_hash_1)
-          expect(control_group_2).to receive(:to_h).and_return(control_hash_2)
-          expect(control_groups.size).to eq 2
-          expect(control_groups).to include(control_hash_1)
-          expect(control_groups).to include(control_hash_2)
-        end
-      end
-    end
-  end
-end
-
-describe Chef::Audit::ControlData do
-
-  let(:name) { "ramen" }
-  let(:resource_type) { double("Service") }
-  let(:resource_name) { "mysql" }
-  let(:context) { nil }
-  let(:line_number) { 27 }
-
-  let(:control_data) do
-    described_class.new(name: name,
-                        resource_type: resource_type, resource_name: resource_name,
-                        context: context, line_number: line_number)
-  end
-
-  describe "#to_h" do
-
-    let(:control_data_hash) { control_data.to_h }
-
-    it "returns a hash" do
-      expect(control_data_hash).to be_a(Hash)
-    end
-
-    it "describes a Chef::Audit::ControlData object" do
-      keys = %i{name resource_type resource_name context status details}
-      expect(control_data_hash.keys).to match_array(keys)
-    end
-
-    context "when context is nil" do
-
-      it "sets :context to an empty array" do
-        expect(control_data_hash[:context]).to eq []
-      end
-
-    end
-
-    context "when context is non-nil" do
-
-      let(:context) { ["outer"] }
-
-      it "sets :context to its value" do
-        expect(control_data_hash[:context]).to eq context
-      end
-    end
-  end
-end
-
-describe Chef::Audit::ControlGroupData do
-
-  let(:name) { "balloon" }
-  let(:control_group_data) { described_class.new(name) }
-
-  shared_context "control data" do
-
-    let(:name) { "" }
-    let(:resource_type) { nil }
-    let(:resource_name) { nil }
-    let(:context) { nil }
-    let(:line_number) { 0 }
-
-    let(:control_data) do
-      {
-        name: name,
-        resource_type: resource_type,
-        resource_name: resource_name,
-        context: context,
-        line_number: line_number,
-      }
-    end
-
-  end
-
-  shared_context "control" do
-    include_context "control data"
-
-    let(:control) do
-      Chef::Audit::ControlData.new(name: name,
-                                   resource_type: resource_type, resource_name: resource_name,
-                                   context: context, line_number: line_number)
-    end
-
-    before do
-      allow(Chef::Audit::ControlData).to receive(:new)
-        .with(name: name, resource_type: resource_type,
-             resource_name: resource_name, context: context,
-             line_number: line_number)
-        .and_return(control)
-    end
-  end
-
-  describe "#new" do
-    it "has status \"success\"" do
-      expect(control_group_data.status).to eq "success"
-    end
-  end
-
-  describe "#example_success" do
-    include_context "control"
-
-    def notify_success
-      control_group_data.example_success(control_data)
-    end
-
-    it "increments the number of successful audits" do
-      num_success = control_group_data.number_succeeded
-      notify_success
-      expect(control_group_data.number_succeeded).to eq (num_success + 1)
-    end
-
-    it "does not increment the number of failed audits" do
-      num_failed = control_group_data.number_failed
-      notify_success
-      expect(control_group_data.number_failed).to eq (num_failed)
-    end
-
-    it "marks the audit's status as success" do
-      notify_success
-      expect(control.status).to eq "success"
-    end
-
-    it "does not modify its own status" do
-      expect(control_group_data).to_not receive(:status=)
-      status = control_group_data.status
-      notify_success
-      expect(control_group_data.status).to eq status
-    end
-
-    it "saves the control" do
-      controls = control_group_data.controls
-      expect(controls).to_not include(control)
-      notify_success
-      expect(controls).to include(control)
-    end
-  end
-
-  describe "#example_failure" do
-    include_context "control"
-
-    let(:details) { "poop" }
-
-    def notify_failure
-      control_group_data.example_failure(control_data, details)
-    end
-
-    it "does not increment the number of successful audits" do
-      num_success = control_group_data.number_succeeded
-      notify_failure
-      expect(control_group_data.number_succeeded).to eq num_success
-    end
-
-    it "increments the number of failed audits" do
-      num_failed = control_group_data.number_failed
-      notify_failure
-      expect(control_group_data.number_failed).to eq (num_failed + 1)
-    end
-
-    it "marks the audit's status as failure" do
-      notify_failure
-      expect(control.status).to eq "failure"
-    end
-
-    it "marks its own status as failure" do
-      notify_failure
-      expect(control_group_data.status).to eq "failure"
-    end
-
-    it "saves the control" do
-      controls = control_group_data.controls
-      expect(controls).to_not include(control)
-      notify_failure
-      expect(controls).to include(control)
-    end
-
-    context "when details are not provided" do
-
-      let(:details) { nil }
-
-      it "does not save details to the control" do
-        default_details = control.details
-        expect(control).to_not receive(:details=)
-        notify_failure
-        expect(control.details).to eq default_details
-      end
-    end
-
-    context "when details are provided" do
-
-      let(:details) { "yep that didn't work" }
-
-      it "saves details to the control" do
-        notify_failure
-        expect(control.details).to eq details
-      end
-    end
-  end
-
-  shared_examples "multiple audits" do |success_or_failure|
-    include_context "control"
-
-    let(:num_success) { 0 }
-    let(:num_failure) { 0 }
-
-    before do
-      if num_failure == 0
-        num_success.times { control_group_data.example_success(control_data) }
-      elsif num_success == 0
-        num_failure.times { control_group_data.example_failure(control_data, nil) }
-      end
-    end
-
-    it "counts the number of successful audits" do
-      expect(control_group_data.number_succeeded).to eq num_success
-    end
-
-    it "counts the number of failed audits" do
-      expect(control_group_data.number_failed).to eq num_failure
-    end
-
-    it "marks its status as \"#{success_or_failure}\"" do
-      expect(control_group_data.status).to eq success_or_failure
-    end
-  end
-
-  context "when all audits pass" do
-    include_examples "multiple audits", "success" do
-      let(:num_success) { 3 }
-    end
-  end
-
-  context "when one audit fails" do
-    shared_examples "mixed audit results" do
-      include_examples "multiple audits", "failure" do
-
-        let(:audit_results) { [] }
-        let(:num_success) { audit_results.count("success") }
-        let(:num_failure) { 1 }
-
-        before do
-          audit_results.each do |result|
-            if result == "success"
-              control_group_data.example_success(control_data)
-            else
-              control_group_data.example_failure(control_data, nil)
-            end
-          end
-        end
-      end
-    end
-
-    context "and it's the first audit" do
-      include_examples "mixed audit results" do
-        let(:audit_results) { %w{failure success success} }
-      end
-    end
-
-    context "and it's an audit in the middle" do
-      include_examples "mixed audit results" do
-        let(:audit_results) { %w{success failure success} }
-      end
-    end
-
-    context "and it's the last audit" do
-      include_examples "mixed audit results" do
-        let(:audit_results) { %w{success success failure} }
-      end
-    end
-  end
-
-  context "when all audits fail" do
-    include_examples "multiple audits", "failure" do
-      let(:num_failure) { 3 }
-    end
-  end
-
-  describe "#to_h" do
-
-    let(:control_group_data_hash) { control_group_data.to_h }
-
-    it "returns a hash" do
-      expect(control_group_data_hash).to be_a(Hash)
-    end
-
-    it "describes a Chef::Audit::ControlGroupData object" do
-      keys = %i{name status number_succeeded number_failed
-        controls id}
-      expect(control_group_data_hash.keys).to match_array(keys)
-    end
-
-    describe ":controls" do
-
-      let(:control_group_controls) { control_group_data_hash[:controls] }
-
-      context "with no controls added" do
-        it "is an empty list" do
-          expect(control_group_controls).to eq []
-        end
-      end
-
-      context "with one control added" do
-        include_context "control"
-
-        let(:control_list) { [control_data] }
-        let(:control_hash) { control.to_h }
-
-        before do
-          expect(control_group_data).to receive(:controls).twice.and_return(control_list)
-          expect(control_data).to receive(:to_h).and_return(control_hash)
-        end
-
-        it "is a one-element list containing the control hash" do
-          expect(control_group_controls.size).to eq 1
-          expect(control_group_controls).to include(control_hash)
-        end
-
-        it "adds a sequence number to the control" do
-          control_group_data.to_h
-          expect(control_hash).to have_key(:sequence_number)
-        end
-
-      end
-
-      context "with multiple controls added" do
-
-        let(:control_hash_1) { { line_number: 27 } }
-        let(:control_hash_2) { { line_number: 13 } }
-        let(:control_hash_3) { { line_number: 35 } }
-
-        let(:control_1) do
-          double("control 1",
-            line_number: control_hash_1[:line_number],
-            to_h: control_hash_1)
-        end
-        let(:control_2) do
-          double("control 2",
-            line_number: control_hash_2[:line_number],
-            to_h: control_hash_2)
-        end
-        let(:control_3) do
-          double("control 3",
-            line_number: control_hash_3[:line_number],
-            to_h: control_hash_3)
-        end
-
-        let(:control_list) { [control_1, control_2, control_3] }
-        let(:ordered_control_hashes) { [control_hash_2, control_hash_1, control_hash_3] }
-
-        before do
-          # Another way to do this would be to call #example_success
-          # or #example_failure per control hash, but we'd have to
-          # then stub #create_control and it's a lot of extra stubbing work.
-          # We can't stub the controls reader to return a list of
-          # controls because of the call to sort! and the following
-          # reading of controls.
-          control_group_data.instance_variable_set(:@controls, control_list)
-        end
-
-        it "is a list of control group hashes ordered by line number" do
-          expect(control_group_controls.size).to eq 3
-          expect(control_group_controls).to eq ordered_control_hashes
-        end
-
-        it "assigns sequence numbers in order" do
-          control_group_data.to_h
-          ordered_control_hashes.each_with_index do |control_hash, idx|
-            expect(control_hash[:sequence_number]).to eq idx + 1
-          end
-        end
-      end
-    end
-  end
-
-end