foreman 0.47.0 → 0.50.0

data/spec/foreman/cli_spec.rb

@@ -3,188 +3,84 @@ require "foreman/cli"
 
 describe "Foreman::CLI", :fakefs do
   subject { Foreman::CLI.new }
-  let(:engine) { subject.send(:engine) }
-  let(:entries) { engine.procfile.entries.inject({}) { |h,e| h.update(e.name => e) } }
 
-  describe "start" do
-    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).start
-          subject.start
-        end
-      end
-    end
-
-    describe "with a Procfile" do
-      before(:each) { write_procfile }
+  describe ".foreman" do
+    before { File.open(".foreman", "w") { |f| f.puts "formation: alpha=2" } }
 
-      it "runs successfully" do
-        dont_allow(subject).error
-        mock.instance_of(Foreman::Engine).start
-        subject.start
-      end
-
-      it "can run a single process" do
-        dont_allow(subject).error
-        stub(engine).watch_for_output
-        stub(engine).watch_for_termination
-        mock(entries["alpha"]).spawn(1, is_a(IO), engine.directory, {}, 5000) { [] }
-        mock(entries["bravo"]).spawn(0, is_a(IO), engine.directory, {}, 5100) { [] }
-        subject.start("alpha")
-      end
+    it "provides default options" do
+      subject.send(:options)["formation"].should == "alpha=2"
     end
 
-    describe "with an alternate root" do
-      it "reads the Procfile from that root" do
-        write_procfile "/some/app/Procfile"
-        mock(Foreman::Procfile).new("/some/app/Procfile")
-        mock.instance_of(Foreman::Engine).start
-        foreman %{ start -d /some/app }
-      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 "export" do
-    describe "options" do
-      it "uses .foreman" do
-        write_procfile
-        File.open(".foreman", "w") { |f| f.puts "concurrency: alpha=2" }
-        mock_export = mock(Foreman::Export::Upstart)
-        mock(Foreman::Export::Upstart).new("/upstart", is_a(Foreman::Engine), { "concurrency" => "alpha=2" }) { mock_export }
-        mock_export.export
-        foreman %{ export upstart /upstart }
-      end
-
-      it "respects --env" do
-        write_procfile
-        write_env("envfile")
-        mock_export = mock(Foreman::Export::Upstart)
-        mock(Foreman::Export::Upstart).new("/upstart", is_a(Foreman::Engine), { "env" => "envfile" }) { mock_export }
-        mock_export.export
-        foreman %{ export upstart /upstart --env envfile }
-      end
-    end
-
-    describe "with a non-existent Procfile" do
-      it "prints an error" do
+  describe "start" 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).export
-          subject.export("testapp")
+          dont_allow.instance_of(Foreman::Engine).start
+          subject.start
         end
       end
     end
 
-    describe "with a Procfile" do
-      before(:each) { write_procfile }
-
-      describe "with a formatter with a generic error" do
-        before do
-          mock(Foreman::Export).formatter("errorful") { Class.new(Foreman::Export::Base) do
-            def export
-              raise Foreman::Export::Exception.new("foo")
-            end
-          end }
-        end
-
-        it "prints an error" do
-          mock_error(subject, "foo") do
-            subject.export("errorful")
-          end
+    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
 
-      describe "with a valid config" do
-        before(:each) { write_foreman_config("testapp") }
-
-        it "runs successfully" do
-          dont_allow(subject).error
-          mock_export = mock(Foreman::Export::Upstart)
-          mock(Foreman::Export::Upstart).new("/tmp/foo", is_a(Foreman::Engine), {}) { mock_export }
-          mock_export.export
-          subject.export("upstart", "/tmp/foo")
+      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 "check" do
-    describe "with a valid Procfile" do
-      before { write_procfile }
-
-      it "displays the jobs" do
-        mock(subject).puts("valid procfile detected (alpha, bravo)")
-        subject.check
-      end
+    it "with a valid Procfile displays the jobs" do
+      write_procfile
+      foreman("check").should == "valid procfile detected (alpha, bravo)\n"
     end
 
-    describe "with a blank Procfile" do
-      before do
-        FileUtils.touch("Procfile")
-      end
-
-      it "displays an error" do
-        mock_error(subject, "no processes defined") do
-          subject.check
-        end
-      end
+    it "with a blank Procfile displays an error" do
+      FileUtils.touch "Procfile"
+      foreman("check").should == "ERROR: no processes defined\n"
     end
 
