foreman 0.36.1 → 0.37.0

data/spec/foreman/cli_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "foreman/cli"
 
-describe "Foreman::CLI" do
+describe "Foreman::CLI", :fakefs do
   subject { Foreman::CLI.new }
 
   describe "start" do
@@ -27,10 +27,21 @@ describe "Foreman::CLI" do
 
   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.instance_of(Foreman::Export::Upstart).export("/upstart", { "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
@@ -47,10 +58,18 @@ describe "Foreman::CLI" do
     describe "with a Procfile" do
       before(:each) { write_procfile }
 
-      describe "with an invalid formatter" do
+      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, "Unknown export format: invalidformatter.") do
-            subject.export("invalidformatter")
+          mock_error(subject, "foo") do
+            subject.export("errorful")
           end
         end
       end
@@ -60,7 +79,9 @@ describe "Foreman::CLI" do
 
         it "runs successfully" do
           dont_allow(subject).error
-          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {})
+          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")
         end
       end
@@ -72,7 +93,7 @@ describe "Foreman::CLI" do
       before { write_procfile }
 
       it "displays the jobs" do
-        mock(subject).display("valid procfile detected (alpha, bravo)")
+        mock(subject).puts("valid procfile detected (alpha, bravo)")
         subject.check
       end
     end
@@ -89,47 +110,47 @@ describe "Foreman::CLI" do
       end
     end
   end
-  
+
   describe "run" do
     describe "with a valid Procfile" do
       before { write_procfile }
 
       describe "and a command" do
         let(:command) { ["ls", "-l"] }
-        
+
         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 runute the command as a string" do
           mock(subject).exec(command.join(" "))
           subject.run *command
         end
       end
-      
+
       describe "and a non-existent command" do
         let(:command) { "iuhtngrglhulhdfg" }
-        
+
         it "should print an error" do
           mock_error(subject, "command not found: #{command}") do
             subject.run command
           end
         end
       end
-      
+
       describe "and a non-executable command" do
         let(:command) { __FILE__ }
-        
+
         it "should print an error" do
           mock_error(subject, "not executable: #{command}") do
             subject.run command

data/spec/foreman/engine_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "foreman/engine"
 
-describe "Foreman::Engine" do
+describe "Foreman::Engine", :fakefs do
   subject { Foreman::Engine.new("Procfile", {}) }
 
   describe "initialize" do
@@ -24,8 +24,8 @@ describe "Foreman::Engine" do
   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.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).watch_for_output
       mock(subject).watch_for_termination
       subject.start
@@ -34,8 +34,8 @@ describe "Foreman::Engine" do
     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)).never
+      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

