foreman 0.31.0 → 0.50.0

data/spec/foreman/cli_spec.rb

@@ -1,12 +1,25 @@
 require "spec_helper"
 require "foreman/cli"
 
-describe "Foreman::CLI" do
+describe "Foreman::CLI", :fakefs do
   subject { Foreman::CLI.new }
 
+  describe ".foreman" do
+    before { File.open(".foreman", "w") { |f| f.puts "formation: alpha=2" } }
+
+    it "provides default options" do
+      subject.send(:options)["formation"].should == "alpha=2"
+    end
+
+    it "is overridden by options at the cli" do
+      subject = Foreman::CLI.new([], :formation => "alpha=3")
+      subject.send(:options)["formation"].should == "alpha=3"
+    end
+  end
+
   describe "start" do
-    describe "with a non-existent Procfile" do
-      it "prints an error" do
+    describe "when a Procfile doesnt exist", :fakefs do
+      it "displays an error" do
         mock_error(subject, "Procfile does not exist.") do
           dont_allow.instance_of(Foreman::Engine).start
           subject.start
@@ -14,79 +27,60 @@ describe "Foreman::CLI" do
       end
     end
 
-    describe "with a Procfile" do
-      before(:each) { write_procfile }
+    describe "with a valid Procfile" do
+      it "can run a single command" do
+        without_fakefs do
+          output = foreman("start env -f #{resource_path("Procfile")}")
+          output.should     =~ /env.1/
+          output.should_not =~ /test.1/
+        end
+      end
 
-      it "runs successfully" do
-        dont_allow(subject).error
-        mock.instance_of(Foreman::Engine).start
-        subject.start
+      it "can run all commands" do
+        without_fakefs do
+          output = foreman("start -f #{resource_path("Procfile")} -e #{resource_path(".env")}")
+          output.should =~ /echo.1 \| echoing/
+          output.should =~ /env.1  \| bar/
+          output.should =~ /test.1 \| testing/
+        end
       end
     end
   end
 
-  describe "export" do
-    describe "options" do
-      it "respects --env" do
-        write_procfile
-        write_env("envfile")
-        mock.instance_of(Foreman::Export::Upstart).export("/upstart", { "env" => "envfile" })
-        foreman %{ export upstart /upstart --env envfile }
-      end
+  describe "check" do
+    it "with a valid Procfile displays the jobs" do
+      write_procfile
+      foreman("check").should == "valid procfile detected (alpha, bravo)\n"
     end
 
-    describe "with a non-existent Procfile" do
-      it "prints an error" do
-        mock_error(subject, "Procfile does not exist.") do
-          dont_allow.instance_of(Foreman::Engine).export
-          subject.export("testapp")
-        end
-      end
+    it "with a blank Procfile displays an error" do
+      FileUtils.touch "Procfile"
+      foreman("check").should == "ERROR: no processes defined\n"
     end
 
-    describe "with a Procfile" do
-      before(:each) { write_procfile }
-
-      describe "with an invalid formatter" do
-        it "prints an error" do
-          mock_error(subject, "Unknown export format: invalidformatter.") do
-            subject.export("invalidformatter")
-          end
-        end
-      end
-
-      describe "with a valid config" do
-        before(:each) { write_foreman_config("testapp") }
-
-        it "runs successfully" do
-          dont_allow(subject).error
-          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {})
-          subject.export("upstart", "/tmp/foo")
-        end
-      end
+    it "without a Procfile displays an error" do
+      FileUtils.rm_f "Procfile"
+      foreman("check").should == "ERROR: Procfile does not exist.\n"
     end
   end
 
-  describe "check" do
-    describe "with a valid Procfile" do
-      before { write_procfile }
+  describe "run" do
+    it "can run a command" do
+      forked_foreman("run echo 1").should == "1\n"
+    end
 
-      it "displays the jobs" do
-        mock(subject).display("valid procfile detected (alpha, bravo)")
-        subject.check
-      end
+    it "includes the environment" do
+      forked_foreman("run #{resource_path("bin/env FOO")} -e #{resource_path(".env")}").should == "bar\n"
     end
