freud 0.0.1

data/lib/freud/version.rb

@@ -0,0 +1,3 @@
+module Freud
+  VERSION = "0.0.1"
+end

data/spec/config_spec.rb

@@ -0,0 +1,141 @@
+require "spec_helper"
+require "freud/config"
+
+RSpec.describe Freud::Config do
+    let(:config) { Freud::Config.new }
+
+    describe "#snakify_string" do
+        def call(input)
+            config.snakify_string(input)
+        end
+
+        it { expect(call("")).to eq("") }
+
+        it { expect(call("hello")).to eq("hello") }
+
+        it { expect(call("helloWorld")).to eq("hello_world") }
+
+        it { expect(call("HelloWorld")).to eq("hello_world") }
+
+        it { expect(call("Helloworld")).to eq("helloworld") }
+
+        it { expect(call("ThinkABC")).to eq("think_abc") }
+    end
+
+    describe "#expand_path" do
+        def call(path, relative_to)
+            config.expand_path(path, relative_to)
+        end
+
+        it { expect(call(".", "/tmp")).to eq("/tmp") }
+
+        it { expect(call("../root", "/tmp")).to eq("/root") }
+
+        it { expect(call("/root", "/tmp")).to eq("/root") }
+
+        it { expect(call("foo", "/tmp")).to eq("/tmp/foo") }
+    end
+
+    it "#deep_merge" do
+        left = { a: { b: { c: 42 } } }
+        right = { a: { b: { d: 72 } } }
+        output = { a: { b: { c: 42, d: 72 } } }
+        expect(config.deep_merge(left, right)).to eq(output)
+    end
+
+    it "#snakify_keys" do
+        input = { "aKey" => "a" }
+        expect(config.snakify_keys(input)).to eq("a_key" => "a")
+    end
+
+    it "#snakify_keys not recursive" do
+        input = { "aKey" => { "bKey" => "b" } }
+        expect(config.snakify_keys(input)).to eq("a_key" => { "bKey" => "b" })
+    end
+
+    describe "#load" do
+        def mock_file(name, content = nil)
+            default = { stages: { back: {} } }
+            content ||= block_given? ? yield : default
+            content = JSON.dump(content) if content.is_a?(Hash)
+            double(read: content, path: name, close: true)
+        end
+
+        def call(file, stage = "development")
+            Freud::Config.new.load(file, stage)
+        end
+
+        let(:root) { File.expand_path("#{File.dirname(__FILE__)}/..") }
+
+        it "name from file with extension" do
+            config = call(mock_file("monkey.json"))
+            expect(config.fetch("name")).to eq("monkey")
+        end
+
+        it "name from file with extension" do
+            config = call(mock_file("monkey"))
+            expect(config.fetch("name")).to eq("monkey")
+        end
+
+        it "pidfile tmp/%name" do
+            config = call(mock_file("monkey"))
+            expect(config.fetch("pidfile")).to eq("#{root}/tmp/monkey.pid")
+        end
+
+        it "pidfile %HOME/tmp/%name" do
+            home = ENV["HOME"]
+            content = { pidfile: "%HOME/tmp/%name.pid" }
+            config = call(mock_file("monkey", content))
+            expect(config.fetch("pidfile")).to eq("#{home}/tmp/monkey.pid")
+        end
+
+        it "logfile" do
+            content = { logfile: "log/%name.log" }
+            config = call(mock_file("monkey", content))
+            expect(config.fetch("logfile")).to eq("#{root}/log/monkey.log")
+        end
+
+        it "env FREUD_STAGE" do
+            config = call(mock_file("monkey"), "back")
+            env = config.to_hash.fetch("env")
+            expect(env["FREUD_STAGE"]).to eq("back")
+        end
+
+        it "background" do
+            config = call(mock_file("monkey", background: true))
+            expect(config.fetch("background")).to be(true)
+        end
+
+        it "reset_env" do
+            config = call(mock_file("monkey", reset_env: true))
+            expect(config.fetch("reset_env")).to be(true)
+        end
+
+        it "create_pidfile" do
+            config = call(mock_file("monkey", create_pidfile: true))
+            expect(config.fetch("create_pidfile")).to be(true)
+        end
+
+        it "javascript comments" do
+            content = mock_file("monkey", <<-END)
+                {
+                    // Comment one.
+                    "reset_env": true,
+                    /* Comment two */
+                    "name": "quux"
+                }
+            END
+            config = call(content)
+            expect(config.fetch("reset_env")).to be(true)
+            expect(config.fetch("name")).to eq("quux")
+        end
+
+        it "interpolates fully-merged" do
+            vars = { vars: { "RUNAS_USER" => "bob" } }
+            content = mock_file("monkey", sudo_user: "%RUNAS_USER",
+                stages: { development: vars })
+            config = call(content)
+            expect(config.fetch("sudo_user")).to eq("bob")
+        end
+    end
+end

