fiveman 0.1.0

data/spec/fiveman/export/inittab_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "fiveman/engine"
+require "fiveman/export/inittab"
+require "tmpdir"
+
+describe Fiveman::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)    { Fiveman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)   { Hash.new }
+  let(:inittab)   { Fiveman::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/fiveman/export/launchd_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+require "fiveman/engine"
+require "fiveman/export/launchd"
+require "tmpdir"
+
+describe Fiveman::Export::Launchd, :fakefs do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:options)  { Hash.new }
+  let(:engine)   { Fiveman::Engine.new().load_procfile(procfile) }
+  let(:launchd)  { Fiveman::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/fiveman/export/runit_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "fiveman/engine"
+require "fiveman/export/runit"
+require "tmpdir"
+
+describe Fiveman::Export::Runit, :fakefs do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile", 'bar=baz') }
+  let(:engine)   { Fiveman::Engine.new(:formation => "alpha=2,bravo=1").load_procfile(procfile) }
+  let(:options)  { Hash.new }
+  let(:runit)    { Fiveman::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/fiveman/export/supervisord_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "fiveman/engine"
+require "fiveman/export/supervisord"
+require "tmpdir"
+
+describe Fiveman::Export::Supervisord, :fakefs do
+  let(:procfile)    { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:formation)   { nil }
+  let(:engine)      { Fiveman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)     { Hash.new }
+  let(:supervisord) { Fiveman::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

data/spec/fiveman/export/systemd_spec.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+require "fiveman/engine"
+require "fiveman/export/systemd"
+require "tmpdir"
+
+describe Fiveman::Export::Systemd, :fakefs, :aggregate_failures do
+  let(:procfile)  { write_procfile("/tmp/app/Procfile") }
+  let(:formation) { nil }
+  let(:engine)    { Fiveman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)   { Hash.new }
+  let(:systemd)   { Fiveman::Export::Systemd.new("/tmp/init", engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("systemd") }
+  before(:each) { allow(systemd).to receive(:say) }
+
+  it "exports to the filesystem" do
+    systemd.export
+
+    expect(File.read("/tmp/init/app.target")).to eq(example_export_file("systemd/app.target"))
+    expect(File.read("/tmp/init/app-alpha.1.service")).to eq(example_export_file("systemd/app-alpha.1.service"))
+    expect(File.read("/tmp/init/app-bravo.1.service")).to eq(example_export_file("systemd/app-bravo.1.service"))
+  end
+
+  context "when systemd export was run using the previous version of systemd export" do
+    before do
+     write_file("/tmp/init/app.target")
+
+     write_file("/tmp/init/app-alpha@.service")
+     write_file("/tmp/init/app-alpha.target")
+     write_file("/tmp/init/app-alpha.target.wants/app-alpha@5000.service")
+
+     write_file("/tmp/init/app-bravo.target")
+     write_file("/tmp/init/app-bravo@.service")
+     write_file("/tmp/init/app-bravo.target.wants/app-bravo@5100.service")
+
+     write_file("/tmp/init/app-foo_bar.target")
+     write_file("/tmp/init/app-foo_bar@.service")
+     write_file("/tmp/init/app-foo_bar.target.wants/app-foo_bar@5200.service")
+
+     write_file("/tmp/init/app-foo-bar.target")
+     write_file("/tmp/init/app-foo-bar@.service")
+     write_file("/tmp/init/app-foo-bar.target.wants/app-foo-bar@5300.service")
+    end
+
+    it "cleans up service files created by systemd export" do
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app.target")
+
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha@.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha.target.wants/app-alpha@5000.service")
+      expect(FileUtils).to receive(:rm_r).with("/tmp/init/app-alpha.target.wants")
+
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo@.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo.target.wants/app-bravo@5100.service")
+      expect(FileUtils).to receive(:rm_r).with("/tmp/init/app-bravo.target.wants")
+
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar@.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar.target.wants/app-foo_bar@5200.service")
+      expect(FileUtils).to receive(:rm_r).with("/tmp/init/app-foo_bar.target.wants")
+
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar@.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar.target.wants/app-foo-bar@5300.service")
+      expect(FileUtils).to receive(:rm_r).with("/tmp/init/app-foo-bar.target.wants")
+
+      systemd.export
+    end
+  end
+
+  context "when systemd export was run using the current version of systemd export" do
+    before do
+      systemd.export
+    end
+
+    it "cleans up service files created by systemd export" do
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha.1.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo.1.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar.1.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar.1.service")
+
+      systemd.export
+    end
+  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
+
+  it "includes ExecStart line" do
+    engine.env['KEY'] = 'some "value"'
+    systemd.export
+    expect(File.read("/tmp/init/app-alpha.1.service")).to match(/^ExecStart=/)
+  end
+
+  context "with a custom formation specified" do
+    let(:formation) { "alpha=2" }
+
+    it "exports only those services that are specified in the formation" do
+      systemd.export
+
+      expect(File.read("/tmp/init/app.target")).to include("Wants=app-alpha.1.service app-alpha.2.service\n")
+      expect(File.read("/tmp/init/app-alpha.1.service")).to eq(example_export_file("systemd/app-alpha.1.service"))
+      expect(File.read("/tmp/init/app-alpha.2.service")).to eq(example_export_file("systemd/app-alpha.2.service"))
+      expect(File.exist?("/tmp/init/app-bravo.1.service")).to be_falsey
+    end
+  end
+
+  context "with alternate template directory specified" 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 "uses template files found in the alternate directory" do
+      systemd.export
+      expect(File.read("/tmp/init/app.target")).to eq("alternate_template\n")
+    end
+
+    context "with alternate templates in the user home directory" do
+      before do
+        FileUtils.mkdir_p File.expand_path("~/.fiveman/templates/systemd")
+        File.open(File.expand_path("~/.fiveman/templates/systemd/master.target.erb"), "w") do |file|
+          file.puts "home_dir_template"
+        end
+      end
+
+      it "uses template files found in the alternate directory" do
+        systemd.export
+        expect(File.read("/tmp/init/app.target")).to eq("alternate_template\n")
+      end
+    end
+  end
+
+  context "with alternate templates in the user home directory" do
+    before do
+      FileUtils.mkdir_p File.expand_path("~/.fiveman/templates/systemd")
+      File.open(File.expand_path("~/.fiveman/templates/systemd/master.target.erb"), "w") do |file|
+        file.puts "home_dir_template"
+      end
+    end
+
+    it "uses template files found in the user home directory" do
+      systemd.export
+      expect(File.read("/tmp/init/app.target")).to eq("home_dir_template\n")
+    end
+  end
+end

data/spec/fiveman/export/upstart_spec.rb

@@ -0,0 +1,118 @@
+require "spec_helper"
+require "fiveman/engine"
+require "fiveman/export/upstart"
+require "tmpdir"
+
+describe Fiveman::Export::Upstart, :fakefs do
+  let(:procfile)  { write_procfile("/tmp/app/Procfile") }
+  let(:formation) { nil }
+  let(:engine)    { Fiveman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)   { Hash.new }
+  let(:upstart)   { Fiveman::Export::Upstart.new("/tmp/init", engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("upstart") }
+  before(:each) { allow(upstart).to receive(: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
+    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")
+
+    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)
+      expect(FileUtils).to_not receive(:rm).with(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)
+      expect(FileUtils).to_not receive(:rm).with(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("~/.fiveman/templates/upstart")
+      File.open(File.expand_path("~/.fiveman/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/fiveman/export_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "fiveman/export"
+
+describe "Fiveman::Export" do
+  subject { Fiveman::Export }
+
+  describe "with a formatter that doesn't declare the appropriate class" do
+    it "prints an error" do
+      expect(subject).to receive(:require).with("fiveman/export/invalidformatter")
+      mock_export_error("Unknown export format: invalidformatter (no class Fiveman::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 'fiveman/export/invalidformatter').") do
+        subject.formatter("invalidformatter")
+      end
+    end
+  end
+end

data/spec/fiveman/helpers_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "fiveman/helpers"
+
+describe "Fiveman::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(Fiveman::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/fiveman/process_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'fiveman/process'
+require 'ostruct'
+require 'timeout'
+require 'tmpdir'
+
+describe Fiveman::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 = Fiveman::Process.new(resource_path("bin/test"))
+      expect(run(process)).to eq("testing\n")
+    end
+
+    it "can set environment" do
+      process = Fiveman::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 = Fiveman::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 = Fiveman::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 = Fiveman::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 = Fiveman::Process.new(resource_path("bin/utf8"))
+      expect(run(process)).to eq(Fiveman.ruby_18? ? "\xFF\x03\n" : "\xFF\x03\n".force_encoding('binary'))
+    end
+
+    it "can expand env in the command" do
+      process = Fiveman::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 = Fiveman::Process.new("command $FOO $BAR", :env => { "FOO" => "bar" })
+      expect(process.expanded_command("BAR" => "qux")).to eq("command bar qux")
+    end
+
+    it "can execute" do
+      expect(Kernel).to receive(:exec).with("bin/command")
+      process = Fiveman::Process.new("bin/command")
+      process.exec
+    end
+
+    it "can execute with env" do
+      expect(Kernel).to receive(:exec).with("bin/command bar")
+      process = Fiveman::Process.new("bin/command $FOO")
+      process.exec(:env => { "FOO" => "bar" })
+    end
+
+  end
+
+end

data/spec/fiveman/procfile_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'fiveman/procfile'
+require 'pathname'
+require 'tmpdir'
+
+describe Fiveman::Procfile, :fakefs do
+  subject { Fiveman::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 = Fiveman::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 'only creates Procfile entries for lines matching regex' do
+    write_procfile
+    procfile = Fiveman::Procfile.new("Procfile")
+    keys = procfile.instance_variable_get(:@entries).map(&:first)
+    expect(keys).to match_array(%w[alpha bravo foo-bar foo_bar])
+  end
+
+  it "returns nil when attempting to retrieve an non-existing entry" do
+    write_procfile
+    procfile = Fiveman::Procfile.new("Procfile")
+    expect(procfile["unicorn"]).to eq(nil)
+  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"
+    Dir.mkdir('/tmp')
+    subject.save "/tmp/proc"
+    expect(File.read("/tmp/proc")).to eq("foo: ./foo\nbar: ./bar\n")
+  end
+
+end

data/spec/fiveman_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+require "fiveman"
+
+describe Fiveman do
+
+  describe "VERSION" do
+    subject { Fiveman::VERSION }
+    it { is_expected.to be_a String }
+  end
+
+  describe "runner" do
+    it "should exist" do
+      expect(File.exist?(Fiveman.runner)).to eq(true)
+    end
+  end
+end

data/spec/helper_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe "spec helpers" do
+  describe "#preserving_env" do
+    after { ENV.delete "FOO" }
+
+    it "should remove added environment vars" do
+      old = ENV["FOO"]
+      preserving_env { ENV["FOO"] = "baz" }
+      expect(ENV["FOO"]).to eq(old)
+    end
+
+    it "should reset modified environment vars" do
+      ENV["FOO"] = "bar"
+      preserving_env { ENV["FOO"] = "baz"}
+      expect(ENV["FOO"]).to eq("bar")
+    end
+  end
+end

data/spec/resources/Procfile

@@ -0,0 +1,5 @@
+echo: bin/echo echoing
+env:  bin/env  FOO
+test: bin/test
+utf8: bin/utf8
+ps:   bin/echo PS env var is $PS

data/spec/resources/Procfile.bad

@@ -0,0 +1,2 @@
+good: sleep 1
+bad: false

data/spec/resources/bin/echo

@@ -0,0 +1,2 @@
+#!/bin/sh
+echo $*

data/spec/resources/bin/env

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo ${!1}

data/spec/resources/bin/test

@@ -0,0 +1,2 @@
+#!/bin/sh
+echo "testing"

data/spec/resources/bin/utf8

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+puts "\xff\x03"