+  end
 
-    describe "with a blank Procfile" do
-      before do
-        FileUtils.touch("Procfile")
-      end
+  describe "version" do
+    it "displays gem version" do
+      foreman("version").chomp.should == Foreman::VERSION
+    end
 
-      it "displays an error" do
-        mock_error(subject, "no processes defined") do
-          subject.check
-        end
-      end
+    it "displays gem version on shortcut command" do
+      foreman("-v").chomp.should == Foreman::VERSION
     end
   end
 

data/spec/foreman/engine_spec.rb

@@ -1,86 +1,104 @@
 require "spec_helper"
 require "foreman/engine"
 
-describe "Foreman::Engine" do
-  subject { Foreman::Engine.new("Procfile", {}) }
+class Foreman::Engine::Tester < Foreman::Engine
+  attr_reader :buffer
 
-  describe "initialize" do
-    describe "without an existing Procfile" do
-      it "raises an error" do
-        lambda { subject }.should raise_error
-      end
-    end
+  def startup
+    @buffer = ""
+  end
+
+  def output(name, data)
+    @buffer += "#{name}: #{data}"
+  end
+
+  def shutdown
+  end
+end
+
+describe "Foreman::Engine", :fakefs do
+  subject do
+    write_procfile "Procfile"
+    Foreman::Engine::Tester.new.load_procfile("Procfile")
+  end
 
+  describe "initialize" do
     describe "with a Procfile" do
       before { write_procfile }
 
       it "reads the processes" do
-        subject.procfile["alpha"].command.should == "./alpha"
-        subject.procfile["bravo"].command.should == "./bravo"
+        subject.process("alpha").command.should == "./alpha"
+        subject.process("bravo").command.should == "./bravo"
       end
     end
   end
 
   describe "start" do
     it "forks the processes" do
-      write_procfile
-      mock.instance_of(Foreman::Process).run_process("./alpha", is_a(IO))
-      mock.instance_of(Foreman::Process).run_process("./bravo", is_a(IO))
+      mock(subject.process("alpha")).run(anything)
+      mock(subject.process("bravo")).run(anything)
       mock(subject).watch_for_output
       mock(subject).watch_for_termination
       subject.start
     end
 
     it "handles concurrency" do
-      write_procfile
-      engine = Foreman::Engine.new("Procfile",:concurrency => "alpha=2")
-      mock.instance_of(Foreman::Process).run_process("./alpha", is_a(IO)).twice
-      mock.instance_of(Foreman::Process).run_process("./bravo", is_a(IO))
-      mock(engine).watch_for_output
-      mock(engine).watch_for_termination
-      engine.start
+      subject.options[:formation] = "alpha=2"
+      mock(subject.process("alpha")).run(anything).twice
+      mock(subject.process("bravo")).run(anything).never
+      mock(subject).watch_for_output
+      mock(subject).watch_for_termination
+      subject.start
     end
   end
 
-  describe "environment" do
-    before(:each) do
-      write_procfile
-      stub(Process).fork
+  describe "directories" do
+    it "has the directory default relative to the Procfile" do
+      write_procfile "/some/app/Procfile"
+      engine = Foreman::Engine.new.load_procfile("/some/app/Procfile")
+      engine.root.should == "/some/app"
     end
+  end
 
-    it "should read if specified" do
+  describe "environment" do
+    it "should read env files" do
       File.open("/tmp/env", "w") { |f| f.puts("FOO=baz") }
-      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
-      stub(engine).info
-      mock(engine).spawn_processes
-      mock(engine).watch_for_termination
-      engine.environment.should == {"FOO"=>"baz"}
-      engine.start
+      subject.load_env("/tmp/env")
+      subject.env["FOO"].should == "baz"
     end
 
     it "should read more than one if specified" do
       File.open("/tmp/env1", "w") { |f| f.puts("FOO=bar") }
       File.open("/tmp/env2", "w") { |f| f.puts("BAZ=qux") }