data/spec/fixtures/true.json

@@ -0,0 +1,6 @@
+{
+    "root": "../..",
+    "pidfile": "tmp/true.pid",
+    "logfile": "tmp/true.log",
+    "commands": { "quux": "/bin/true" }
+}

data/spec/launcher_spec.rb

@@ -0,0 +1,114 @@
+require "spec_helper"
+require "fileutils"
+require "stringio"
+require "freud/logging"
+require "freud/launcher"
+require "freud/pidfile"
+
+RSpec.describe Freud::Launcher do
+    let(:log) { StringIO.new }
+
+    before(:each) { Freud::Logging.log_to(log) }
+
+    it "#new" do
+        fields = %w(name root pidfile logfile background create_pidfile
+            reset_env env commands)
+        command = Freud::Launcher.new(Hash[fields.map { |k| [ k, 42 ] }])
+        fields.each { |f| expect(command.send(f)).to eq(42) }
+    end
+
+    describe "#run" do
+        let(:process) { double }
+
+        let(:pidfile) { double(Freud::Pidfile) }
+
+        after(:each) { FileUtils.rm_f("tmp/foo.json") }
+
+        def try(config, runnable, *args, &block)
+            command = Freud::Launcher.new(config)
+            trial = lambda { command.run(runnable, args) }
+            return(trial.call) unless block_given?
+            expect(trial).to raise_error(Freud::RunnerExit, &block)
+        end
+
+        describe "execute" do
+            it "bad external command" do
+                allow(pidfile).to receive(:read).and_return(35767)
+                config = { "process" => process, "pidfile" => pidfile,
+                    "env" => {}, "commands" => {} }
+                try(config, "notacommand") { |e| expect(e.value).to eq(1) }
+            end
+
+            it "test: /bin/true" do
+                allow(pidfile).to receive(:read).and_return(35767)
+                config = { "process" => process, "pidfile" => pidfile,
+                    "env" => {}, "commands" => { "test" => "/bin/true" } }
+                expect(process).to receive(:exec).with({}, "/bin/true",
+                    { unsetenv_others: false, chdir: nil, close_others: true,
+                    in: "/dev/null", out: :err })
+                try(config, "test")
+            end
+        end
+
+        describe "daemonize" do
+            it "bad external command" do
+                allow(pidfile).to receive(:read).and_return(35767)
+                config = { "process" => process, "pidfile" => pidfile,
+                    "env" => {}, "commands" => {} }
+                try(config, "start") { |e| expect(e.value).to eq(1) }
+            end
+
+            it "background: false" do
+                allow(pidfile).to receive(:read).and_return(nil)
+                allow(pidfile).to receive(:running?).and_return(false)
+                allow(process).to receive(:pid).and_return(35767)
+                config = { "process" => process, "pidfile" => pidfile,
+                    "env" => {}, "background" => false,
+                    "commands" => { "start" => "/bin/true" } }
+                expect(process).to receive(:exec).with({}, "/bin/true",
+                    { unsetenv_others: false, chdir: nil, close_others: true,
+                    in: "/dev/null", out: :err })
+                try(config, "start")
+            end
+
+            it "background: true" do
+                allow(pidfile).to receive(:read).and_return(nil)
+                allow(pidfile).to receive(:running?).and_return(false)
+                config = { "process" => process, "pidfile" => pidfile,
+                    "env" => {}, "background" => true,
+                    "commands" => { "start" => "/bin/true" } }
+                expect(process).to receive(:spawn).with({}, "/bin/true",
+                    { unsetenv_others: false, chdir: nil, close_others: true,
+                    in: "/dev/null", out: :err, pgroup: true })
+                try(config, "start")
+            end
+
+            it "reset_env" do
+                allow(pidfile).to receive(:read).and_return(nil)
+                allow(pidfile).to receive(:running?).and_return(false)
+                allow(process).to receive(:pid).and_return(35767)
+                config = { "process" => process, "pidfile" => pidfile,
+                    "env" => {}, "reset_env" => true,
+                    "commands" => { "start" => "/bin/true" } }
+                expect(process).to receive(:exec).with({}, "/bin/true",
+                    { unsetenv_others: true, chdir: nil, close_others: true,
+                    in: "/dev/null", out: :err })
+                try(config, "start")
+            end
+
+            it "create_pidfile" do
+                allow(pidfile).to receive(:read).and_return(nil)
+                allow(pidfile).to receive(:running?).and_return(false)
+                allow(pidfile).to receive(:write).with(35767)
+                allow(process).to receive(:pid).and_return(35767)
+                config = { "process" => process, "pidfile" => pidfile,
+                    "env" => {}, "create_pidfile" => true,
+                    "commands" => { "start" => "/bin/true" } }
+                expect(process).to receive(:exec).with({}, "/bin/true",
+                    { unsetenv_others: false, chdir: nil, close_others: true,
+                    in: "/dev/null", out: :err })
+                try(config, "start")
+            end
+        end
+    end
+end

