overman 0.0.1 → 0.88.1

data/spec/foreman/cli_spec.rb

@@ -0,0 +1,111 @@
+require "spec_helper"
+require "foreman/cli"
+
+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
+      expect(subject.send(:options)["formation"]).to eq("alpha=2")
+    end
+
+    it "is overridden by options at the cli" do
+      subject = Foreman::CLI.new([], :formation => "alpha=3")
+      expect(subject.send(:options)["formation"]).to eq("alpha=3")
+    end
+  end
+
+  describe "start" do
+    describe "when a Procfile doesnt exist", :fakefs do
+      it "displays an error" do
+        mock_error(subject, "Procfile does not exist.") do
+          expect_any_instance_of(Foreman::Engine).to_not receive(:start)
+          subject.start
+        end
+      end
+    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")}")
+          expect(output).to     match(/env.1/)
+          expect(output).not_to match(/test.1/)
+        end
+      end
+
+      it "can run all commands" do
+        without_fakefs do
+          output = foreman("start -f #{resource_path("Procfile")} -e #{resource_path(".env")}")
+          expect(output).to match(/echo.1 \| echoing/)
+          expect(output).to match(/env.1  \| bar/)
+          expect(output).to match(/test.1 \| testing/)
+        end
+      end
+
+      it "sets PS variable with the process name" do
+        without_fakefs do
+          output = foreman("start -f #{resource_path("Procfile")}")
+          expect(output).to match(/ps.1   \| PS env var is ps.1/)
+        end
+      end
+
+      it "fails if process fails" do
+        output = `bundle exec foreman start -f #{resource_path "Procfile.bad"} && echo success`
+        expect(output).not_to include 'success'
+      end
+    end
+  end
+
+  describe "check" do
+    it "with a valid Procfile displays the jobs" do
+      write_procfile
+      expect(foreman("check")).to eq("valid procfile detected (alpha, bravo, foo_bar, foo-bar)\n")
+    end
+
+    it "with a blank Procfile displays an error" do
+      FileUtils.touch "Procfile"
+      expect(foreman("check")).to eq("ERROR: no processes defined\n")
+    end
+
+    it "without a Procfile displays an error" do
+      expect(foreman("check")).to eq("ERROR: Procfile does not exist.\n")
+    end
+  end
+
+  describe "run" do
+    it "can run a command" do
+      expect(forked_foreman("run -f #{resource_path("Procfile")} echo 1")).to eq("1\n")
+    end
+
+    it "doesn't parse options for the command" do
+      expect(forked_foreman("run -f #{resource_path("Procfile")} grep -e FOO #{resource_path(".env")}")).to eq("FOO=bar\n")
+    end
+
+    it "includes the environment" do
+      expect(forked_foreman("run -f #{resource_path("Procfile")} -e #{resource_path(".env")} #{resource_path("bin/env FOO")}")).to eq("bar\n")
+    end
+
+    it "can run a command from the Procfile" do
+      expect(forked_foreman("run -f #{resource_path("Procfile")} test")).to eq("testing\n")
+    end
+
+    it "exits with the same exit code as the command" do
+      expect(fork_and_get_exitstatus("run -f #{resource_path("Procfile")} echo 1")).to eq(0)
+      expect(fork_and_get_exitstatus("run -f #{resource_path("Procfile")} date 'invalid_date'")).to eq(1)
+    end
+  end
+
+  describe "version" do
+    it "displays gem version" do
+      expect(foreman("version").chomp).to eq(Foreman::VERSION)
+    end
+
+    it "displays gem version on shortcut command" do
+      expect(foreman("-v").chomp).to eq(Foreman::VERSION)
+    end
+  end
+
+end

data/spec/foreman/engine_spec.rb