-      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env1,/tmp/env2")
-      stub(engine).info
-      mock(engine).spawn_processes
-      mock(engine).watch_for_termination
-      engine.environment.should == { "FOO"=>"bar", "BAZ"=>"qux" }
-      engine.start
+      subject.load_env "/tmp/env1"
+      subject.load_env "/tmp/env2"
+      subject.env["FOO"].should == "bar"
+      subject.env["BAZ"].should == "qux"
+    end
+
+    it "should handle quoted values" do
+      File.open("/tmp/env", "w") do |f|
+        f.puts 'FOO=bar'
+        f.puts 'BAZ="qux"'
+        f.puts "FRED='barney'"
+        f.puts 'OTHER="escaped\"quote"'
+      end
+      subject.load_env "/tmp/env"
+      subject.env["FOO"].should   == "bar"
+      subject.env["BAZ"].should   == "qux"
+      subject.env["FRED"].should  == "barney"
+      subject.env["OTHER"].should == 'escaped"quote'
     end
 
     it "should fail if specified and doesnt exist" do
-      mock.instance_of(Foreman::Engine).error("No such file: /tmp/env")
-      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
+      lambda { subject.load_env "/tmp/env" }.should raise_error(Errno::ENOENT)
     end
 
-    it "should read .env if none specified" do
-      File.open(".env", "w") { |f| f.puts("FOO=qoo") }
-      engine = Foreman::Engine.new("Procfile")
-      mock(engine).spawn_processes
-      mock(engine).watch_for_termination
-      engine.environment.should == {"FOO"=>"qoo"}
-      engine.start
+    it "should set port from .env if specified" do
+      File.open("/tmp/env", "w") { |f| f.puts("PORT=9000") }
+      subject.load_env "/tmp/env"
+      subject.send(:base_port).should == 9000
     end
   end
+
 end

data/spec/foreman/export/base_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export"
+
+describe "Foreman::Export::Base", :fakefs do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:location) { "/tmp/init" }
+  let(:engine)   { Foreman::Engine.new().load_procfile(procfile) }
+  let(:subject)  { Foreman::Export::Base.new(location, engine) }
+
+  it "has a say method for displaying info" do
+    mock(subject).puts("[foreman export] foo")
+    subject.send(:say, "foo")
+  end
+
+  it "raises errors as a Foreman::Export::Exception" do
+    lambda { subject.send(:error, "foo") }.should raise_error(Foreman::Export::Exception, "foo")
+  end
+end

data/spec/foreman/export/bluepill_spec.rb

@@ -3,17 +3,35 @@ require "foreman/engine"
 require "foreman/export/bluepill"
 require "tmpdir"
 
-describe Foreman::Export::Bluepill do
-  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
-  let(:engine) { Foreman::Engine.new(procfile) }
-  let(:bluepill) { Foreman::Export::Bluepill.new(engine) }
+describe Foreman::Export::Bluepill, :fakefs do
+  let(:procfile)  { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:formation) { nil }
+  let(:engine)    { Foreman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)   { Hash.new }
+  let(:bluepill)  { Foreman::Export::Bluepill.new("/tmp/init", engine, options) }
 
   before(:each) { load_export_templates_into_fakefs("bluepill") }
   before(:each) { stub(bluepill).say }
 
   it "exports to the filesystem" do
-    bluepill.export("/tmp/init", :concurrency => "alpha=2")
-    File.read("/tmp/init/app.pill").should == example_export_file("bluepill/app.pill")
+    bluepill.export
+    normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app.pill"))
+  end
+
+  it "cleans up if exporting into an existing dir" do
+    mock(FileUtils).rm("/tmp/init/app.pill")
+
+    bluepill.export
+    bluepill.export
+  end
+
+  context "with a process formation" do
+    let(:formation) { "alpha=2" }
+
+    it "exports to the filesystem with concurrency" do
+      bluepill.export
+      normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app-concurrency.pill"))
+    end
   end
 
 end

