ashtonw-slather 1.8.2

data/spec/slather/coverage_service/gutter_json_spec.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+require 'json'
+
+describe Slather::CoverageService::GutterJsonOutput do
+
+  let(:fixtures_project) do
+    proj = Slather::Project.open(FIXTURES_PROJECT_PATH)
+    proj.extend(Slather::CoverageService::GutterJsonOutput)
+  end
+
+  describe '#coverage_file_class' do
+    it "should return CoverageFile" do
+      expect(fixtures_project.send(:coverage_file_class)).to eq(Slather::CoverageFile)
+    end
+  end
+
+  describe '#post' do
+    it "should print out the coverage for each file, and then total coverage" do
+      fixtures_project.post
+
+      fixture_json = File.read(FIXTURES_JSON_PATH)
+      current_json = File.read('.gutter.json')
+
+      expect(current_json).to be_json_eql(fixture_json)
+      File.unlink('.gutter.json')
+    end
+  end
+end

data/spec/slather/coverage_service/hardcover_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Slather::CoverageService::Hardcover do
+
+  let(:fixtures_project) do
+    proj = Slather::Project.open(FIXTURES_PROJECT_PATH)
+    proj.extend(Slather::CoverageService::Hardcover)
+  end
+
+  let(:fixture_yaml) do
+      yaml_text = <<-EOF
+        hardcover_repo_token: "27dd855e706b22126ec6daaaf7bb40b5"
+        hardcover_base_url: "http://api.hardcover.io"
+      EOF
+      yaml = YAML.load(yaml_text)
+  end
+
+  describe "#coverage_file_class" do
+    it "should return CoverallsCoverageFile" do
+      expect(fixtures_project.send(:coverage_file_class)).to eq(Slather::CoverallsCoverageFile)
+    end
+  end
+
+  describe "#job_id" do
+    it "should return the Jenkins JOB_NAME and BUILD_NUMBER environment variables" do
+      ENV['BUILD_NUMBER'] = "9182"
+      ENV['JOB_NAME'] = "slather-master"
+      expect(fixtures_project.send(:jenkins_job_id)).to eq("slather-master/9182")
+    end
+  end
+
+  describe '#hardcover_coverage_data' do
+
+    context "coverage_service is :jenkins_ci" do
+      before(:each) do
+        fixtures_project.ci_service = :jenkins_ci
+        Slather::Project.stub(:yml).and_return(fixture_yaml)
+      end
+
+      it "should return a valid json" do
+        json = JSON(fixtures_project.send(:hardcover_coverage_data))
+        expect(json["service_job_id"]).to eq("slather-master/9182")
+        expect(json["service_name"]).to eq("jenkins-ci")
+        expect(json["repo_token"]).to eq("27dd855e706b22126ec6daaaf7bb40b5")
+        expect(json["source_files"]).to_not be_empty
+      end
+
+      it "should raise an error if there is no BUILD_NUMBER or JOB_NAME" do
+        fixtures_project.stub(:jenkins_job_id).and_return(nil)
+        expect { fixtures_project.send(:hardcover_coverage_data) }.to raise_error(StandardError)
+      end
+    end
+
+    it "should raise an error if it does not recognize the ci_service" do
+      fixtures_project.ci_service = :non_existing_ci
+      expect { fixtures_project.send(:hardcover_coverage_data) }.to raise_error(StandardError)
+    end
+  end
+
+  describe '#post' do
+    before(:each) do
+      Slather::Project.stub(:yml).and_return(fixture_yaml)
+      fixtures_project.ci_service = :jenkins_ci
+    end
+
+    it "should save the hardcover_coverage_data to a file and post it to hardcover" do
+      fixtures_project.stub(:jenkins_job_id).and_return("slather-master/9182")
+      fixtures_project.stub(:coverage_service_url).and_return("http://api.hardcover.io")
+      expect(fixtures_project).to receive(:`) do |cmd|
+        expect(cmd).to eq("curl --form json_file=@hardcover_json_file http://api.hardcover.io/v1/jobs")
+      end.once
+      fixtures_project.post
+    end
+
+    it "should always remove the hardcover_json_file after it's done" do
+      fixtures_project.stub(:`)
+
+      fixtures_project.stub(:jenkins_job_id).and_return("slather-master/9182")
+      fixtures_project.stub(:coverage_service_url).and_return("http://api.hardcover.io")
+      fixtures_project.post
+      expect(File.exist?("hardcover_json_file")).to be_falsy
+      fixtures_project.stub(:jenkins_job_id).and_return(nil)
+      expect { fixtures_project.post }.to raise_error
+      expect(File.exist?("hardcover_json_file")).to be_falsy
+    end
+  end
+end