@@ -0,0 +1,114 @@
+require "spec_helper"
+require "foreman/engine"
+
+class Foreman::Engine::Tester < Foreman::Engine
+  attr_reader :buffer
+
+  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
+        expect(subject.process("alpha").command).to eq("./alpha")
+        expect(subject.process("bravo").command).to eq("./bravo")
+      end
+    end
+  end
+
+  describe "start" do
+    it "forks the processes" do
+      expect(subject.process("alpha")).to receive(:run)
+      expect(subject.process("bravo")).to receive(:run)
+      expect(subject).to receive(:watch_for_output)
+      expect(subject).to receive(:wait_for_shutdown_or_child_termination)
+      subject.start
+    end
+
+    it "handles concurrency" do
+      subject.options[:formation] = "alpha=2"
+      expect(subject.process("alpha")).to receive(:run).twice
+      expect(subject.process("bravo")).to_not receive(:run)
+      expect(subject).to receive(:watch_for_output)
+      expect(subject).to receive(:wait_for_shutdown_or_child_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.load_procfile("/some/app/Procfile")
+      expect(engine.root).to eq("/some/app")
+    end
+  end
+
+  describe "environment" do
+    it "should read env files" do
+      write_file("/tmp/env") { |f| f.puts("FOO=baz") }
+      subject.load_env("/tmp/env")
+      expect(subject.env["FOO"]).to eq("baz")
+    end
+
+    it "should read more than one if specified" do
+      write_file("/tmp/env1") { |f| f.puts("FOO=bar") }
+      write_file("/tmp/env2") { |f| f.puts("BAZ=qux") }
+      subject.load_env "/tmp/env1"
+      subject.load_env "/tmp/env2"
+      expect(subject.env["FOO"]).to eq("bar")
+      expect(subject.env["BAZ"]).to eq("qux")
+    end
+
+    it "should handle quoted values" do
+      write_file("/tmp/env") do |f|
+        f.puts 'FOO=bar'
+        f.puts 'BAZ="qux"'
+        f.puts "FRED='barney'"
+        f.puts 'OTHER="escaped\"quote"'
+        f.puts 'URL="http://example.com/api?foo=bar&baz=1"'
+      end
+      subject.load_env "/tmp/env"
+      expect(subject.env["FOO"]).to   eq("bar")
+      expect(subject.env["BAZ"]).to   eq("qux")
+      expect(subject.env["FRED"]).to  eq("barney")
+      expect(subject.env["OTHER"]).to eq('escaped"quote')
+      expect(subject.env["URL"]).to   eq("http://example.com/api?foo=bar&baz=1")
+    end
+
+    it "should handle multiline strings" do
+      write_file("/tmp/env") do |f|
+        f.puts 'FOO="bar\nbaz"'
+      end
+      subject.load_env "/tmp/env"
+      expect(subject.env["FOO"]).to eq("bar\nbaz")
+    end
+
+    it "should fail if specified and doesnt exist" do
+      expect { subject.load_env "/tmp/env" }.to raise_error(Errno::ENOENT)
+    end
+
+    it "should set port from .env if specified" do
+      write_file("/tmp/env") { |f| f.puts("PORT=9000") }
+      subject.load_env "/tmp/env"
+      expect(subject.send(:base_port)).to eq(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
+    expect(subject).to receive(:puts).with("[foreman export] foo")
+    subject.send(:say, "foo")
+  end
+
+  it "raises errors as a Foreman::Export::Exception" do
+    expect { subject.send(:error, "foo") }.to raise_error(Foreman::Export::Exception, "foo")
+  end
+end

data/spec/foreman/export/bluepill_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "foreman/engine"
+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(: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) { allow(bluepill).to receive(:say) }
+
+  it "exports to the filesystem" do
+    bluepill.export
+    expect(normalize_space(File.read("/tmp/init/app.pill"))).to eq(normalize_space(example_export_file("bluepill/app.pill")))
+  end
+
+  it "cleans up if exporting into an existing dir" do
+    expect(FileUtils).to receive(:rm).with("/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
+      expect(normalize_space(File.read("/tmp/init/app.pill"))).to eq(normalize_space(example_export_file("bluepill/app-concurrency.pill")))
+    end
+  end
+
+end

data/spec/foreman/export/daemon_spec.rb

@@ -0,0 +1,97 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/daemon"
+require "tmpdir"
+
+describe Foreman::Export::Daemon, :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(:daemon)   { Foreman::Export::Daemon.new("/tmp/init", engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("daemon") }
+  before(:each) { allow(daemon).to receive(:say) }
+
+  it "exports to the filesystem" do
+    daemon.export
+
+    expect(File.read("/tmp/init/app.conf")).to         eq(example_export_file("daemon/app.conf"))
+    expect(File.read("/tmp/init/app-alpha.conf")).to   eq(example_export_file("daemon/app-alpha.conf"))
+    expect(File.read("/tmp/init/app-alpha-1.conf")).to eq(example_export_file("daemon/app-alpha-1.conf"))
+    expect(File.read("/tmp/init/app-bravo.conf")).to   eq(example_export_file("daemon/app-bravo.conf"))
+    expect(File.read("/tmp/init/app-bravo-1.conf")).to eq(example_export_file("daemon/app-bravo-1.conf"))
+  end
+
+  it "cleans up if exporting into an existing dir" do
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha-1.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo-1.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar-1.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar-1.conf")
+
+    daemon.export
+    daemon.export
+  end
+
+  it "does not delete exported files for similarly named applications" do
+    FileUtils.mkdir_p "/tmp/init"
+
+    ["app2", "app2-alpha", "app2-alpha-1"].each do |name|
+      path = "/tmp/init/#{name}.conf"
+      FileUtils.touch(path)
+      expect(FileUtils).to_not receive(:rm).with(path)
+    end
+
+    daemon.export
+  end
+
+  context "with a formation" do
+    let(:formation) { "alpha=2" }
+
+    it "exports to the filesystem with concurrency" do
+      daemon.export
+
+      expect(File.read("/tmp/init/app.conf")).to            eq(example_export_file("daemon/app.conf"))
+      expect(File.read("/tmp/init/app-alpha.conf")).to      eq(example_export_file("daemon/app-alpha.conf"))
+      expect(File.read("/tmp/init/app-alpha-1.conf")).to    eq(example_export_file("daemon/app-alpha-1.conf"))
+      expect(File.read("/tmp/init/app-alpha-2.conf")).to    eq(example_export_file("daemon/app-alpha-2.conf"))
+      expect(File.exist?("/tmp/init/app-bravo-1.conf")).to eq(false)
+    end
+  end
+
+  context "with alternate templates" do
+    let(:template) { "/tmp/alternate" }
+    let(:options)  { { :app => "app", :template => template } }
+
+    before do
+      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
+      daemon.export
+      expect(File.read("/tmp/init/app.conf")).to eq("alternate_template\n")
+    end
+  end
+
+  context "with alternate templates from home dir" do
+
+    before do
+      FileUtils.mkdir_p File.expand_path("~/.foreman/templates/daemon")
+      File.open(File.expand_path("~/.foreman/templates/daemon/master.conf.erb"), "w") do |file|
+        file.puts "default_alternate_template"
+      end
+    end
+
+    it "can export with alternate template files" do
+      daemon.export
+      expect(File.read("/tmp/init/app.conf")).to eq("default_alternate_template\n")
+    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) { allow(inittab).to receive(:say) }
+
+  it "exports to the filesystem" do
+    inittab.export
+    expect(File.read("/tmp/inittab")).to eq(example_export_file("inittab/inittab.default"))
+  end
+
+  context "to stdout" do
+    let(:location) { "-" }
+
+    it "exports to stdout" do
+      expect(inittab).to receive(:puts).with(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
+      expect(File.read("/tmp/inittab")).to eq(example_export_file("inittab/inittab.concurrency"))
+    end
+  end
+
+end

data/spec/foreman/export/launchd_spec.rb

@@ -0,0 +1,31 @@
+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) { allow(launchd).to receive(:say) }
+
+  it "exports to the filesystem" do
+    launchd.export
+    expect(File.read("/tmp/init/app-alpha-1.plist")).to eq(example_export_file("launchd/launchd-a.default"))
+    expect(File.read("/tmp/init/app-bravo-1.plist")).to eq(example_export_file("launchd/launchd-b.default"))
+  end
+
+  context "with multiple command arguments" do
+    let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile", "charlie") }
+
+    it "splits each command argument" do
+      launchd.export
+      expect(File.read("/tmp/init/app-alpha-1.plist")).to eq(example_export_file("launchd/launchd-c.default"))
+    end
+
+  end
+
+end

data/spec/foreman/export/runit_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/runit"
+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(: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) { allow(runit).to receive(:say) }
+  before(:each) { allow(FakeFS::FileUtils).to receive(:chmod) }
+
+  it "exports to the filesystem" do
+    engine.env["BAR"] = "baz"
+    runit.export
+
+    expect(File.read("/tmp/init/app-alpha-1/run")).to      eq(example_export_file('runit/app-alpha-1/run'))
+    expect(File.read("/tmp/init/app-alpha-1/log/run")).to  eq(example_export_file('runit/app-alpha-1/log/run'))
+    expect(File.read("/tmp/init/app-alpha-1/env/PORT")).to eq("5000\n")
+    expect(File.read("/tmp/init/app-alpha-1/env/BAR")).to  eq("baz\n")
+    expect(File.read("/tmp/init/app-alpha-2/run")).to      eq(example_export_file('runit/app-alpha-2/run'))
+    expect(File.read("/tmp/init/app-alpha-2/log/run")).to  eq(example_export_file('runit/app-alpha-2/log/run'))
+    expect(File.read("/tmp/init/app-alpha-2/env/PORT")).to eq("5001\n")
+    expect(File.read("/tmp/init/app-alpha-2/env/BAR")).to  eq("baz\n")
+    expect(File.read("/tmp/init/app-bravo-1/run")).to      eq(example_export_file('runit/app-bravo-1/run'))
+    expect(File.read("/tmp/init/app-bravo-1/log/run")).to  eq(example_export_file('runit/app-bravo-1/log/run'))
+    expect(File.read("/tmp/init/app-bravo-1/env/PORT")).to eq("5100\n")
+  end
+
+  it "creates a full path to the export directory" do
+    expect { runit.export }.to_not raise_error
+  end
+end

data/spec/foreman/export/supervisord_spec.rb

@@ -0,0 +1,38 @@
+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) { allow(supervisord).to receive(:say) }
+
+  it "exports to the filesystem" do
+    write_env(".env", "FOO"=>"bar", "URL"=>"http://example.com/api?foo=bar&baz=1")
+    supervisord.engine.load_env('.env')
+    supervisord.export
+    expect(File.read("/tmp/init/app.conf")).to eq(example_export_file("supervisord/app-alpha-1.conf"))
+  end
+
+  it "cleans up if exporting into an existing dir" do
+    expect(FileUtils).to receive(:rm).with("/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
+      expect(File.read("/tmp/init/app.conf")).to eq(example_export_file("supervisord/app-alpha-2.conf"))
+    end
+  end
+
+end