data/spec/pidfile_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+require "freud/pidfile"
+
+RSpec.describe Freud::Pidfile do
+    PIDFILE = "tmp/freud.pid"
+
+    let(:pidfile) { Freud::Pidfile.new(PIDFILE) }
+
+    after(:each) { FileUtils.rm(PIDFILE) if File.exists?(PIDFILE) }
+
+    it "#write" do
+        pidfile.write(Process.pid)
+        expect(File.exists?(PIDFILE)).to be(true)
+    end
+
+    it "#read" do
+        expect(pidfile.read).to be_nil
+        pidfile.write(Process.pid)
+        expect(pidfile.read).to eq(Process.pid)
+    end
+
+    it "#running? true" do
+        pidfile.write(Process.pid)
+        expect(pidfile.running?).to be(true)
+    end
+
+    # NOTE: This will (obviously) fail if a process with that pid exists,
+    # but it's the maximum pid on a Linux system, and likely to be not used.
+    it "#running? false" do
+        pidfile.write(32768)
+        expect(pidfile.running?).to be(false)
+    end
+
+    it "#to_s returns path" do
+        expect(pidfile.to_s).to eq(PIDFILE)
+    end
+
+    it "== path" do
+        expect(pidfile).to eq(PIDFILE)
+    end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,133 @@
+require "spec_helper"
+require "freud/runner"
+require "set"
+
+RSpec.describe Freud::Runner do
+    def unused_pid
+        used = Set.new(`ps -A | awk '{print $1}'`.split(/\n/))
+        output = 35767.step(1, -1).find { |pid| not used.include?(pid.to_s) }
+        raise("Can't find an unused pid.") unless output
+        output
+    end
+
+    let(:root) { File.expand_path("#{File.dirname(__FILE__)}/..") }
+
+    let(:runner) { Freud::Runner.new }
+
+    let(:process) { double }
+
+    let(:pidfile) { double(Freud::Pidfile) }
+
+    let(:log) { StringIO.new }
+
+    before(:each) { Freud::Logging.log_to(log) }
+    
+    after(:each) do
+        FileUtils.rm_f("tmp/generated.json")
+        FileUtils.rm_f("tmp/true.pid")
+    end
+
+    it ".run" do
+        expect { Freud::Runner.run([]) }.to raise_error(SystemExit)
+    end
+
+    describe "#run" do
+        def try(runnable, &block)
+            expect(runnable).to raise_error(Freud::RunnerExit, &block)
+        end
+
+        after(:each) do
+            ENV.delete("FREUD_CONFIG")
+            ENV.delete("FREUD_STAGE")
+            ENV.delete("FREUD_SERVICE_PATH")
+        end
+
+        it "@check (up)" do
+            Freud::Pidfile.new("#{root}/tmp/true.pid").write(Process.pid)
+            args = [ "@check", "spec/fixtures/true.json" ]
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(0) }
+        end
+
+        it "@check via FREUD_CONFIG" do
+            ENV["FREUD_CONFIG"] = "spec/fixtures/true.json"
+            Freud::Pidfile.new("#{root}/tmp/true.pid").write(Process.pid)
+            args = [ "@check" ]
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(0) }
+            log.rewind
+            expect(log.read).to match(/\bup\b/)
+        end
+
+        it "@check (down)" do
+            ENV["FREUD_CONFIG"] = "spec/fixtures/true.json"
+            Freud::Pidfile.new("#{root}/tmp/true.pid").write(unused_pid)
+            args = [ "@check", "spec/fixtures/true.json" ]
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(0) }
+            log.rewind
+            expect(log.read).to match(/\bdown\b/)
+        end
+
+        it "@wait-up (up)" do
+            ENV["FREUD_CONFIG"] = "spec/fixtures/true.json"
+            Freud::Pidfile.new("#{root}/tmp/true.pid").write(Process.pid)
+            args = [ "@wait-up", "-t", "1" ]
+            started_at = Time.now.to_i
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(0) }
+            expect(Time.now.to_i - started_at).to be < 2
+        end
+
+        it "@wait-up (down)" do
+            ENV["FREUD_CONFIG"] = "spec/fixtures/true.json"
+            Freud::Pidfile.new("#{root}/tmp/true.pid").write(unused_pid)
+            args = [ "@wait-up", "-t", "1" ]
+            started_at = Time.now.to_i
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(1) }
+            expect(Time.now.to_i - started_at).to be < 2
+        end
+
+        it "@wait-down (down)" do
+            ENV["FREUD_CONFIG"] = "spec/fixtures/true.json"
+            Freud::Pidfile.new("#{root}/tmp/true.pid").write(unused_pid)
+            args = [ "@wait-down", "-t", "1" ]
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(0) }
+        end
+
+        it "@wait-down (up)" do
+            ENV["FREUD_CONFIG"] = "spec/fixtures/true.json"
+            Freud::Pidfile.new("#{root}/tmp/true.pid").write(Process.pid)
+            args = [ "@wait-down", "-t", "1" ]
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(1) }
+        end
+
+        it "generate" do
+            Freud::Pidfile.new("#{root}/tmp/true.pid").write(unused_pid)
+            args = [ "g", "tmp/generated.json" ]
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(0) }
+            generated = "#{root}/tmp/generated.json"
+            expect(File.exists?(generated)).to be(true)
+            expect { JSON.parse(File.read(generated)) }.to_not raise_error
+        end
+
+        it "usage" do
+            Freud::Pidfile.new("#{root}/tmp/true.pid").write(unused_pid)
+            try(lambda { runner.run([]) }) do |result|
+                expect(result.value).to eq(1)
+                expect(result.message).to match(/usage/i)
+            end
+        end
+
+        it "help" do
+            args = [ "help", "spec/fixtures/true.json" ]
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(0) }
+            log.rewind
+            expect(log.read).to match(/quux/)
+        end
+
+        it "FREUD_SERVICE_PATH" do
+            ENV["FREUD_SERVICE_PATH"] = "spec/fixtures"
+            args = [ "help", "true" ]
+            try(lambda { runner.run(args) }) { |r| expect(r.value).to eq(0) }
+            log.rewind
+            expect(log.read).to match(/quux/)
+        end
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+root = File.join(File.dirname(File.expand_path(__FILE__)), "..")
+$LOAD_PATH.unshift(root) unless $LOAD_PATH.include?(root)
+
+require "simplecov"
+
+SimpleCov.start do
+    add_filter "/spec/"
+end
+
+RSpec.configure do |config|
+    config.filter_run(:focus)
+    config.run_all_when_everything_filtered = true
+    config.order = :random
+    config.default_formatter = "doc" if config.files_to_run.one?
+    Kernel.srand(config.seed)
+
+    config.expect_with :rspec do |expectations|
+        expectations.syntax = :expect
+    end
+
+    config.mock_with :rspec do |mocks|
+        mocks.syntax = :expect
+        mocks.verify_partial_doubles = true
+    end
+end