-    describe "without a Procfile" do
-      it "displays an error" do
-        mock_error(subject, "Procfile does not exist.") do
-          subject.check
-        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 "run" do
-    describe "with a valid Procfile" do
-      before { write_procfile }
-
-      describe "and a command" do
-        let(:command) { ["ls", "-l", "foo bar"] }
-
-        before(:each) do
-          stub(subject).exec
-        end
-
-        it "should load the environment file" do
-          write_env
-          preserving_env do
-            subject.run *command
-            ENV["FOO"].should == "bar"
-          end
-
-          ENV["FOO"].should be_nil
-        end
-
-        it "should exec the argument list as a shell command" do
-          mock(subject).exec(command.shelljoin)
-          subject.run *command
-        end
-      end
-
-      describe "and a non-existent command" do
-        let(:command) { "iuhtngrglhulhdfg" }
+    it "can run a command" do
+      forked_foreman("run echo 1").should == "1\n"
+    end
 
-        it "should print an error" do
-          mock_error(subject, "command not found: #{command}") do
-            subject.run command
-          end
-        end
-      end
+    it "includes the environment" do
+      forked_foreman("run #{resource_path("bin/env FOO")} -e #{resource_path(".env")}").should == "bar\n"
+    end
+  end
 
-      describe "and a non-executable command" do
-        let(:command) { __FILE__ }
+  describe "version" do
+    it "displays gem version" do
+      foreman("version").chomp.should == Foreman::VERSION
+    end
 
-        it "should print an error" do
-          mock_error(subject, "not executable: #{command}") do
-            subject.run command
-          end
-        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,14 +1,25 @@
 require "spec_helper"
 require "foreman/engine"
 
-describe "Foreman::Engine", :fakefs do
-  subject { Foreman::Engine.new("Procfile", {}) }
+class Foreman::Engine::Tester < Foreman::Engine
+  attr_reader :buffer
 
-  before do
-    any_instance_of(Foreman::Engine) do |engine|
-      stub(engine).proctitle
-      stub(engine).termtitle
-    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
@@ -16,65 +27,53 @@ describe "Foreman::Engine", :fakefs 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(Dir.pwd, "./alpha", is_a(IO))
-      mock.instance_of(Foreman::Process).run_process(Dir.pwd, "./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(Dir.pwd, "./alpha", is_a(IO)).twice
-      mock.instance_of(Foreman::Process).run_process(Dir.pwd, "./bravo", is_a(IO)).never
-      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 "directories" do
     it "has the directory default relative to the Procfile" do
       write_procfile "/some/app/Procfile"
-      engine = Foreman::Engine.new("/some/app/Procfile")
-      engine.directory.should == "/some/app"
+      engine = Foreman::Engine.new.load_procfile("/some/app/Procfile")
+      engine.root.should == "/some/app"
     end
   end
 
   describe "environment" do
-    before(:each) do
-      write_procfile
-      stub(Process).fork
-      any_instance_of(Foreman::Engine) do |engine|
-        stub(engine).info
-        stub(engine).spawn_processes
-        stub(engine).watch_for_termination
-      end
-    end
-
-    it "should read if specified" 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")
-      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")
-      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
@@ -84,55 +83,22 @@ describe "Foreman::Engine", :fakefs do
         f.puts "FRED='barney'"
         f.puts 'OTHER="escaped\"quote"'
       end
-      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
-      engine.environment.should == { "FOO" => "bar", "BAZ" => "qux", "FRED" => "barney", "OTHER" => 'escaped"quote' }
+      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")
-    end
-
-    it "should read .env if none specified" do
-      File.open(".env", "w") { |f| f.puts("FOO=qoo") }
-      engine = Foreman::Engine.new("Procfile")
-      engine.environment.should == {"FOO"=>"qoo"}
-      engine.start
+      lambda { subject.load_env "/tmp/env" }.should raise_error(Errno::ENOENT)
     end
 
     it "should set port from .env if specified" do
-      File.open(".env", "w") { |f| f.puts("PORT=8017") }
-      engine = Foreman::Engine.new("Procfile")
-      engine.send(:base_port).should == "8017"
-      engine.start
-    end
-
-    it "should be loaded relative to the Procfile" do
-      FileUtils.mkdir_p "/some/app"
-      File.open("/some/app/.env", "w") { |f| f.puts("FOO=qoo") }
-      write_procfile "/some/app/Procfile"
-      engine = Foreman::Engine.new("/some/app/Procfile")
-      engine.environment.should == {"FOO"=>"qoo"}
-      engine.start
+      File.open("/tmp/env", "w") { |f| f.puts("PORT=9000") }
+      subject.load_env "/tmp/env"
+      subject.send(:base_port).should == 9000
     end
   end
 
-  describe "utf8" do
-    before(:each) do
-      File.open("Procfile", "w") do |file|
-        file.puts "utf8: #{resource_path("bin/utf8")}"
-      end
-    end
-
-    it "should spawn" do
-      stub(subject).watch_for_output
-      stub(subject).watch_for_termination
-      subject.start
-      Process.waitall
-      mock(subject).info(/started with pid \d+/, "utf8.1", anything)
-      mock(subject).info("\xff\x03\n", "utf8.1", anything)
-      subject.send(:poll_readers)
-      subject.send(:poll_readers)
-    end
-  end
 end

data/spec/foreman/export/base_spec.rb

@@ -1,10 +1,11 @@
 require "spec_helper"
-require "foreman/export/base"
+require "foreman/engine"
+require "foreman/export"
 
-describe "Foreman::Export::Base" do
+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(procfile) }
+  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
@@ -12,10 +13,6 @@ describe "Foreman::Export::Base" do
     subject.send(:say, "foo")
   end
 