data/spec/foreman/export/inittab_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/inittab"
+require "tmpdir"
+
+describe Foreman::Export::Inittab, :fakefs do
+  let(:procfile)  { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:location)  { "/tmp/inittab" }
+  let(:formation) { nil }
+  let(:engine)    { Foreman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)   { Hash.new }
+  let(:inittab)   { Foreman::Export::Inittab.new(location, engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("inittab") }
+  before(:each) { stub(inittab).say }
+
+  it "exports to the filesystem" do
+    inittab.export
+    File.read("/tmp/inittab").should == example_export_file("inittab/inittab.default")
+  end
+
+  context "to stdout" do
+    let(:location) { "-" }
+
+    it "exports to stdout" do
+      mock(inittab).puts example_export_file("inittab/inittab.default")
+      inittab.export
+    end
+  end
+
+  context "with concurrency" do
+    let(:formation) { "alpha=2" }
+
+    it "exports to the filesystem with concurrency" do
+      inittab.export
+      File.read("/tmp/inittab").should == example_export_file("inittab/inittab.concurrency")
+    end
+  end
+
+end

data/spec/foreman/export/launchd_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/launchd"
+require "tmpdir"
+
+describe Foreman::Export::Launchd, :fakefs do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:options)  { Hash.new }
+  let(:engine)   { Foreman::Engine.new().load_procfile(procfile) }
+  let(:launchd)  { Foreman::Export::Launchd.new("/tmp/init", engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("launchd") }
+  before(:each) { stub(launchd).say }
+
+  it "exports to the filesystem" do
+    launchd.export
+    File.read("/tmp/init/app-alpha-1.plist").should == example_export_file("launchd/launchd-a.default")
+    File.read("/tmp/init/app-bravo-1.plist").should == example_export_file("launchd/launchd-b.default")
+  end
+
+end

data/spec/foreman/export/runit_spec.rb

@@ -3,33 +3,34 @@ require "foreman/engine"
 require "foreman/export/runit"
 require "tmpdir"
 
-describe Foreman::Export::Runit do
+describe Foreman::Export::Runit, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile", 'bar=baz') }
-  let(:engine) { Foreman::Engine.new(procfile) }
-  let(:runit) { Foreman::Export::Runit.new(engine) }
-  
+  let(:engine)   { Foreman::Engine.new(:formation => "alpha=2,bravo=1").load_procfile(procfile) }
+  let(:options)  { Hash.new }
+  let(:runit)    { Foreman::Export::Runit.new('/tmp/init', engine, options) }
+
   before(:each) { load_export_templates_into_fakefs("runit") }
   before(:each) { stub(runit).say }
-  
+  before(:each) { stub(FakeFS::FileUtils).chmod }
+
   it "exports to the filesystem" do
-    FileUtils.mkdir_p('/tmp/init')
-    runit.export('/tmp/init', :concurrency => 'alpha=2')
-    
-    File.read("/tmp/init/app-alpha-1/run").should == example_export_file('runit/app-alpha-1-run')
-    File.read("/tmp/init/app-alpha-1/log/run").should == 
-        example_export_file('runit/app-alpha-1-log-run')
+    engine.env["BAR"] = "baz"
+    runit.export
+
+    File.read("/tmp/init/app-alpha-1/run").should      == example_export_file('runit/app-alpha-1/run')
+    File.read("/tmp/init/app-alpha-1/log/run").should  == example_export_file('runit/app-alpha-1/log/run')
     File.read("/tmp/init/app-alpha-1/env/PORT").should == "5000\n"
-    File.read("/tmp/init/app-alpha-1/env/BAR").should == "baz\n"
-    
-    File.read("/tmp/init/app-alpha-2/run").should == example_export_file('runit/app-alpha-2-run')
-    File.read("/tmp/init/app-alpha-2/log/run").should == 
-        example_export_file('runit/app-alpha-2-log-run')
+    File.read("/tmp/init/app-alpha-1/env/BAR").should  == "baz\n"
+    File.read("/tmp/init/app-alpha-2/run").should      == example_export_file('runit/app-alpha-2/run')
+    File.read("/tmp/init/app-alpha-2/log/run").should  == example_export_file('runit/app-alpha-2/log/run')
     File.read("/tmp/init/app-alpha-2/env/PORT").should == "5001\n"
-    File.read("/tmp/init/app-alpha-2/env/BAR").should == "baz\n"
-    
-    File.read("/tmp/init/app-bravo-1/run").should == example_export_file('runit/app-bravo-1-run')
-    File.read("/tmp/init/app-bravo-1/log/run").should == 
-        example_export_file('runit/app-bravo-1-log-run')
+    File.read("/tmp/init/app-alpha-2/env/BAR").should  == "baz\n"
+    File.read("/tmp/init/app-bravo-1/run").should      == example_export_file('runit/app-bravo-1/run')
+    File.read("/tmp/init/app-bravo-1/log/run").should  == example_export_file('runit/app-bravo-1/log/run')
     File.read("/tmp/init/app-bravo-1/env/PORT").should == "5100\n"
   end
-end
+
+  it "creates a full path to the export directory" do
+    expect { runit.export }.to_not raise_error(Errno::ENOENT)
+  end
+end

data/spec/foreman/export/supervisord_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/supervisord"
+require "tmpdir"
+
+describe Foreman::Export::Supervisord, :fakefs do
+  let(:procfile)    { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:formation)   { nil }
+  let(:engine)      { Foreman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)     { Hash.new }
+  let(:supervisord) { Foreman::Export::Supervisord.new("/tmp/init", engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("supervisord") }
+  before(:each) { stub(supervisord).say }
+
+  it "exports to the filesystem" do
+    supervisord.export
+    File.read("/tmp/init/app.conf").should == example_export_file("supervisord/app-alpha-1.conf")
+  end
+
+  it "cleans up if exporting into an existing dir" do
+    mock(FileUtils).rm("/tmp/init/app.conf")
+    supervisord.export
+    supervisord.export
+  end
+
+  context "with concurrency" do
+    let(:formation) { "alpha=2" }
+
+    it "exports to the filesystem with concurrency" do
+      supervisord.export
+      File.read("/tmp/init/app.conf").should == example_export_file("supervisord/app-alpha-2.conf")
+    end
+  end
+
+end

data/spec/foreman/export/upstart_spec.rb

@@ -3,51 +3,84 @@ require "foreman/engine"
 require "foreman/export/upstart"
 require "tmpdir"
 
-describe Foreman::Export::Upstart do
-  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
-  let(:engine) { Foreman::Engine.new(procfile) }
-  let(:upstart) { Foreman::Export::Upstart.new(engine) }
+describe Foreman::Export::Upstart, :fakefs do
+  let(:procfile)  { write_procfile("/tmp/app/Procfile") }
+  let(:formation) { nil }
+  let(:engine)    { Foreman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)   { Hash.new }
+  let(:upstart)   { Foreman::Export::Upstart.new("/tmp/init", engine, options) }
 
   before(:each) { load_export_templates_into_fakefs("upstart") }
   before(:each) { stub(upstart).say }
 
   it "exports to the filesystem" do
-    upstart.export("/tmp/init", :concurrency => "alpha=2")
+    upstart.export
 
     File.read("/tmp/init/app.conf").should         == example_export_file("upstart/app.conf")
     File.read("/tmp/init/app-alpha.conf").should   == example_export_file("upstart/app-alpha.conf")
     File.read("/tmp/init/app-alpha-1.conf").should == example_export_file("upstart/app-alpha-1.conf")
-    File.read("/tmp/init/app-alpha-2.conf").should == example_export_file("upstart/app-alpha-2.conf")
     File.read("/tmp/init/app-bravo.conf").should   == example_export_file("upstart/app-bravo.conf")
     File.read("/tmp/init/app-bravo-1.conf").should == example_export_file("upstart/app-bravo-1.conf")
   end
 
+  it "cleans up if exporting into an existing dir" do
+    mock(FileUtils).rm("/tmp/init/app.conf")
+    mock(FileUtils).rm("/tmp/init/app-alpha.conf")
+    mock(FileUtils).rm("/tmp/init/app-alpha-1.conf")
+    mock(FileUtils).rm("/tmp/init/app-bravo.conf")
+    mock(FileUtils).rm("/tmp/init/app-bravo-1.conf")
+
+    upstart.export
+    upstart.export
+  end
+
+  it "quotes and escapes environment variables" do
+    engine.env['KEY'] = 'd"\|d'
+    upstart.export
+    "foobarfoo".should include "bar"
+    File.read("/tmp/init/app-alpha-1.conf").should =~ /KEY="d\\"\\\\\\\|d/
+  end
+
+  context "with a formation" do
+    let(:formation) { "alpha=2" }
+
+    it "exports to the filesystem with concurrency" do
+      upstart.export
+
+      File.read("/tmp/init/app.conf").should            == example_export_file("upstart/app.conf")
+      File.read("/tmp/init/app-alpha.conf").should      == example_export_file("upstart/app-alpha.conf")
+      File.read("/tmp/init/app-alpha-1.conf").should    == example_export_file("upstart/app-alpha-1.conf")
+      File.read("/tmp/init/app-alpha-2.conf").should    == example_export_file("upstart/app-alpha-2.conf")
+      File.exists?("/tmp/init/app-bravo-1.conf").should == false
+    end
+  end
+
   context "with alternate templates" do
-    let(:template_root) { "/tmp/alternate" }
+    let(:template) { "/tmp/alternate" }
+    let(:options)  { { :app => "app", :template => template } }
 
     before do
-      FileUtils.mkdir_p template_root
-      File.open("#{template_root}/master.conf.erb", "w") { |f| f.puts "alternate_template" }
+      FileUtils.mkdir_p template
+      File.open("#{template}/master.conf.erb", "w") { |f| f.puts "alternate_template" }
     end
 
     it "can export with alternate template files" do
-      upstart.export("/tmp/init", :template => template_root)
-
+      upstart.export
       File.read("/tmp/init/app.conf").should == "alternate_template\n"
     end
   end
 
   context "with alternate templates from home dir" do
-    let(:default_template_root) {File.expand_path("~/.foreman/templates")}
 
     before do
-      FileUtils.mkdir_p default_template_root
-      File.open("#{default_template_root}/master.conf.erb", "w") { |f| f.puts "default_alternate_template" }
+      FileUtils.mkdir_p File.expand_path("~/.foreman/templates/upstart")
+      File.open(File.expand_path("~/.foreman/templates/upstart/master.conf.erb"), "w") do |file|
+        file.puts "default_alternate_template"
+      end
     end
 
     it "can export with alternate template files" do
-      upstart.export("/tmp/init")
-
+      upstart.export
       File.read("/tmp/init/app.conf").should == "default_alternate_template\n"
     end
   end

data/spec/foreman/export_spec.rb

@@ -1,2 +1,24 @@
 require "spec_helper"
 require "foreman/export"
+
+describe "Foreman::Export" do
+  subject { Foreman::Export }
+
+  describe "with a formatter that doesn't declare the appropriate class" do
+    it "prints an error" do
+      mock(subject).require("foreman/export/invalidformatter")
+      mock_export_error("Unknown export format: invalidformatter (no class Foreman::Export::Invalidformatter).") do
+        subject.formatter("invalidformatter") 
+      end
+    end
+  end
+
+  describe "with an invalid formatter" do
+
+    it "prints an error" do
+      mock_export_error("Unknown export format: invalidformatter (unable to load file 'foreman/export/invalidformatter').") do
+        subject.formatter("invalidformatter")
+      end
+    end
+  end
+end