data/spec/foreman/export/base_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "foreman/export/base"
+
+describe "Foreman::Export::Base" do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:location) { "/tmp/init" }
+  let(:engine)   { Foreman::Engine.new(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 "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
+end

data/spec/foreman/export/bluepill_spec.rb

@@ -3,22 +3,34 @@ require "foreman/engine"
 require "foreman/export/bluepill"
 require "tmpdir"
 
-describe Foreman::Export::Bluepill do
+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(:bluepill) { Foreman::Export::Bluepill.new(engine) }
+  let(:engine)   { Foreman::Engine.new(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")
+    bluepill.export
     normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app.pill"))
   end
 
-  it "exports to the filesystem with concurrency" do
-    bluepill.export("/tmp/init", :concurrency => "alpha=2")
-    
-    normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app-concurrency.pill"))
+  it "cleans up if exporting into an existing dir" do
+    mock(FileUtils).rm("/tmp/init/app.pill")
+
+    bluepill.export
+    bluepill.export
   end
-end
+
+  context  "with concurrency" do
+    let(:options) { Hash[:concurrency => "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(: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) }
+
+  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(:options) { Hash[:concurrency => "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/runit_spec.rb

@@ -3,34 +3,39 @@ 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(:runit) { Foreman::Export::Runit.new('/tmp/init', engine, :concurrency => 'alpha=2,bravo=1') }
+
   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,bravo=1")
-    
+
+    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 == 
+    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 == 
+    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 == 
+    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/upstart_spec.rb

@@ -3,16 +3,17 @@ require "foreman/engine"
 require "foreman/export/upstart"
 require "tmpdir"
 
-describe Foreman::Export::Upstart do
+describe Foreman::Export::Upstart, :fakefs 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) }
+  let(:engine)   { Foreman::Engine.new(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")
+    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")
@@ -21,18 +22,34 @@ describe Foreman::Export::Upstart do
     File.read("/tmp/init/app-bravo-1.conf").should == example_export_file("upstart/app-bravo-1.conf")
   end
 
-  it "exports to the filesystem with concurrency" do
-    upstart.export("/tmp/init", :concurrency => "alpha=2")
+  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")
 
-    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
+    upstart.export
+    upstart.export
+  end
+
+  context "with concurrency" do
+    let(:options) { Hash[:concurrency => "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(:upstart) { Foreman::Export::Upstart.new("/tmp/init", engine, :template => template_root) }
 
     before do
       FileUtils.mkdir_p template_root
@@ -40,7 +57,7 @@ describe Foreman::Export::Upstart do
     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
@@ -61,7 +78,7 @@ describe Foreman::Export::Upstart do
     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

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

data/spec/foreman/helpers_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "foreman/helpers"
+
+describe "Foreman::Helpers" do
+  before do
+    module Foo
+      class Bar; end
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Foo)
+  end
+
+  subject { o = Object.new; o.extend(Foreman::Helpers); o }
+
+  it "should classify words" do
+    subject.classify("foo").should == "Foo"
+    subject.classify("foo-bar").should == "FooBar"
+  end
+
+  it "should constantize words" do
+    subject.constantize("Object").should == Object
+    subject.constantize("Foo::Bar").should == Foo::Bar
+  end
+end

data/spec/foreman/process_spec.rb

@@ -1,2 +1,131 @@
-require "spec_helper"
-require "foreman/process"
+require 'spec_helper'
+require 'foreman/process'
+require 'ostruct'
+require 'timeout'
+require 'tmpdir'
+
+describe Foreman::Process do
+  subject { described_class.new entry, number, port }
+
+  let(:number)  { 1 }
+  let(:port)    { 777 }
+  let(:command) { "script" }
+  let(:name)    { "foobar" }
+  let(:entry)   { OpenStruct.new :name => name, :command => command }
+
+  its(:entry) { entry }
+  its(:num)   { number }
+  its(:port)  { port }
+  its(:name)  { "#{name}.#{port}" }
+  its(:pid)   { nil }
+
+  describe '#run' do
+    let(:pipe)       { :pipe }
+    let(:basedir)    { Dir.mktmpdir }
+    let(:env)        {{ 'foo' => 'bar' }}
+    let(:init_delta) { 0.1 }
+
+    after { FileUtils.remove_entry_secure basedir }
+
+    def run(cmd=command)
+      entry.command = cmd
+      subject.run pipe, basedir, env
+      subject.detach && sleep(init_delta)
+    end
+
+    def run_file(executable, code)
+      file = File.open("#{basedir}/script", 'w') {|it| it << code }
+      run "#{executable} #{file.path}"
+    end
+
+    context 'options' do
+      it 'should set PORT for environment' do
+        mock(subject).run_process(basedir, command, pipe) do
+          ENV['PORT'].should == port.to_s
+        end
+        run
+      end
+
+      it 'should set custom variables for environment' do
+        mock(subject).run_process(basedir, command, pipe) do
+          ENV['foo'].should == 'bar'
+        end
+        run
+      end
+
+      it 'should restore environment afterwards' do
+        mock(subject).run_process(basedir, command, pipe)
+        run
+        ENV.should_not include('PORT', 'foo')
+      end
+    end
+
+    context 'process' do
+      around do |spec|
+        IO.pipe do |reader, writer|
+          @reader, @writer = reader, writer
+          spec.run
+        end
+      end
+
+      let(:pipe) { @writer }
+      let(:output) { @reader.read_nonblock 1024 }
+
+      it 'should not block' do
+        expect {
+          Timeout.timeout(2*init_delta) { run 'sleep 2' }
+        }.should_not raise_exception
+      end
+
+      it 'should be alive' do
+        run 'sleep 1'
+        subject.should be_alive
+      end
+
+      it 'should be dead' do
+        run 'exit'
+        subject.should be_dead
+      end
+
+      it 'should be killable' do
+        run 'sleep 1'
+        subject.kill 'TERM'
+        subject.should be_dead
+      end
+
+      it 'should send different signals' do
+        run_file 'ruby', <<-CODE
+          trap "TERM", "IGNORE"
+          loop { sleep 1 }
+        CODE
+        sleep 1  # wait for ruby to start
+        subject.should be_alive
+        subject.kill 'TERM'
+        subject.should be_alive
+        subject.kill 'KILL'
+        subject.should be_dead
+      end
+
+      it 'should redirect stdout' do
+        run 'echo hey'
+        output.should include('hey')
+      end
+
+      it 'should redirect stderr' do
+        run 'echo hey >2'
+        output.should include('hey')
+      end
+
+      it 'should handle variables' do
+        run 'echo $PORT'
+        output.should include('777')
+      end
+
+      it 'should handle arguments' do
+        pending
+        run %{ sh -c "trap '' TERM; sleep 10" }
+        subject.should be_alive
+      end
+    end
+  end
+end

data/spec/foreman_spec.rb

@@ -8,13 +8,8 @@ describe Foreman do
     it { should be_a String }
   end
 
-  describe "::load_env!(env_file)" do
-    before do
-      FakeFS.activate!
-    end
-
+  describe "::load_env!(env_file)", :fakefs do
     after do
-      FakeFS.deactivate!
       ENV['FOO'] = nil
     end
 
@@ -22,7 +17,7 @@ describe Foreman do
       File.open("/tmp/env1", "w") { |f| f.puts("FOO=bar") }
       Foreman.load_env!("/tmp/env1")
       ENV['FOO'].should == 'bar'
-    end 
+    end
 
     it "should assume env_file in ./.env" do
       File.open("./.env", "w") { |f| f.puts("FOO=bar") }
@@ -30,4 +25,10 @@ describe Foreman do
       ENV['FOO'].should == 'bar'
     end
   end
+
+  describe "runner" do
+    it "should exist" do
+      File.exists?(Foreman.runner).should == true
+    end
+  end
 end

data/spec/helper_spec.rb

@@ -3,16 +3,16 @@ require "spec_helper"
 describe "spec helpers" do
   describe "#preserving_env" do
     after { ENV.delete "FOO" }
-    
+
     it "should remove added environment vars" do
       preserving_env { ENV["FOO"] = "baz" }
       ENV["FOO"].should == nil
     end
-    
+
     it "should reset modified environment vars" do
       ENV["FOO"] = "bar"
       preserving_env { ENV["FOO"] = "baz"}
       ENV["FOO"].should == "bar"
     end
   end
-end
+end

data/spec/resources/export/inittab/inittab.concurrency

@@ -0,0 +1,4 @@
+# ----- foreman app processes -----
+AP01:4:respawn:/bin/su - app -c 'PORT=5000 ./alpha >> /var/log/app/alpha-1.log 2>&1'
+AP02:4:respawn:/bin/su - app -c 'PORT=5001 ./alpha >> /var/log/app/alpha-2.log 2>&1'
+# ----- end foreman app processes -----

data/spec/resources/export/inittab/inittab.default

@@ -0,0 +1,4 @@
+# ----- foreman app processes -----
+AP01:4:respawn:/bin/su - app -c 'PORT=5000 ./alpha >> /var/log/app/alpha-1.log 2>&1'
+AP02:4:respawn:/bin/su - app -c 'PORT=5100 ./bravo >> /var/log/app/bravo-1.log 2>&1'
+# ----- end foreman app processes -----