data/spec/slather/coverage_service/html_output_spec.rb

@@ -0,0 +1,179 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+require 'nokogiri'
+
+describe Slather::CoverageService::HtmlOutput do
+
+  OUTPUT_DIR_PATH = "html"
+
+  let(:fixture_html_files) do
+    ["index",
+    "fixtures.m",
+    "peekaview.m",
+    "fixtures_cpp.cpp",
+    "fixtures_mm.mm",
+    "fixtures_m.m",
+    "Branches.m",
+    "Empty.m",
+    "fixturesTests.m",
+    "peekaviewTests.m",
+    "BranchesTests.m"].map { |file| "#{file}.html"}
+  end
+
+  let(:fixtures_project) do
+    proj = Slather::Project.open(FIXTURES_PROJECT_PATH)
+    proj.extend(Slather::CoverageService::HtmlOutput)
+  end
+
+  describe '#coverage_file_class' do
+    it "should return CoverageFile" do
+      expect(fixtures_project.send(:coverage_file_class)).to eq(Slather::CoverageFile)
+    end
+  end
+
+  describe '#post' do
+    before(:each) {
+      fixtures_project.stub(:print_path_coverage)
+    }
+
+    after(:each) {
+      FileUtils.rm_rf(OUTPUT_DIR_PATH) if Dir.exist?(OUTPUT_DIR_PATH)
+    }
+
+    def extract_header_title(doc)
+      doc.at_css('title').text
+    end
+
+    it "should create all coverage as static html files" do
+      fixtures_project.post
+
+      fixture_html_files.map { |filename|
+        File.join(OUTPUT_DIR_PATH, filename)
+      }.each { |filepath|
+        expect(File.exist?(filepath)).to be_truthy
+      }
+    end
+
+    it "should print out the path of the html folder by default" do
+      fixtures_project.post
+
+      expect(fixtures_project).to have_received(:print_path_coverage).with("html/index.html")
+    end
+
+    it "should open the index.html automatically if --show is flagged" do
+      fixtures_project.stub(:open_coverage)
+
+      fixtures_project.show_html = true
+      fixtures_project.post
+
+      expect(fixtures_project).to have_received(:open_coverage).with("html/index.html")
+    end
+
+    it "should create index html with correct coverage information" do
+      def extract_title(doc)
+        doc.at_css('#reports > h2').text
+      end
+
+      def extract_coverage_text(doc)
+        doc.at_css('#total_coverage').text
+      end
+
+      def extract_coverage_class(doc)
+        doc.at_css('#total_coverage').attribute("class").to_s
+      end
+
+      def extract_cov_header(doc)
+        doc.css("table.coverage_list > thead > tr > th").map { |header|
+          [header.text, header.attribute("data-sort")].join(", ")
+        }.join("; ")
+      end
+
+      def extract_cov_index(doc)
+        coverages = doc.css("table.coverage_list > tbody > tr").map { |tr|
+          tr.css("td").map { |td|
+            if td.attribute("class")
+              td.attribute("class").to_s.split.join(", ") + ", #{td.text}"
+            elsif span = td.at_css("span")
+              span.attribute("class").to_s.split.join(", ")  + ", #{td.text}"
+            else
+              td.text
+            end
+          }.join("; ")
+        }
+
+        list = doc.css("table.coverage_list > tbody").attribute("class")
+        coverages.append(list.to_s)
+      end
+
+      fixtures_project.post
+
+      file = File.open(File.join(FIXTURES_HTML_FOLDER_PATH, "index.html"))
+      fixture_doc = Nokogiri::HTML(file)
+      file.close
+
+      file = File.open(File.join(OUTPUT_DIR_PATH, "index.html"))
+      current_doc = Nokogiri::HTML(file)
+      file.close
+
+      expect(extract_header_title(current_doc)).to eq(extract_header_title(fixture_doc))
+      expect(extract_title(current_doc)).to eq(extract_title(fixture_doc))
+      expect(extract_coverage_text(current_doc)).to eq(extract_coverage_text(fixture_doc))
+      expect(extract_coverage_class(current_doc)).to eq(extract_coverage_class(fixture_doc))
+      expect(extract_cov_header(current_doc)).to eq(extract_cov_header(fixture_doc))
+      expect(extract_cov_index(current_doc)).to eq(extract_cov_index(fixture_doc))
+    end
+
+    it "should create html coverage for each file with correct coverage" do
+      def extract_title(doc)
+        doc.css('#coverage > h2 > span').map{ |x| x.text.strip }.join(", ")
+      end
+
+      def extract_subtitle(doc)
+        (sub = doc.at_css('h4.cov_subtitle')) ? sub.text : ""
+      end
+
+      def extract_filepath(doc)
+        (path = doc.at_css('h4.cov_filepath'))? path.text : ""
+      end
+
+      def extract_cov_data(doc)
+        doc.css("table.source_code > tr").map { |tr|
+          ([tr.attribute("class")] + tr.css('td').map(&:text)).join(",")
+        }
+      end
+
+      fixtures_project.post
+
+      fixture_html_files.each { |filename|
+        file = File.open(File.join(FIXTURES_HTML_FOLDER_PATH, filename))
+        fixture_doc = Nokogiri::HTML(file)
+        file.close
+
+        file = File.open(File.join(OUTPUT_DIR_PATH, filename))
+        current_doc = Nokogiri::HTML(file)
+        file.close
+
+        expect(extract_title(fixture_doc)).to eq(extract_title(current_doc))
+        expect(extract_subtitle(fixture_doc)).to eq(extract_subtitle(current_doc))
+        expect(extract_filepath(fixture_doc)).to eq(extract_filepath(current_doc))
+        expect(extract_cov_data(fixture_doc)).to eq(extract_cov_data(current_doc))
+      }
+    end
+
+    it "should create an HTML report directory in the given output directory" do
+      fixtures_project.output_directory = "./output"
+      fixtures_project.post
+
+      expect(Dir.exist?(fixtures_project.output_directory)).to be_truthy
+
+      FileUtils.rm_rf(fixtures_project.output_directory) if Dir.exist?(fixtures_project.output_directory)
+    end
+
+    it "should create the default directory (html) if output directory is faulty" do
+      fixtures_project.output_directory = "  "
+      fixtures_project.post
+
+      expect(Dir.exist?(OUTPUT_DIR_PATH)).to be_truthy
+    end
+
+  end
+end