-  it "export needs to be overridden" do
-    lambda { subject.export }.should raise_error("export method must be overridden")
-  end
-
   it "raises errors as a Foreman::Export::Exception" do
     lambda { subject.send(:error, "foo") }.should raise_error(Foreman::Export::Exception, "foo")
   end

data/spec/foreman/export/bluepill_spec.rb

@@ -4,10 +4,11 @@ require "foreman/export/bluepill"
 require "tmpdir"
 
 describe Foreman::Export::Bluepill, :fakefs do
-  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
-  let(:engine)   { Foreman::Engine.new(procfile) }
-  let(:options)  { Hash.new }
-  let(:bluepill) { Foreman::Export::Bluepill.new("/tmp/init", engine, options) }
+  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 }
@@ -24,8 +25,8 @@ describe Foreman::Export::Bluepill, :fakefs do
     bluepill.export
   end
 
-  context  "with concurrency" do
-    let(:options) { Hash[:concurrency => "alpha=2"] }
+  context "with a process formation" do
+    let(:formation) { "alpha=2" }
 
     it "exports to the filesystem with concurrency" do
       bluepill.export

data/spec/foreman/export/inittab_spec.rb

@@ -4,12 +4,12 @@ require "foreman/export/inittab"
 require "tmpdir"
 
 describe Foreman::Export::Inittab, :fakefs do
-  let(:location) { "/tmp/inittab" }
-  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
-  let(:location) { "/tmp/inittab" }
-  let(:engine)   { Foreman::Engine.new(procfile) }
-  let(:options)  { Hash.new }
-  let(:inittab)  { Foreman::Export::Inittab.new(location, engine, options) }
+  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 }
@@ -29,7 +29,7 @@ describe Foreman::Export::Inittab, :fakefs do
   end
 
   context "with concurrency" do
-    let(:options) { Hash[:concurrency => "alpha=2"] }
+    let(:formation) { "alpha=2" }
 
     it "exports to the filesystem with concurrency" do
       inittab.export

data/spec/foreman/export/launchd_spec.rb

@@ -5,20 +5,17 @@ require "tmpdir"
 
 describe Foreman::Export::Launchd, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
-  let(:engine)   { Foreman::Engine.new(procfile) }
   let(:options)  { Hash.new }
-  let(:launchd) { Foreman::Export::Launchd.new("/tmp/init", engine, options) }
+  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
-    
-    normalize_space(File.read("/tmp/init/app-alpha-1.plist")).should == normalize_space(example_export_file("launchd/launchd-a.default"))
-    
-    normalize_space(File.read("/tmp/init/app-bravo-1.plist")).should == normalize_space(example_export_file("launchd/launchd-b.default"))
-    
+    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

@@ -5,33 +5,28 @@ require "tmpdir"
 
 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('/tmp/init', engine, :concurrency => 'alpha=2,bravo=1') }
+  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')
-
+    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/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