cornucopia 0.1.12

data/spec/lib/util/file_asset_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+require "tempfile"
+require ::File.expand_path("../../../lib/cornucopia/util/file_asset", File.dirname(__FILE__))
+
+describe Cornucopia::Util::FileAsset do
+  let(:asset) { Cornucopia::Util::FileAsset.new("index_contents.html") }
+
+  around(:each) do |example|
+    begin
+      FileUtils.mkdir_p(File.join(File.dirname(__FILE__), "test_file_output"))
+
+      example.run
+    ensure
+      FileUtils.rm_rf(File.join(File.dirname(__FILE__), "test_file_output"))
+    end
+  end
+
+  it "returns the path to the default asset path" do
+    expect(asset.path).to be == File.absolute_path(File.join(File.dirname(__FILE__), "../../../lib/cornucopia/source_files/index_contents.html"))
+  end
+
+  it "copies base files" do
+    asset.create_file(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+
+    copy_file   = File.read(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+    source_file = File.read(asset.path)
+
+    expect(copy_file).to be == source_file
+  end
+
+  it "allows for an overridden file asset" do
+    asset.body = "This is a specialized asset"
+
+    asset.create_file(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+
+    copy_file = File.read(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+
+    expect(copy_file).to be == "This is a specialized asset"
+  end
+
+  it "allows a separate file source" do
+    alt_asset = Cornucopia::Util::FileAsset.new("report_base.html")
+
+    asset.source_file = alt_asset.path
+
+    asset.create_file(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+
+    copy_file   = File.read(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+    source_file = File.read(alt_asset.path)
+
+    expect(copy_file).to be == source_file
+  end
+
+  it "adds files if they don't exist" do
+    asset.add_file(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+
+    copy_file   = File.read(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+    source_file = File.read(asset.path)
+
+    expect(copy_file).to be == source_file
+  end
+
+  it "does not add a file if it already exists" do
+    alt_asset = Cornucopia::Util::FileAsset.new("report_base.html")
+
+    alt_asset.add_file(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+    asset.add_file(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+
+    copy_file   = File.read(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+    source_file = File.read(alt_asset.path)
+
+    expect(copy_file).to be == source_file
+  end
+
+  it "shares and caches file assets" do
+    cached      = Cornucopia::Util::FileAsset.asset("index_contents.html")
+    cached.body = "This is a specialized asset"
+
+    alt_cached = Cornucopia::Util::FileAsset.asset("index_contents.html")
+
+    alt_cached.add_file(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+    copy_file = File.read(File.join(File.dirname(__FILE__), "test_file_output/copy_file_test.html"))
+
+    expect(copy_file).to be == "This is a specialized asset"
+  end
+end

data/spec/lib/util/generic_settings_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+require ::File.expand_path("../../../lib/cornucopia/util/generic_settings", File.dirname(__FILE__))
+
+describe Cornucopia::Util::GenericSettings do
+  let(:subject) { Cornucopia::Util::GenericSettings.new }
+
+  class Object
+    def method_missing(method_sym, *arguments, &block)
+      if method_sym == :___stupid_missing_message
+        "Missing message"
+      else
+        super
+      end
+    end
+
+    def respond_to?(method_sym, include_private = false)
+      if method_sym == :___stupid_missing_message
+        true
+      else
+        super
+      end
+    end
+  end
+
+  it "responds_to? anything" do
+    expect(subject.respond_to?(Faker::Lorem.word)).to be_truthy
+  end
+
+  it "calls the super implementation of somthing if it exists" do
+    expect(subject.object_id).to be
+  end
+
+  it "looks for a value in a hash if it isn't recognized" do
+    expect(subject.send(Faker::Lorem.word)).not_to be
+  end
+
+  it "will store a value in anything that isn't a base function" do
+    stored_value = Faker::Lorem.paragraphs
+    value_name   = Faker::Lorem.word
+
+    subject.send("#{value_name}=", stored_value)
+    expect(subject.send(value_name)).to be == stored_value
+  end
+
+  it "calls the super method" do
+    expect(subject.___stupid_missing_message).to be == "Missing message"
+  end
+end

data/spec/lib/util/log_capture_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require ::File.expand_path("../../../lib/cornucopia/util/log_capture", File.dirname(__FILE__))
+
+describe Cornucopia::Util::LogCapture do
+  let(:file_name) { Rails.root.join("sample_log.log") }
+
+  around(:each) do |example|
+    expect(File.directory?(Rails.root.join("cornucopia_report/"))).to be_falsey
+    expect(File.directory?(Rails.root.join("spec/cornucopia_report/"))).to be_falsey
+    expect(File.directory?(Rails.root.join("features/cornucopia_report/"))).to be_falsey
+    expect(File.exists?(file_name)).to be_falsey
+
+    begin
+      example.run
+    ensure
+      if (Cornucopia::Util::ReportBuilder.class_variable_get("@@current_report"))
+        Cornucopia::Util::ReportBuilder.current_report.close
+      end
+
+      FileUtils.rm_rf Rails.root.join("cornucopia_report/")
+      FileUtils.rm_rf Rails.root.join("spec/cornucopia_report/")
+      FileUtils.rm_rf Rails.root.join("features/cornucopia_report/")
+      FileUtils.rm_rf Rails.root.join("features") if Dir[Rails.root.join("features/*")].empty?
+      FileUtils.rm_rf file_name
+    end
+  end
+
+  describe "#highlight_log_output" do
+    it "should color error lines" do
+      error_line = Cornucopia::Util::LogCapture.highlight_log_output("Completed 404 this is an error")
+      expect(error_line).to be_html_safe
+      expect(error_line).to match(/\>Completed 404 this is an error\</)
+      expect(error_line).to match(/^\<span/)
+      expect(error_line).to match(/\<\/span\>$/)
+      expect(error_line).to match(/completed-error/)
+    end
+
+    it "should color success lines" do
+      error_line = Cornucopia::Util::LogCapture.highlight_log_output("Completed 302 this is a redirect")
+      expect(error_line).to be_html_safe
+      expect(error_line).to match(/\>Completed 302 this is a redirect\</)
+      expect(error_line).to match(/^\<span/)
+      expect(error_line).to match(/\<\/span\>$/)
+      expect(error_line).to match(/completed-other/)
+    end
+
+    it "should color both error and success lines" do
+      error_line = Cornucopia::Util::LogCapture.highlight_log_output("Completed 404 this is an error\nCompleted 302 this is a redirect")
+      expect(error_line).to be_html_safe
+      expect(error_line).to match(/\>Completed 404 this is an error\</)
+      expect(error_line).to match(/^\<span/)
+      expect(error_line).to match(/\<\/span\>$/)
+      expect(error_line).to match(/completed-error/)
+      expect(error_line).to match(/\>Completed 302 this is a redirect\</)
+      expect(error_line).to match(/^\<span/)
+      expect(error_line).to match(/\<\/span\>$/)
+      expect(error_line).to match(/completed-other/)
+    end
+  end
+
+  describe "#output_log_file" do
+    it "fetches the last 500 lines of a file" do
+      lines = Faker::Lorem.sentences(rand(600..1000))
+      File.open(file_name, "a:UTF-8") do |write_file|
+        write_file.write(lines.join("\n"))
+      end
+
+      report_table = Cornucopia::Util::ReportTable.new do |table|
+        Cornucopia::Util::LogCapture.output_log_file(table, file_name)
+      end
+
+      expect(report_table.full_table).to match /#{lines[-500..-1].join("\n")}/
+      expect(report_table.full_table).to_not match /#{lines[-501..-1].join("\n")}/
+    end
+
+    it "fetches the last 500 lines of a file even if it has to fetch multiple times" do
+      lines = (0..rand(600..1000)).to_a.map { Faker::Lorem.sentences(rand(5..10)).join(" ") }
+      File.open(file_name, "a:UTF-8") do |write_file|
+        write_file.write(lines.join("\n"))
+      end
+
+      report_table = Cornucopia::Util::ReportTable.new do |table|
+        Cornucopia::Util::LogCapture.output_log_file(table, file_name)
+      end
+
+      expect(report_table.full_table).to match /#{lines[-500..-1].join("\n")}/
+      expect(report_table.full_table).to_not match /#{lines[-501..-1].join("\n")}/
+    end
+  end
+
+  describe "#capture_logs" do
+    after(:each) do
+      Cornucopia::Util::Configuration.remove_log_file("sample_log.log")
+    end
+
+    it "starts a new report if it is not passed a table" do
+      expect(Cornucopia::Util::ReportBuilder).to receive(:current_report).and_call_original
+      expect(Cornucopia::Util::LogCapture).to receive(:capture_logs).twice.and_call_original
+      Cornucopia::Util::Configuration.add_log_file("sample_log.log")
+
+      lines = Faker::Lorem.sentences(rand(600..1000))
+      File.open(file_name, "a:UTF-8") do |write_file|
+        write_file.write(lines.join("\n"))
+      end
+
+      Cornucopia::Util::LogCapture.capture_logs(nil)
+
+      report_data = File.read(Rails.root.join("cornucopia_report/cornucopia_report/report_contents.html"))
+      expect(report_data).to match /#{lines[-500..-1].join("\n")}/
+      expect(report_data).to_not match /#{lines[-501..-1].join("\n")}/
+    end
+
+    it "goes up one level if you are in spec or features" do
+      expect(Cornucopia::Util::ReportBuilder).to receive(:current_report).and_call_original
+      expect(Cornucopia::Util::LogCapture).to receive(:capture_logs).twice.and_call_original
+      Cornucopia::Util::Configuration.add_log_file("sample_log.log")
+
+      lines = Faker::Lorem.sentences(rand(600..1000))
+      File.open(file_name, "a:UTF-8") do |write_file|
+        write_file.write(lines.join("\n"))
+      end
+
+      new_root = Rails.root.join(%w(features features).sample).to_s
+      expect(Rails).to receive(:root).at_least(1).and_return(new_root)
+      Cornucopia::Util::LogCapture.capture_logs(nil)
+
+      report_data = File.read(File.join(new_root, "cornucopia_report/cornucopia_report/report_contents.html"))
+      expect(report_data).to match /#{lines[-500..-1].join("\n")}/
+      expect(report_data).to_not match /#{lines[-501..-1].join("\n")}/
+    end
+
+    it "does not require Rails" do
+      expect(Cornucopia::Util::ReportBuilder).to receive(:current_report).and_call_original
+      expect(Cornucopia::Util::LogCapture).to receive(:capture_logs).twice.and_call_original
+      Cornucopia::Util::Configuration.add_log_file("sample_log.log")
+      FileUtils.cd Rails.root.to_s
+      expect(Object).to receive(:const_defined?).at_least(1).with("Rails").and_return(false)
+
+      lines = Faker::Lorem.sentences(rand(600..1000))
+      File.open(file_name, "a:UTF-8") do |write_file|
+        write_file.write(lines.join("\n"))
+      end
+
+      Cornucopia::Util::LogCapture.capture_logs(nil)
+
+      report_data = File.read(Rails.root.join("cornucopia_report/cornucopia_report/report_contents.html"))
+      expect(report_data).to match /#{lines[-500..-1].join("\n")}/
+      expect(report_data).to_not match /#{lines[-501..-1].join("\n")}/
+    end
+  end
+end

data/spec/lib/util/pretty_formatter_spec.rb

@@ -0,0 +1,694 @@
+require 'spec_helper'
+require ::File.expand_path("../../../lib/cornucopia/util/pretty_formatter", File.dirname(__FILE__))
+
+describe Cornucopia::Util::PrettyFormatter do
+  let(:formatted_string) { "#<AClass\nmy_variable = \"a value \",\n \"another\"=0>" }
+  let(:simple_class) { "#<AClass>" }
+  let(:simple_variable) { "#<AClass \"variable\"=\"value\", something = something else>" }
+  let(:simple_variable_expectations) { "#<AClass\n  \"variable\" = \"value\",\n  something = something else\n>" }
+  let(:simple_array) { "#<AClass \"array\" = [[a,b,c],\"value\", something here, \"\\\"some\\\\thing\\\"\", a_value]>" }
+  let(:simple_array_expectations) { "#<AClass\n  \"array\" =\n    [\n      [\n        a,\n        b,\n        c\n      ],\n      \"value\",\n      something here,\n      \"\\\"some\\\\thing\\\"\",\n      a_value\n    ]\n>" }
+  let(:simple_hash) { "#<AClass \"hash\" = {:value => something here, \"\\\"some\\\\thing\\\"\" => a value, symbol: :symbol_also }  >" }
+  let(:simple_hash_expectations) { "#<AClass\n  \"hash\" =\n    {\n      :value => something here,\n      \"\\\"some\\\\thing\\\"\" => a value,\n      symbol: :symbol_also\n    }\n>" }
+
+  it "doesn't format a formatted string" do
+    pretty = Cornucopia::Util::PrettyFormatter.format_string(formatted_string)
+    expect(pretty).to be == formatted_string
+
+    pretty = Cornucopia::Util::PrettyFormatter.format_string(formatted_string.gsub(/\n/, " "))
+    expect(pretty).to_not be == formatted_string
+  end
+
+  describe "bad states" do
+    ["\"", "{", "["].each do |test_char|
+      it "gives up if it finds bad characters = #{test_char}" do
+        test_string = "#<ACl#{test_char}ass \"variable\"=\"value\", something = something else>"
+        pretty      = Cornucopia::Util::PrettyFormatter.format_string(test_string)
+        expect(pretty).to be == "\n#{test_string}"
+      end
+    end
+
+    it "knows what to do with a comma" do
+      test_string = "#<AClass \"variable\", something = , something else>"
+      pretty      = Cornucopia::Util::PrettyFormatter.format_string(test_string)
+      expect(pretty).to be == "#<AClass\n  \"variable\" ,something =,\n  something \nelse>"
+    end
+
+    it "knows what to do with a comma after a =>" do
+      test_string = "#<AClass \"variable\" = { :hash =>,>"
+      pretty      = Cornucopia::Util::PrettyFormatter.format_string(test_string)
+      expect(pretty).to be == "#<AClass\n  \"variable\" =\n    {\n      :hash => ,\n>"
+    end
+
+    it "knows what to do with a comma instead of a =>" do
+      test_string = "#<AClass \"variable\" = { :hash,>"
+      pretty      = Cornucopia::Util::PrettyFormatter.format_string(test_string)
+      expect(pretty).to be == "#<AClass\n  \"variable\" =\n    {\n      :hash , \n>"
+    end
+
+    it "is a test" do
+      test_string = "#<AClass hash: value>"
+      pretty      = Cornucopia::Util::PrettyFormatter.format_string(test_string)
+      expect(pretty).to be == "#<AClass\n  hash: value\n>"
+    end
+
+    it "breaks if a hash is invalid" do
+      test_string = "#<AClass {\"variable\" = >,}>"
+      pretty      = Cornucopia::Util::PrettyFormatter.format_string(test_string)
+      expect(pretty).to be == "#<AClass\n    {\n      \"variable\" \n= >,}>"
+
+      test_string = "#<AClass {\"variable\" => \"VALUE\" t}>"
+      pretty      = Cornucopia::Util::PrettyFormatter.format_string(test_string)
+      expect(pretty).to be == "#<AClass\n    {\n      \"variable\" => \"VALUE\"\nt}>"
+    end
+  end
+
+  it "formats a simple class" do
+    pretty = Cornucopia::Util::PrettyFormatter.format_string(simple_class)
+    expect(pretty).to be == simple_class
+  end
+
+  it "formats a simple variable" do
+    pretty = Cornucopia::Util::PrettyFormatter.format_string(simple_variable)
+    expect(pretty).to be == simple_variable_expectations
+  end
+
+  it "formats a simple class in bigger text" do
+    pre_text  = rand(0..1) == 0 ? "#{Faker::Lorem.sentence}\n" : ""
+    post_text = rand(0..1) == 0 ? "\n#{Faker::Lorem.sentence}" : ""
+    pretty    = Cornucopia::Util::PrettyFormatter.format_string("#{pre_text[0..-2]}#{simple_variable}#{post_text[1..-1]}")
+
+    expect(pretty).to be == expectation_in_text(simple_variable_expectations, pre_text, post_text)
+  end
+
+  it "formats an array" do
+    pretty = Cornucopia::Util::PrettyFormatter.format_string(simple_array)
+    expect(pretty).to be == simple_array_expectations
+  end
+
+  it "formats a simple array in bigger text" do
+    pre_text  = rand(0..1) == 0 ? "#{Faker::Lorem.sentence}\n" : ""
+    post_text = rand(0..1) == 0 ? "\n#{Faker::Lorem.sentence}" : ""
+    pretty    = Cornucopia::Util::PrettyFormatter.format_string("#{pre_text[0..-2]}#{simple_array}#{post_text[1..-1]}")
+
+    expect(pretty).to be == expectation_in_text(simple_array_expectations, pre_text, post_text)
+  end
+
+  it "formats an hash" do
+    pretty = Cornucopia::Util::PrettyFormatter.format_string(simple_hash)
+    expect(pretty).to be == simple_hash_expectations
+  end
+
+  it "formats a simple hash in bigger text" do
+    pre_text  = rand(0..1) == 0 ? "#{Faker::Lorem.sentence}\n" : ""
+    post_text = rand(0..1) == 0 ? "\n#{Faker::Lorem.sentence}" : ""
+    pretty    = Cornucopia::Util::PrettyFormatter.format_string("#{pre_text[0..-2]}#{simple_hash}#{post_text[1..-1]}")
+
+    expect(pretty).to be == expectation_in_text(simple_hash_expectations, pre_text, post_text)
+  end
+
+  it "formats a known problem string 1" do
+    format_value = "#<class @silencers=#<class @silencers=[#<Proc:0x007f8d9f2a15f0@/Users/elittell/.rvm/gems/ruby-1.9.3-p327@homerun/gems/railties-3.2.13/lib/rails/backtrace_cleaner.rb:15>]>, \"HTTP_HO\"=\"HTTP_HO\">"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == "#<class\n  @silencers =\n    #<class\n      @silencers =\n        [\n          #<Proc:0x007f8d9f2a15f0@/Users/elittell/.rvm/gems/ruby-1.9.3-p327@homerun/gems/railties-3.2.13/lib/rails/backtrace_cleaner.rb:15>\n        ]\n    >,\n  \"HTTP_HO\" = \"HTTP_HO\"\n>"
+  end
+
+  it "formats an implied hash" do
+    format_value = "#<DbInjector::Deal id: 1, slug: \"6ff445f3\", type: \"daily-deal\">"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == "#<DbInjector::Deal\n  id: 1,\n  slug: \"6ff445f3\",\n  type: \"daily-deal\"\n>"
+
+    format_value = "".html_safe + "#<DbInjector::Deal id: 1, slug: \"6ff445f3\", type: \"daily-deal\">"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == "#&lt;DbInjector::Deal\n  id: 1,\n  slug: &quot;6ff445f3&quot;,\n  type: &quot;daily-deal&quot;\n&gt;"
+    expect(pretty).to be_html_safe
+  end
+
+  it "formats an implied hash" do
+    format_value = "#<DbInjector::Deal id: 1, slug: \"6ff445f3\", type: \"daily-deal\"> fred"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == "#<DbInjector::Deal\n  id: 1,\n  slug: \"6ff445f3\",\n  type: \"daily-deal\"\n>\n fred"
+
+    format_value = "".html_safe + "#<DbInjector::Deal id: 1, slug: \"6ff445f3\", type: \"daily-deal\"> fred"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == "#&lt;DbInjector::Deal\n  id: 1,\n  slug: &quot;6ff445f3&quot;,\n  type: &quot;daily-deal&quot;\n&gt;\n fred"
+    expect(pretty).to be_html_safe
+  end
+
+  it "formats an implied hash with a hash-rocket" do
+    format_value = "#<DbInjector::Deal id => 1, slug => \"6ff445f3\", type => \"daily-deal\">"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == "#<DbInjector::Deal\n  id => 1,\n  slug => \"6ff445f3\",\n  type => \"daily-deal\"\n>"
+
+    format_value = "".html_safe + "#<DbInjector::Deal id => 1, slug => \"6ff445f3\", type => \"daily-deal\">"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == "#&lt;DbInjector::Deal\n  id =&gt; 1,\n  slug =&gt; &quot;6ff445f3&quot;,\n  type =&gt; &quot;daily-deal&quot;\n&gt;"
+    expect(pretty).to be_html_safe
+  end
+
+  it "formats parameters" do
+    format_value = "Parameters: { \"id\" => \"value\", \"deal\"=>{\"affinity_score\"=>nil, \"buy_button_clicks\"=>6 }, \"custom_data\"=>{\"custom_data\"=>{}} }"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+    expected     = "Parameters:\n  {\n    \"id\" => \"value\",\n    \"deal\" =>\n      {\n        \"affinity_score\" => nil,\n        \"buy_button_clicks\" => 6\n      },\n    \"custom_data\" =>\n      {\n        \"custom_data\" =>\n          {\n          }\n      }\n  }"
+
+    expect(pretty).to be == expected
+
+    format_value = "".html_safe + format_value
+    expected     = "".html_safe + expected
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == expected
+    expect(pretty).to be_html_safe
+  end
+
+  it "formats parameters embedded in text" do
+    format_value = "this is some expectation_in_text Parameters: { \"id\" => \"value\", \"deal\"=>{\"affinity_score\"=>nil, \"buy_button_clicks\"=>6 }, \"custom_data\"=>{\"custom_data\"=>{}} } this is some expectation_in_text"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+    expected     = "this is some expectation_in_text\n  Parameters:\n    {\n      \"id\" => \"value\",\n      \"deal\" =>\n        {\n          \"affinity_score\" => nil,\n          \"buy_button_clicks\" => 6\n        },\n      \"custom_data\" =>\n        {\n          \"custom_data\" =>\n            {\n            }\n        }\n    }\n this is some expectation_in_text"
+
+    expect(pretty).to be == expected
+
+    format_value = "".html_safe + format_value
+    expected     = "".html_safe + expected
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == expected
+    expect(pretty).to be_html_safe
+  end
+
+  it "formats multiple parameters embedded in text" do
+    format_value = "this is some expectation_in_text Parameters: { \"id\" => \"value\", \"deal\"=>{\"affinity_score\"=>nil, \"buy_button_clicks\"=>6 }, \"custom_data\"=>{\"custom_data\"=>{}} } this is some expectation_in_textthis is some expectation_in_text Parameters: { \"id\" => \"value\", \"deal\"=>{\"affinity_score\"=>nil, \"buy_button_clicks\"=>6 }, \"custom_data\"=>{\"custom_data\"=>{}} } this is some expectation_in_text"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+    expected     = "this is some expectation_in_text\n  Parameters:\n    {\n      \"id\" => \"value\",\n      \"deal\" =>\n        {\n          \"affinity_score\" => nil,\n          \"buy_button_clicks\" => 6\n        },\n      \"custom_data\" =>\n        {\n          \"custom_data\" =>\n            {\n            }\n        }\n    }\n this is some expectation_in_textthis is some expectation_in_text\n  Parameters:\n    {\n      \"id\" => \"value\",\n      \"deal\" =>\n        {\n          \"affinity_score\" => nil,\n          \"buy_button_clicks\" => 6\n        },\n      \"custom_data\" =>\n        {\n          \"custom_data\" =>\n            {\n            }\n        }\n    }\n this is some expectation_in_text"
+
+    expect(pretty).to be == expected
+
+    format_value = "".html_safe + format_value
+    expected     = "".html_safe + expected
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == expected
+    expect(pretty).to be_html_safe
+  end
+
+  it "formats bad parameters embedded in text" do
+    format_value = "[PartnerScope] Set to: chameleon_basic\nProcessing by DealsController#show as HTML\n  Parameters: {\";id\"=>\"5e2a61bd\"}\nGET http://admin-homerun.localhost:3001//api/v2/deals/5e2a61bd.json?include=all"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+    expected     = "[PartnerScope] Set to: chameleon_basic\nProcessing by DealsController#show as HTML\n  Parameters:\n    {\n      \";id\" => \"5e2a61bd\"\n    }\n\nGET http://admin-homerun.localhost:3001//api/v2/deals/5e2a61bd.json?include=all"
+
+    expect(pretty).to be == expected
+
+    format_value = ("".html_safe + format_value).to_s
+    expected     = "".html_safe + expected
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == expected
+    expect(pretty).to be_html_safe
+  end
+
+  it "formats Parameters: {}" do
+    format_value = "Parameters:{}"
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+    expected     = "Parameters:\n  {\n  }"
+
+    expect(pretty).to be == expected
+
+    format_value = ("".html_safe + format_value).to_s
+    expected     = "".html_safe + expected
+    pretty       = Cornucopia::Util::PrettyFormatter.format_string(format_value)
+
+    expect(pretty).to be == expected
+    expect(pretty).to be_html_safe
+  end
+
+  describe "helpers" do
+    [:parameters,
+     :embedded_class,
+     :class,
+     :class_with_value,
+     :implied_hash,
+     :hash,
+     :array].each do |value_type|
+      it "can create a #{value_type} value" do
+        create_value(0, value_type)
+      end
+    end
+
+    [:whitespace,
+     :value_name_simple,
+     :value_method,
+     :value_name_string,
+     :hash_key_string,
+     :value_string,
+     :value_name_complex_string,
+     :value_complex_string,
+     :hash_key_complex_string,
+     :value_simple,
+     :hash_key_symbol,
+     :hash_key_reversed_symbol
+    ].each do |value_type|
+      it "can create a #{value_type} simple value" do
+        create_simple_value(0, value_type)
+      end
+    end
+  end
+
+  describe "tests" do
+    it "formats a complicated value" do
+      test_value, expected_value = create_value(0, [:class, :embedded_class, :implied_hash, :parameters].sample)
+      pretty                     = Cornucopia::Util::PrettyFormatter.format_string(test_value)
+      expect(pretty).to be == expected_value
+    end
+
+    it "formats an html_safe complicated value" do
+      test_value, expected_value = create_value(0, [:class, :embedded_class, :implied_hash, :parameters].sample)
+      test_value                 = "".html_safe + test_value
+      expected_value             = "".html_safe + expected_value
+      pretty                     = Cornucopia::Util::PrettyFormatter.format_string(test_value)
+      expect(pretty).to be == expected_value
+      expect(pretty).to be_html_safe
+    end
+  end
+
+  # (1..100).to_a.each do |index|
+  (1..10).to_a.each do |index|
+    it "formats a complicated value (#{index})" do
+      test_value, expected_value = create_value(0, [:class, :embedded_class, :implied_hash, :parameters].sample)
+      pretty                     = Cornucopia::Util::PrettyFormatter.format_string(test_value)
+      expect(pretty).to be == expected_value
+    end
+
+    it "formats an html_safe complicated value (#{index})" do
+      test_value, expected_value = create_value(0, [:class, :embedded_class, :implied_hash, :parameters].sample)
+      test_value                 = "".html_safe + test_value
+      expected_value             = "".html_safe + expected_value
+      pretty                     = Cornucopia::Util::PrettyFormatter.format_string(test_value)
+      expect(pretty).to be == expected_value
+      expect(pretty).to be_html_safe
+    end
+  end
+end
+
+def create_simple_value(type, options = {})
+  case type
+    when :whitespace
+      if rand(0..10) == 0
+        simple_val = ""
+      else
+        simple_val = " " * rand(1..10)
+        simple_val += "\t" * rand(0..10)
+        unless options[:spaces_only]
+          simple_val += "\n" * rand(0..10)
+          simple_val += "\r" * rand(0..10)
+        end
+        simple_val = simple_val.split("").sample(100).join("")
+      end
+
+    when :value_name_simple, :value_method
+      simple_val = Faker::Lorem.word
+      simple_val = "#{simple_val}?" if rand(0..1) == 0
+      simple_val = "@#{simple_val}" if rand(0..1) == 0
+
+    when :value_name_string, :hash_key_string, :value_string
+      simple_val = "\"#{Faker::Lorem.sentence}\""
+
+    when :value_name_complex_string, :value_complex_string, :hash_key_complex_string
+      simple_val = "'#{'{}<>[]\"\#~?/`!@#$%^&*()-_=+`'}".split("").sample(rand(5..10)).join("")
+      simple_val = "#{simple_val}#{Faker::Lorem.word}".split("").join("")
+      simple_val = "#{Faker::Lorem.sentence} #{simple_val}".split(" ").join(" ")
+      simple_val = simple_val.gsub(/([\\\"])/, "\\\\\\1")
+      simple_val = "\"#{simple_val}\""
+
+    when :value_simple
+      case [:number, :float, :date, :date_time, :string, :word].sample
+        when :number
+          simple_val = rand(-9999999999..9999999999)
+
+        when :float
+          simple_val = rand * (10 ** rand(0..15))
+
+        when :date
+          simple_val = Date.today + rand(-99999..99999).days
+
+        when :date_time
+          simple_val = DateTime.now + rand(-9999999999..9999999999).seconds
+
+        when :string
+          simple_val = Faker::Lorem.sentence
+
+        when :word
+          simple_val = Faker::Lorem.word
+      end
+
+    when :hash_key_symbol
+      simple_val = ":#{Faker::Lorem.word}"
+
+    when :hash_key_reversed_symbol
+      simple_val = "#{Faker::Lorem.word}:"
+  end
+
+  simple_val.to_s
+end
+
+def create_value(level, type, options = {})
+  case type
+    when :parameters
+      sub_options = options.merge({ spaces_only: true })
+
+      pre_value  = rand(0..1) == 0 ? Faker::Lorem.sentence : ""
+      post_value = rand(0..1) == 0 ? Faker::Lorem.sentence : ""
+
+      unless pre_value.blank?
+        if rand(0..1) == 0
+          pre_value << create_simple_value(:whitespace, options)
+        end
+      end
+
+      unless post_value.blank?
+        if rand(0..1) == 0
+          post_value = "#{create_simple_value(:whitespace, options)}#{post_value}"
+        end
+      end
+
+      if pre_value.blank?
+        val, expected = create_value(level + 1, :hash, sub_options)
+      else
+        val, expected = create_value(level + 2, :hash, sub_options)
+      end
+      unless post_value.blank?
+        post_value = "\n#{post_value}"
+      end
+
+      value_val    = "#{pre_value}Parameters:#{create_simple_value(:whitespace, sub_options)}#{val}#{post_value}"
+      value_expect = "#{pre_value.rstrip}#{pre_value.rstrip.blank? ? "" : "\n  "}Parameters:\n#{expected}\n#{post_value.rstrip}"
+
+      rand(0..5).times do
+        pre_value  = rand(0..1) == 0 ? Faker::Lorem.sentence : ""
+        post_value = rand(0..1) == 0 ? Faker::Lorem.sentence : ""
+
+        if rand(0..1) == 0
+          val = create_simple_value(:whitespace, options)
+          value_val << val
+          value_expect << val
+        end
+
+        if rand(0..1) == 0
+          val = Faker::Lorem.sentence
+          value_val << val
+          value_expect << val
+
+          if rand(0..1) == 0
+            val = create_simple_value(:whitespace, options)
+            value_val << val
+            value_expect << val
+          end
+        end
+
+        if pre_value.blank?
+          if rand(0..1) == 0
+            pre_value << create_simple_value(:whitespace, options)
+          end
+        end
+
+        unless post_value.blank?
+          if rand(0..1) == 0
+            post_value = "#{create_simple_value(:whitespace, options)}#{post_value}"
+          end
+        end
+        unless post_value.blank?
+          post_value = "\n#{post_value}"
+        end
+        if pre_value.rstrip.blank?
+          value_expect.rstrip!
+        end
+
+        val, expected = create_value(level + 2, :hash, sub_options)
+
+        value_val << "#{pre_value}Parameters:#{create_simple_value(:whitespace, sub_options)}#{val}#{post_value}"
+        value_expect << "#{pre_value.rstrip}\n  Parameters:\n#{expected}\n#{post_value.rstrip}"
+      end
+
+      value_expect.rstrip!
+
+    when :embedded_class
+      pre_value  = rand(0..1) == 0 ? Faker::Lorem.sentence : ""
+      post_value = rand(0..1) == 0 ? Faker::Lorem.sentence : ""
+
+      unless pre_value.blank?
+        if rand(0..1) == 0
+          pre_value << create_simple_value(:whitespace, options)
+        end
+      end
+
+      unless post_value.blank?
+        if rand(0..1) == 0
+          post_value = "#{create_simple_value(:whitespace, options)}#{post_value}"
+        end
+      end
+
+      if pre_value.blank?
+        val, expected = create_value(level, :class_with_value, options)
+      else
+        val, expected = create_value(level + 1, :class_with_value, options)
+      end
+      unless post_value.blank?
+        post_value = "\n#{post_value}"
+      end
+
+      value_val    = "#{pre_value}#{val}#{post_value}"
+      value_expect = "#{pre_value.rstrip}#{pre_value.rstrip.blank? ? "" : "\n"}#{expected}\n#{post_value.rstrip}"
+
+      rand(0..5).times do
+        pre_value  = rand(0..1) == 0 ? Faker::Lorem.sentence : ""
+        post_value = rand(0..1) == 0 ? Faker::Lorem.sentence : ""
+
+        if rand(0..1) == 0
+          val = create_simple_value(:whitespace, options)
+          value_val << val
+          value_expect << val
+        end
+
+        if rand(0..1) == 0
+          val = Faker::Lorem.sentence
+          value_val << val
+          value_expect << val
+
+          if rand(0..1) == 0
+            val = create_simple_value(:whitespace, options)
+            value_val << val
+            value_expect << val
+          end
+        end
+
+        if pre_value.blank?
+          if rand(0..1) == 0
+            pre_value << create_simple_value(:whitespace, options)
+          end
+        end
+
+        unless post_value.blank?
+          if rand(0..1) == 0
+            post_value = "#{create_simple_value(:whitespace, options)}#{post_value}"
+          end
+        end
+        unless post_value.blank?
+          post_value = "\n#{post_value}"
+        end
+        if pre_value.rstrip.blank?
+          value_expect.rstrip!
+        end
+
+        val, expected = create_value(level + 1, :class, options)
+
+        value_val << "#{pre_value}#{val}#{post_value}"
+        value_expect << "#{pre_value.rstrip}\n#{expected}\n#{post_value.rstrip}"
+      end
+
+      value_expect.rstrip!
+
+    when :class, :class_with_value
+      name          = create_simple_value(:value_name_simple, options)
+      value_val     = "\#<#{name}#{" " * rand(1..10)}"
+      value_expect  = "#{"  " * level}\#<#{name}"
+      append_value  = ""
+      append_expect = "\n"
+
+      range_start = type == :class ? 0 : 1
+
+      rand(range_start..5).times do
+        name     = create_simple_value([:value_name_complex_string, :value_name_simple, :value_name_string].sample, options)
+        val_type = [:class, :value, :hash, :array].sample
+        val_type = :value if level > 4 || rand(0.1) == 0
+
+        case val_type
+          when :class, :hash, :array
+            val, expected = create_value(level + 2, val_type, options)
+
+          when :value
+            val      = create_simple_value([:value_simple, :value_string, :value_method, :value_complex_string].sample, options)
+            expected = val
+        end
+
+        value_val << "#{append_value}#{name}#{create_simple_value(:whitespace, options)}=#{create_simple_value(:whitespace, options)}#{val}"
+        if val_type == :value
+          value_expect << "#{append_expect}#{"  " * (level + 1)}#{name} = #{expected}"
+        else
+          value_expect << "#{append_expect}#{"  " * (level + 1)}#{name} =\n#{expected}"
+        end
+
+        append_value  = ",#{create_simple_value(:whitespace, options)}"
+        append_expect = ",\n"
+      end
+
+      unless append_expect.empty?
+        append_expect = append_expect[1..-1]
+      end
+      unless append_expect.empty?
+        append_expect << "  " * level
+      end
+
+      value_val << "#{"  " * rand(0..10)}>"
+      value_expect << "#{append_expect}>"
+
+    when :implied_hash
+      options.merge!({ spaces_only: true })
+
+      name          = create_simple_value(:value_name_simple, options)
+      value_val     = "\#<#{name}#{" " * rand(1..10)}"
+      value_expect  = "#{"  " * level}\#<#{name}"
+      append_value  = ""
+      append_expect = "\n"
+
+      rand(1..5).times do
+        hash_type = [:hash_key_reversed_symbol, :hash_key_symbol].sample
+        name      = create_simple_value(hash_type, options)
+        val_type  = [:class, :value, :hash, :array].sample
+        val_type  = :value if level > 4 || rand(0.1) == 0
+
+        case val_type
+          when :class, :hash, :array
+            val, expected = create_value(level + 2, val_type, options)
+
+          when :value
+            val      = create_simple_value([:value_simple, :value_string, :value_method, :value_complex_string].sample, options)
+            expected = val
+        end
+
+        case hash_type
+          when :hash_key_reversed_symbol
+            value_val << "#{append_value}#{name}#{" " * rand(0..10)}#{val}"
+            if val_type == :value
+              value_expect << "#{append_expect}#{"  " * (level + 1)}#{name} #{expected}"
+            else
+              value_expect << "#{append_expect}#{"  " * (level + 1)}#{name}\n#{expected}"
+            end
+
+          else
+            value_val << "#{append_value}#{name}#{" " * rand(0..10)}=>#{" " * rand(0..10)}#{val}"
+            if val_type == :value
+              value_expect << "#{append_expect}#{"  " * (level + 1)}#{name} => #{expected}"
+            else
+              value_expect << "#{append_expect}#{"  " * (level + 1)}#{name} =>\n#{expected}"
+            end
+        end
+
+        append_value  = ",#{create_simple_value(:whitespace, options)}"
+        append_expect = ",\n"
+      end
+
+      value_val << "#{create_simple_value(:whitespace, options)}>"
+      value_expect << "\n#{"  " * level}>"
+
+    when :hash
+      value_val     = "{#{create_simple_value(:whitespace, options)}"
+      value_expect  = "#{"  " * level}{\n"
+      append_value  = ""
+      append_expect = ""
+
+      rand(1..5).times do
+        hash_type = [:hash_key_string, :hash_key_complex_string, :hash_key_symbol, :hash_key_reversed_symbol].sample
+        name      = create_simple_value(hash_type, options)
+        val_type  = [:class, :value, :hash, :array].sample
+        val_type  = :value if level > 4 || rand(0.1) == 0
+
+        case val_type
+          when :class, :hash, :array
+            val, expected = create_value(level + 2, val_type, options)
+
+          when :value
+            val      = create_simple_value([:value_simple, :value_string, :value_method, :value_complex_string].sample, options)
+            expected = val
+        end
+
+        case hash_type
+          when :hash_key_reversed_symbol
+            value_val << "#{append_value}#{name}#{create_simple_value(:whitespace, options)}#{val}"
+            if val_type == :value
+              value_expect << "#{append_expect}#{"  " * (level + 1)}#{name} #{expected}"
+            else
+              value_expect << "#{append_expect}#{"  " * (level + 1)}#{name}\n#{expected}"
+            end
+
+          else
+            value_val << "#{append_value}#{name}#{create_simple_value(:whitespace, options)}=>#{create_simple_value(:whitespace, options)}#{val}"
+            if val_type == :value
+              value_expect << "#{append_expect}#{"  " * (level + 1)}#{name} => #{expected}"
+            else
+              value_expect << "#{append_expect}#{"  " * (level + 1)}#{name} =>\n#{expected}"
+            end
+        end
+
+        append_value  = ",#{create_simple_value(:whitespace, options)}"
+        append_expect = ",\n"
+      end
+
+      value_val << "#{create_simple_value(:whitespace, options)}}"
+      value_expect << "\n#{"  " * level}}"
+
+    when :array
+      value_val     = "[#{create_simple_value(:whitespace, options)}"
+      value_expect  = "#{"  " * level}[\n"
+      append_value  = ""
+      append_expect = ""
+
+      rand(1..5).times do
+        val_type = [:class, :value, :hash, :array].sample
+        val_type = :value if level > 4 || rand(0.1) == 0
+
+        case val_type
+          when :class, :hash, :array
+            val, expected = create_value(level + 1, val_type, options)
+
+          when :value
+            val      = create_simple_value([:value_simple, :value_string, :value_method, :value_complex_string].sample, options)
+            expected = "#{"  " * (level + 1)}#{val}"
+        end
+
+        value_val << "#{append_value}#{val}"
+        value_expect << "#{append_expect}#{expected}"
+
+        append_value  = ",#{create_simple_value(:whitespace, options)}"
+        append_expect = ",\n"
+      end
+
+      value_val << "#{create_simple_value(:whitespace, options)}]"
+      value_expect << "\n#{"  " * level}]"
+  end
+
+  [value_val, value_expect]
+end
+
+def expectation_in_text(expected_text, pre_text, post_text)
+  expected = "#{pre_text}#{expected_text}#{post_text}"
+  expected = expected.gsub("\n", "\n  ") unless pre_text.empty?
+  expected = expected.gsub(post_text.gsub("\n", "\n  "), post_text)
+
+  expected
+end