data/spec/slather/coverage_service/simple_output_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Slather::CoverageService::SimpleOutput do
+
+  let(:fixtures_project) do
+    proj = Slather::Project.open(FIXTURES_PROJECT_PATH)
+    proj.extend(Slather::CoverageService::SimpleOutput)
+  end
+
+  describe '#coverage_file_class' do
+    it "should return CoverageFile" do
+      expect(fixtures_project.send(:coverage_file_class)).to eq(Slather::CoverageFile)
+    end
+  end
+
+  describe '#post' do
+    it "should print out the coverage for each file, and then total coverage" do
+      ["spec/fixtures/fixtures/fixtures.m: 2 of 4 lines (50.00%)",
+      "spec/fixtures/fixtures/more_files/peekaview.m: 0 of 6 lines (0.00%)",
+      "spec/fixtures/fixtures/fixtures_cpp.cpp: 0 of 0 lines (100.00%)",
+      "spec/fixtures/fixtures/fixtures_mm.mm: 0 of 0 lines (100.00%)",
+      "spec/fixtures/fixtures/fixtures_m.m: 0 of 0 lines (100.00%)",
+      "spec/fixtures/fixtures/more_files/Branches.m: 10 of 20 lines (50.00%)",
+      "spec/fixtures/fixtures/more_files/Empty.m: 0 of 0 lines (100.00%)",
+      "spec/fixtures/fixturesTests/fixturesTests.m: 7 of 7 lines (100.00%)",
+      "spec/fixtures/fixturesTests/peekaviewTests.m: 6 of 6 lines (100.00%)",
+      "spec/fixtures/fixturesTests/BranchesTests.m: 10 of 10 lines (100.00%)",
+      "Test Coverage: 66.04%"].each do |line|
+        expect(fixtures_project).to receive(:puts).with(line)
+      end
+
+      fixtures_project.post
+    end
+  end
+end

data/spec/slather/project_spec.rb

