foreman-systemd 0.78.0

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) { stub(runit).say }
+  before(:each) { stub(FakeFS::FileUtils).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,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
+    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
+    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
+      expect(File.read("/tmp/init/app.conf")).to eq(example_export_file("supervisord/app-alpha-2.conf"))
+    end
+  end
+
+end

data/spec/foreman/export/systemd_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/systemd"
+require "tmpdir"
+
+describe Foreman::Export::Systemd, :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(:systemd)   { Foreman::Export::Systemd.new("/tmp/init", engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("systemd") }
+  before(:each) { stub(systemd).say }
+
+  it "exports to the filesystem" do
+    systemd.export
+
+    expect(File.read("/tmp/init/app.target")).to          eq(example_export_file("systemd/standard/app.target"))
+    expect(File.read("/tmp/init/app-alpha.target")).to    eq(example_export_file("systemd/standard/app-alpha.target"))
+    expect(File.read("/tmp/init/app-alpha-1.service")).to eq(example_export_file("systemd/standard/app-alpha-1.service"))
+    expect(File.read("/tmp/init/app-bravo.target")).to    eq(example_export_file("systemd/standard/app-bravo.target"))
+    expect(File.read("/tmp/init/app-bravo-1.service")).to eq(example_export_file("systemd/standard/app-bravo-1.service"))
+  end
+
+  it "cleans up if exporting into an existing dir" do
+    mock(FileUtils).rm("/tmp/init/app.target")
+    mock(FileUtils).rm("/tmp/init/app-alpha.target")
+    mock(FileUtils).rm("/tmp/init/app-alpha-1.service")
+    mock(FileUtils).rm("/tmp/init/app-bravo.target")
+    mock(FileUtils).rm("/tmp/init/app-bravo-1.service")
+    mock(FileUtils).rm("/tmp/init/app-foo-bar.target")
+    mock(FileUtils).rm("/tmp/init/app-foo-bar-1.service")
+    mock(FileUtils).rm("/tmp/init/app-foo_bar.target")
+    mock(FileUtils).rm("/tmp/init/app-foo_bar-1.service")
+
+    systemd.export
+    systemd.export
+  end
+
+  it "includes environment variables" do
+    engine.env['KEY'] = 'some "value"'
+    systemd.export
+    expect(File.read("/tmp/init/app-alpha-1.service")).to match(/KEY=some "value"$/)
+  end
+
+  context "with a formation" do
+    let(:formation) { "alpha=2" }
+
+    it "exports to the filesystem with concurrency" do
+      systemd.export
+
+      expect(File.read("/tmp/init/app.target")).to             eq(example_export_file("systemd/concurrency/app.target"))
+      expect(File.read("/tmp/init/app-alpha.target")).to       eq(example_export_file("systemd/concurrency/app-alpha.target"))
+      expect(File.read("/tmp/init/app-alpha-1.service")).to    eq(example_export_file("systemd/concurrency/app-alpha-1.service"))
+      expect(File.read("/tmp/init/app-alpha-2.service")).to    eq(example_export_file("systemd/concurrency/app-alpha-2.service"))
+      expect(File.exists?("/tmp/init/app-bravo-1.service")).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.target.erb", "w") { |f| f.puts "alternate_template" }
+    end
+
+    it "can export with alternate template files" do
+      systemd.export
+      expect(File.read("/tmp/init/app.target")).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/systemd")
+      File.open(File.expand_path("~/.foreman/templates/systemd/master.target.erb"), "w") do |file|
+        file.puts "default_alternate_template"
+      end
+    end
+
+    it "can export with alternate template files" do
+      systemd.export
+      expect(File.read("/tmp/init/app.target")).to eq("default_alternate_template\n")
+    end
+  end
+
+end

data/spec/foreman/export/upstart_spec.rb

@@ -0,0 +1,118 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/upstart"
+require "tmpdir"
+
+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
+
+    expect(File.read("/tmp/init/app.conf")).to         eq(example_export_file("upstart/app.conf"))
+    expect(File.read("/tmp/init/app-alpha.conf")).to   eq(example_export_file("upstart/app-alpha.conf"))
+    expect(File.read("/tmp/init/app-alpha-1.conf")).to eq(example_export_file("upstart/app-alpha-1.conf"))
+    expect(File.read("/tmp/init/app-bravo.conf")).to   eq(example_export_file("upstart/app-bravo.conf"))
+    expect(File.read("/tmp/init/app-bravo-1.conf")).to eq(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")
+    mock(FileUtils).rm("/tmp/init/app-foo-bar.conf")
+    mock(FileUtils).rm("/tmp/init/app-foo-bar-1.conf")
+    mock(FileUtils).rm("/tmp/init/app-foo_bar.conf")
+    mock(FileUtils).rm("/tmp/init/app-foo_bar-1.conf")
+
+    upstart.export
+    upstart.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)
+      dont_allow(FileUtils).rm(path)
+    end
+
+    upstart.export
+  end
+
+  it 'does not delete exported files for app which share name prefix' do
+    FileUtils.mkdir_p "/tmp/init"
+
+    ["app-worker", "app-worker-worker", "app-worker-worker-1"].each do |name|
+      path = "/tmp/init/#{name}.conf"
+      FileUtils.touch(path)
+      dont_allow(FileUtils).rm(path)
+    end
+
+    upstart.export
+    expect(File.exist?('/tmp/init/app.conf')).to be true
+    expect(File.exist?('/tmp/init/app-worker.conf')).to be true
+  end
+
+  it "quotes and escapes environment variables" do
+    engine.env['KEY'] = 'd"\|d'
+    upstart.export
+    expect("foobarfoo").to include "bar"
+    expect(File.read("/tmp/init/app-alpha-1.conf")).to match(/KEY='d"\\\|d'/)
+  end
+
+  context "with a formation" do
+    let(:formation) { "alpha=2" }
+
+    it "exports to the filesystem with concurrency" do
+      upstart.export
+
+      expect(File.read("/tmp/init/app.conf")).to            eq(example_export_file("upstart/app.conf"))
+      expect(File.read("/tmp/init/app-alpha.conf")).to      eq(example_export_file("upstart/app-alpha.conf"))
+      expect(File.read("/tmp/init/app-alpha-1.conf")).to    eq(example_export_file("upstart/app-alpha-1.conf"))
+      expect(File.read("/tmp/init/app-alpha-2.conf")).to    eq(example_export_file("upstart/app-alpha-2.conf"))
+      expect(File.exists?("/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
+      upstart.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/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
+      expect(File.read("/tmp/init/app.conf")).to eq("default_alternate_template\n")
+    end
+  end
+
+end

data/spec/foreman/export_spec.rb

@@ -0,0 +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
+    expect(subject.classify("foo")).to eq("Foo")
+    expect(subject.classify("foo-bar")).to eq("FooBar")
+  end
+
+  it "should constantize words" do
+    expect(subject.constantize("Object")).to eq(Object)
+    expect(subject.constantize("Foo::Bar")).to eq(Foo::Bar)
+  end
+end

data/spec/foreman/process_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'foreman/process'
+require 'ostruct'
+require 'timeout'
+require 'tmpdir'
+
+describe Foreman::Process do
+
+  def run(process, options={})
+    rd, wr = IO.method(:pipe).arity.zero? ? IO.pipe : IO.pipe("BINARY")
+    process.run(options.merge(:output => wr))
+    rd.gets
+  end
+
+  describe "#run" do
+
+    it "runs the process" do
+      process = Foreman::Process.new(resource_path("bin/test"))
+      expect(run(process)).to eq("testing\n")
+    end
+
+    it "can set environment" do
+      process = Foreman::Process.new(resource_path("bin/env FOO"), :env => { "FOO" => "bar" })
+      expect(run(process)).to eq("bar\n")
+    end
+
+    it "can set per-run environment" do
+      process = Foreman::Process.new(resource_path("bin/env FOO"))
+      expect(run(process, :env => { "FOO" => "bar "})).to eq("bar\n")
+    end
+
+    it "can handle env vars in the command" do
+      process = Foreman::Process.new(resource_path("bin/echo $FOO"), :env => { "FOO" => "bar" })
+      expect(run(process)).to eq("bar\n")
+    end
+
+    it "can handle per-run env vars in the command" do
+      process = Foreman::Process.new(resource_path("bin/echo $FOO"))
+      expect(run(process, :env => { "FOO" => "bar" })).to eq("bar\n")
+    end
+
+    it "should output utf8 properly" do
+      process = Foreman::Process.new(resource_path("bin/utf8"))
+      expect(run(process)).to eq(Foreman.ruby_18? ? "\xFF\x03\n" : "\xFF\x03\n".force_encoding('binary'))
+    end
+
+    it "can expand env in the command" do
+      process = Foreman::Process.new("command $FOO $BAR", :env => { "FOO" => "bar" })
+      expect(process.expanded_command).to eq("command bar $BAR")
+    end
+
+    it "can expand extra env in the command" do
+      process = Foreman::Process.new("command $FOO $BAR", :env => { "FOO" => "bar" })
+      expect(process.expanded_command("BAR" => "qux")).to eq("command bar qux")
+    end
+
+    it "can execute" do
+      mock(Kernel).exec "bin/command"
+      process = Foreman::Process.new("bin/command")
+      process.exec
+    end
+
+    it "can execute with env" do
+      mock(Kernel).exec "bin/command bar"
+      process = Foreman::Process.new("bin/command $FOO")
+      process.exec(:env => { "FOO" => "bar" })
+    end
+
+  end
+
+end

data/spec/foreman/procfile_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'foreman/procfile'
+require 'pathname'
+require 'tmpdir'
+
+describe Foreman::Procfile, :fakefs do
+  subject { Foreman::Procfile.new }
+
+  it "can load from a file" do
+    write_procfile
+    subject.load "Procfile"
+    expect(subject["alpha"]).to eq("./alpha")
+    expect(subject["bravo"]).to eq("./bravo")
+  end
+
+  it "loads a passed-in Procfile" do
+    write_procfile
+    procfile = Foreman::Procfile.new("Procfile")
+    expect(procfile["alpha"]).to   eq("./alpha")
+    expect(procfile["bravo"]).to   eq("./bravo")
+    expect(procfile["foo-bar"]).to eq("./foo-bar")
+    expect(procfile["foo_bar"]).to eq("./foo_bar")
+  end
+
+  it "can have a process appended to it" do
+    subject["charlie"] = "./charlie"
+    expect(subject["charlie"]).to eq("./charlie")
+  end
+
+  it "can write to a string" do
+    subject["foo"] = "./foo"
+    subject["bar"] = "./bar"
+    expect(subject.to_s).to eq("foo: ./foo\nbar: ./bar")
+  end
+
+  it "can write to a file" do
+    subject["foo"] = "./foo"
+    subject["bar"] = "./bar"
+    subject.save "/tmp/proc"
+    expect(File.read("/tmp/proc")).to eq("foo: ./foo\nbar: ./bar\n")
+  end
+
+end