@@ -0,0 +1,288 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Slather::Project do
+
+  let(:fixtures_project) do
+    Slather::Project.any_instance.stub(:configure_from_yml)
+    Slather::Project.open(FIXTURES_PROJECT_PATH)
+  end
+
+  describe "::open" do
+    it "should return a project instance that has been configured from yml" do
+      expect_any_instance_of(Slather::Project).to receive(:configure_from_yml)
+      expect(fixtures_project).not_to be_nil
+    end
+  end
+
+  describe "#derived_data_dir" do
+    it "should return the system's derived data directory" do
+      expect(fixtures_project.send(:derived_data_dir)).to eq(File.expand_path('~') + "/Library/Developer/Xcode/DerivedData/")
+    end
+  end
+
+  describe "#build_directory" do
+    it "should return the build_directory property, if it has been explicitly set" do
+      build_directory_mock = double(String)
+      fixtures_project.build_directory = build_directory_mock
+      expect(fixtures_project.build_directory).to eq(build_directory_mock)
+    end
+
+    it "should return the derived_data_dir if no build_directory has been set" do
+      derived_data_dir_mock = double(String)
+      fixtures_project.stub(:derived_data_dir).and_return(derived_data_dir_mock)
+      expect(fixtures_project.build_directory).to eq(derived_data_dir_mock)
+    end
+  end
+
+  describe "::yml" do
+    before(:each) { Slather::Project.instance_variable_set("@yml", nil) }
+
+    context ".slather.yml file exists" do
+      before(:all) { File.open(".slather.yml", "w") { |f| f.write("two: 2") } }
+      after(:all) { File.delete(".slather.yml") }
+
+      it "should load and return .slather.yml, if it exists" do
+        expect(Slather::Project.yml).to eq({"two" => 2})
+      end
+    end
+
+    context ".slather.yml file doesn't exist" do
+      it "should return an empy hash" do
+        expect(Slather::Project.yml).to eq({})
+      end
+    end
+  end
+
+  describe "#coverage_files" do
+    class SpecCoverageFile < Slather::CoverageFile
+    end
+
+    before(:each) do
+      Dir.stub(:[]).and_call_original
+      Dir.stub(:[]).with("#{fixtures_project.build_directory}/**/*.gcno").and_return(["/some/path/fixtures.gcno",
+                                                                                  "/some/path/peekaview.gcno",
+                                                                                  "/some/path/fixturesTests.gcno",
+                                                                                  "/some/path/peekaviewTests.gcno",
+                                                                                  "/some/path/NotInProject.gcno",
+                                                                                  "/some/path/NSRange.gcno"])
+      fixtures_project.stub(:coverage_file_class).and_return(SpecCoverageFile)
+    end
+
+    it "should return coverage file objects of type coverage_file_class for unignored project files" do
+      fixtures_project.ignore_list = ["*fixturesTests*"]
+      fixtures_project.stub(:dedupe) { |coverage_files| coverage_files }
+      coverage_files = fixtures_project.send(:coverage_files)
+      coverage_files.each { |cf| expect(cf.kind_of?(SpecCoverageFile)).to be_truthy }
+      expect(coverage_files.map { |cf| cf.source_file_pathname.basename.to_s }).to eq(["fixtures.m", "peekaview.m"])
+    end
+
+    it "should raise an exception if no unignored project coverage file files were found" do
+      fixtures_project.ignore_list = ["*fixturesTests*", "*fixtures*"]
+      expect {fixtures_project.send(:coverage_files)}.to raise_error(StandardError)
+    end
+  end
+
+  describe "#dedupe" do
+    it "should return a deduplicated list of coverage files, favoring the file with higher coverage" do
+      coverage_file_1 = double(Slather::CoverageFile)
+      coverage_file_1.stub(:source_file_pathname).and_return("some/path/class1.m")
+      coverage_file_1.stub(:percentage_lines_tested).and_return(100)
+
+      coverage_file_2 = double(Slather::CoverageFile)
+      coverage_file_2.stub(:source_file_pathname).and_return("some/path/class2.m")
+      coverage_file_2.stub(:percentage_lines_tested).and_return(100)
+
+      coverage_file_2b = double(Slather::CoverageFile)
+      coverage_file_2b.stub(:source_file_pathname).and_return("some/path/class2.m")
+      coverage_file_2b.stub(:percentage_lines_tested).and_return(0)
+
+      coverage_files = [coverage_file_1, coverage_file_2, coverage_file_2b]
+      deduped_coverage_files = fixtures_project.send(:dedupe, coverage_files)
+      expect(deduped_coverage_files.size).to eq(2)
+      expect(deduped_coverage_files).to include(coverage_file_1)
+      expect(deduped_coverage_files).to include(coverage_file_2)
+    end
+  end
+
+  describe "#configure_from_yml" do
+    it "should configure all properties from the yml" do
+      unstubbed_project = Slather::Project.open(FIXTURES_PROJECT_PATH)
+      expect(unstubbed_project).to receive(:configure_build_directory_from_yml)
+      expect(unstubbed_project).to receive(:configure_source_directory_from_yml)
+      expect(unstubbed_project).to receive(:configure_ignore_list_from_yml)
+      expect(unstubbed_project).to receive(:configure_ci_service_from_yml)
+      expect(unstubbed_project).to receive(:configure_coverage_service_from_yml)
+      unstubbed_project.configure_from_yml
+    end
+  end
+
+  describe "#configure_ignore_list_from_yml" do
+    it "should set the ignore_list if it has been provided in the yml and has not already been set" do
+      Slather::Project.stub(:yml).and_return({"ignore" => ["test", "ing"] })
+      fixtures_project.configure_ignore_list_from_yml
+      expect(fixtures_project.ignore_list).to eq(["test", "ing"])
+    end
+
+    it "should force the ignore_list into an array" do
+      Slather::Project.stub(:yml).and_return({"ignore" => "test" })
+      fixtures_project.configure_ignore_list_from_yml
+      expect(fixtures_project.ignore_list).to eq(["test"])
+    end
+
+    it "should not set the ignore_list if it has already been set" do
+      Slather::Project.stub(:yml).and_return({"ignore" => ["test", "ing"] })
+      fixtures_project.ignore_list = ["already", "set"]
+      fixtures_project.configure_ignore_list_from_yml
+      expect(fixtures_project.ignore_list).to eq(["already", "set"])
+    end
+
+    it "should default the ignore_list to an empty array if nothing is provided in the yml" do
+      Slather::Project.stub(:yml).and_return({})
+      fixtures_project.configure_ignore_list_from_yml
+      expect(fixtures_project.ignore_list).to eq([])
+    end
+  end
+
+  describe "#configure_build_directory_from_yml" do
+    it "should set the build_directory if it has been provided in the yml and has not already been set" do
+      Slather::Project.stub(:yml).and_return({"build_directory" => "/some/path"})
+      fixtures_project.configure_build_directory_from_yml
+      expect(fixtures_project.build_directory).to eq("/some/path")
+    end
+
+    it "should not set the build_directory if it has already been set" do
+      Slather::Project.stub(:yml).and_return({"build_directory" => "/some/path"})
+      fixtures_project.build_directory = "/already/set"
+      fixtures_project.configure_build_directory_from_yml
+      expect(fixtures_project.build_directory).to eq("/already/set")
+    end
+
+    it "should default the build_directory to derived data if nothing is provided in the yml" do
+      Slather::Project.stub(:yml).and_return({})
+      fixtures_project.configure_build_directory_from_yml
+      expect(fixtures_project.build_directory).to eq(fixtures_project.send(:derived_data_dir))
+    end
+  end
+
+  describe "#configure_source_directory_from_yml" do
+    it "should set the source_directory if it has been provided in the yml and has not already been set" do
+      Slather::Project.stub(:yml).and_return({"source_directory" => "/some/path"})
+      fixtures_project.configure_source_directory_from_yml
+      expect(fixtures_project.source_directory).to eq("/some/path")
+    end
+
+    it "should not set the source_directory if it has already been set" do
+      Slather::Project.stub(:yml).and_return({"source_directory" => "/some/path"})
+      fixtures_project.source_directory = "/already/set"
+      fixtures_project.configure_source_directory_from_yml
+      expect(fixtures_project.source_directory).to eq("/already/set")
+    end
+  end
+
+  describe "#configure_output_directory_from_yml" do
+    it "should set the output_directory if it has been provided in the yml and has not already been set" do
+      Slather::Project.stub(:yml).and_return({"output_directory" => "/some/path"})
+      fixtures_project.configure_output_directory_from_yml
+      expect(fixtures_project.output_directory).to eq("/some/path")
+    end
+
+    it "should not set the output_directory if it has already been set" do
+      Slather::Project.stub(:yml).and_return({"output_directory" => "/some/path"})
+      fixtures_project.output_directory = "/already/set"
+      fixtures_project.configure_output_directory_from_yml
+      expect(fixtures_project.output_directory).to eq("/already/set")
+    end
+  end
+
+  describe "#configure_ci_service_from_yml" do
+    it "should set the ci_service if it has been provided in the yml and has not already been set" do
+      Slather::Project.stub(:yml).and_return({"ci_service" => "some_service"})
+      fixtures_project.configure_ci_service_from_yml
+      expect(fixtures_project.ci_service).to eq(:some_service)
+    end
+
+    it "should not set the ci_service if it has already been set" do
+      Slather::Project.stub(:yml).and_return({"ci_service" => "some service"})
+      fixtures_project.ci_service = "already_set"
+      fixtures_project.configure_ci_service_from_yml
+      expect(fixtures_project.ci_service).to eq(:already_set)
+    end
+
+    it "should default the ci_service to :travis_ci if nothing is provided in the yml" do
+      Slather::Project.stub(:yml).and_return({})
+      fixtures_project.configure_ci_service_from_yml
+      expect(fixtures_project.ci_service).to eq(:travis_ci)
+    end
+  end
+
+  describe "#ci_service=" do
+    it "should set the ci_service as a symbol" do
+      fixtures_project.ci_service = "foobar"
+      expect(fixtures_project.ci_service).to eq(:foobar)
+    end
+  end
+
+  describe "#configure_coverage_service_from_yml" do
+    it "should set the coverage_service if it has been provided by the yml" do
+      Slather::Project.stub(:yml).and_return({"coverage_service" => "some_service"})
+      expect(fixtures_project).to receive(:coverage_service=).with("some_service")
+      fixtures_project.configure_coverage_service_from_yml
+    end
+
+    it "should default the coverage_service to :terminal if nothing is provided in the yml" do
+      Slather::Project.stub(:yml).and_return({})
+      expect(fixtures_project).to receive(:coverage_service=).with(:terminal)
+      fixtures_project.configure_coverage_service_from_yml
+    end
+
+    it "should not set the coverage_service if it has already been set" do
+      Slather::Project.stub(:yml).and_return({"coverage_service" => "some_service" })
+      fixtures_project.stub(:coverage_service).and_return("already set")
+      expect(fixtures_project).to_not receive(:coverage_service=)
+      fixtures_project.configure_coverage_service_from_yml
+    end
+  end
+
+  describe "#configure_coverage_access_token" do
+    it "should set the coverage_access_token if it has been provided by the yml" do
+      Slather::Project.stub(:yml).and_return({"coverage_access_token" => "abc123"})
+      expect(fixtures_project).to receive(:coverage_access_token=).with("abc123")
+      fixtures_project.configure_coverage_access_token_from_yml
+    end
+    
+    it "should set the coverage_access_token if it is in the ENV" do
+      stub_const('ENV', ENV.to_hash.merge('COVERAGE_ACCESS_TOKEN' => 'asdf456'))
+      expect(fixtures_project).to receive(:coverage_access_token=).with("asdf456")
+      fixtures_project.configure_coverage_access_token_from_yml
+    end
+    
+  end
+
+  describe "#coverage_service=" do
+    it "should extend Slather::CoverageService::Coveralls and set coverage_service = :coveralls if given coveralls" do
+      expect(fixtures_project).to receive(:extend).with(Slather::CoverageService::Coveralls)
+      fixtures_project.coverage_service = "coveralls"
+      expect(fixtures_project.coverage_service).to eq(:coveralls)
+    end
+
+    it "should extend Slather::CoverageService::SimpleOutput and set coverage_service = :terminal if given terminal" do
+      expect(fixtures_project).to receive(:extend).with(Slather::CoverageService::SimpleOutput)
+      fixtures_project.coverage_service = "terminal"
+      expect(fixtures_project.coverage_service).to eq(:terminal)
+    end
+
+    it "should raise an exception if it does not recognize the coverage service" do
+      expect { fixtures_project.coverage_service = "xcode bots, lol" }.to raise_error(StandardError)
+    end
+  end
+
+  describe "#slather_setup_for_coverage" do
+    it "should enable the correct flags to generate test coverage on all of the build_configurations build settings" do
+      fixtures_project.slather_setup_for_coverage
+      fixtures_project.build_configurations.each do |build_configuration|
+        expect(build_configuration.build_settings["GCC_INSTRUMENT_PROGRAM_FLOW_ARCS"]).to eq("YES")
+        expect(build_configuration.build_settings["GCC_GENERATE_TEST_COVERAGE_FILES"]).to eq("YES")
+      end
+    end
+  end
+end