daqing_figaro 1.2.1

data/spec/figaro/cli/heroku_set_spec.rb

@@ -0,0 +1,67 @@
+describe "figaro heroku:set" do
+  before do
+    create_directory("example")
+    cd("example")
+    write_file("config/application.yml", "foo: bar")
+  end
+
+  it "sends Figaro configuration to Heroku" do
+    run_command_and_stop("figaro heroku:set")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args).to eq(["config:set", "foo=bar"])
+  end
+
+  it "respects path" do
+    write_file("env.yml", "foo: bar")
+
+    run_command_and_stop("figaro heroku:set -p env.yml")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args).to eq(["config:set", "foo=bar"])
+  end
+
+  it "respects environment" do
+    overwrite_file("config/application.yml", <<-EOF)
+foo: bar
+test:
+  foo: baz
+EOF
+
+    run_command_and_stop("figaro heroku:set -e test")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args).to eq(["config:set", "foo=baz"])
+  end
+
+  it "targets a specific Heroku app" do
+    run_command_and_stop("figaro heroku:set -a foo-bar-app")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args.shift).to eq("config:set")
+    expect(command.args).to match_array(["foo=bar", "--app=foo-bar-app"])
+  end
+
+  it "targets a specific Heroku git remote" do
+    run_command_and_stop("figaro heroku:set -r production")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args.shift).to eq("config:set")
+    expect(command.args).to match_array(["foo=bar", "--remote=production"])
+  end
+
+  it "handles values with special characters" do
+    overwrite_file("config/application.yml", "foo: bar baz")
+
+    run_command_and_stop("figaro heroku:set")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args).to eq(["config:set", "foo=bar baz"])
+  end
+end

data/spec/figaro/cli/install_spec.rb

@@ -0,0 +1,49 @@
+describe "figaro install" do
+  before do
+    create_directory("example")
+    cd("example")
+  end
+
+  it "creates a configuration file" do
+    run_command_and_stop("figaro install")
+
+    expect("config/application.yml").to be_an_existing_file
+  end
+
+  it "respects path" do
+    run_command_and_stop("figaro install -p env.yml")
+
+    expect("env.yml").to be_an_existing_file
+  end
+
+  context "with a .gitignore file" do
+    before do
+      write_file(".gitignore", <<-EOF)
+/foo
+/bar
+EOF
+    end
+
+    it "Git-ignores the configuration file if applicable" do
+      run_command_and_stop("figaro install")
+
+      expect(".gitignore").to have_file_content(%r(^/foo$))
+      expect(".gitignore").to have_file_content(%r(^/bar$))
+      expect(".gitignore").to have_file_content(%r(^/config/application\.yml$))
+    end
+
+    it "respects path" do
+      run_command_and_stop("figaro install -p env.yml")
+
+      expect(".gitignore").to have_file_content(%r(^/env\.yml$))
+    end
+  end
+
+  context "without a .gitignore file" do
+    it "doesn't generate a new .gitignore file" do
+      run_command_and_stop("figaro install")
+
+      expect(".gitignore").not_to be_an_existing_file
+    end
+  end
+end

data/spec/figaro/env_spec.rb

@@ -0,0 +1,195 @@
+describe Figaro::ENV do
+  subject(:env) { Figaro::ENV }
+
+  before do
+    ::ENV["HELLO"] = "world"
+    ::ENV["foo"] = "bar"
+  end
+
+  describe "#method_missing" do
+    context "plain methods" do
+      it "makes ENV values accessible as lowercase methods" do
+        expect(env.hello).to eq("world")
+        expect(env.foo).to eq("bar")
+      end
+
+      it "makes ENV values accessible as uppercase methods" do
+        expect(env.HELLO).to eq("world")
+        expect(env.FOO).to eq("bar")
+      end
+
+      it "makes ENV values accessible as mixed-case methods" do
+        expect(env.Hello).to eq("world")
+        expect(env.fOO).to eq("bar")
+      end
+
+      it "returns nil if no ENV key matches" do
+        expect(env.goodbye).to eq(nil)
+      end
+
+      it "respects a stubbed plain method" do
+        allow(env).to receive(:bar) { "baz" }
+        expect(env.bar).to eq("baz")
+      end
+    end
+
+    context "bang methods" do
+      it "makes ENV values accessible as lowercase methods" do
+        expect(env.hello!).to eq("world")
+        expect(env.foo!).to eq("bar")
+      end
+
+      it "makes ENV values accessible as uppercase methods" do
+        expect(env.HELLO!).to eq("world")
+        expect(env.FOO!).to eq("bar")
+      end
+
+      it "makes ENV values accessible as mixed-case methods" do
+        expect(env.Hello!).to eq("world")
+        expect(env.fOO!).to eq("bar")
+      end
+
+      it "raises an error if no ENV key matches" do
+        expect { env.goodbye! }.to raise_error(Figaro::MissingKey)
+      end
+
+      it "respects a stubbed plain method" do
+        allow(env).to receive(:bar) { "baz" }
+        expect { expect(env.bar!).to eq("baz") }.not_to raise_error
+      end
+    end
+
+    context "boolean methods" do
+      it "returns true for accessible, lowercase methods" do
+        expect(env.hello?).to eq(true)
+        expect(env.foo?).to eq(true)
+      end
+
+      it "returns true for accessible, uppercase methods" do
+        expect(env.HELLO?).to eq(true)
+        expect(env.FOO?).to eq(true)
+      end
+
+      it "returns true for accessible, mixed-case methods" do
+        expect(env.Hello?).to eq(true)
+        expect(env.fOO?).to eq(true)
+      end
+
+      it "returns false if no ENV key matches" do
+        expect(env.goodbye?).to eq(false)
+      end
+
+      it "respects a stubbed plain method" do
+        allow(env).to receive(:bar) { "baz" }
+        expect(env.bar?).to eq(true)
+      end
+    end
+
+    context "setter methods" do
+      it "raises an error for accessible, lowercase methods" do
+        expect { env.hello = "world" }.to raise_error(NoMethodError)
+        expect { env.foo = "bar" }.to raise_error(NoMethodError)
+      end
+
+      it "raises an error for accessible, uppercase methods" do
+        expect { env.HELLO = "world" }.to raise_error(NoMethodError)
+        expect { env.FOO = "bar" }.to raise_error(NoMethodError)
+      end
+
+      it "raises an error for accessible, mixed-case methods" do
+        expect { env.Hello = "world" }.to raise_error(NoMethodError)
+        expect { env.fOO = "bar" }.to raise_error(NoMethodError)
+      end
+
+      it "raises an error if no ENV key matches" do
+        expect { env.goodbye = "world" }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe "#respond_to?" do
+    context "plain methods" do
+      it "returns true for accessible, lowercase methods" do
+        expect(env.respond_to?(:hello)).to eq(true)
+        expect(env.respond_to?(:foo)).to eq(true)
+      end
+
+      it "returns true for accessible uppercase methods" do
+        expect(env.respond_to?(:HELLO)).to eq(true)
+        expect(env.respond_to?(:FOO)).to eq(true)
+      end
+
+      it "returns true for accessible mixed-case methods" do
+        expect(env.respond_to?(:Hello)).to eq(true)
+        expect(env.respond_to?(:fOO)).to eq(true)
+      end
+
+      it "returns true if no ENV key matches" do
+        expect(env.respond_to?(:baz)).to eq(true)
+      end
+    end
+
+    context "bang methods" do
+      it "returns true for accessible, lowercase methods" do
+        expect(env.respond_to?(:hello!)).to eq(true)
+        expect(env.respond_to?(:foo!)).to eq(true)
+      end
+
+      it "returns true for accessible uppercase methods" do
+        expect(env.respond_to?(:HELLO!)).to eq(true)
+        expect(env.respond_to?(:FOO!)).to eq(true)
+      end
+
+      it "returns true for accessible mixed-case methods" do
+        expect(env.respond_to?(:Hello!)).to eq(true)
+        expect(env.respond_to?(:fOO!)).to eq(true)
+      end
+
+      it "returns false if no ENV key matches" do
+        expect(env.respond_to?(:baz!)).to eq(false)
+      end
+    end
+
+    context "boolean methods" do
+      it "returns true for accessible, lowercase methods" do
+        expect(env.respond_to?(:hello?)).to eq(true)
+        expect(env.respond_to?(:foo?)).to eq(true)
+      end
+
+      it "returns true for accessible uppercase methods" do
+        expect(env.respond_to?(:HELLO?)).to eq(true)
+        expect(env.respond_to?(:FOO?)).to eq(true)
+      end
+
+      it "returns true for accessible mixed-case methods" do
+        expect(env.respond_to?(:Hello?)).to eq(true)
+        expect(env.respond_to?(:fOO?)).to eq(true)
+      end
+
+      it "returns true if no ENV key matches" do
+        expect(env.respond_to?(:baz?)).to eq(true)
+      end
+    end
+
+    context "setter methods" do
+      it "returns false for accessible, lowercase methods" do
+        expect(env.respond_to?(:hello=)).to eq(false)
+        expect(env.respond_to?(:foo=)).to eq(false)
+      end
+
+      it "returns false for accessible uppercase methods" do
+        expect(env.respond_to?(:HELLO=)).to eq(false)
+        expect(env.respond_to?(:FOO=)).to eq(false)
+      end
+
+      it "returns false for accessible mixed-case methods" do
+        expect(env.respond_to?(:Hello=)).to eq(false)
+        expect(env.respond_to?(:fOO=)).to eq(false)
+      end
+
+      it "returns false if no ENV key matches" do
+        expect(env.respond_to?(:baz=)).to eq(false)
+      end
+    end
+  end
+end

data/spec/figaro/rails/application_spec.rb

@@ -0,0 +1,41 @@
+module Figaro
+  module Rails
+    describe Application do
+      describe "#default_path" do
+        let!(:application) { Application.new }
+
+        it "defaults to config/application.yml in Rails.root" do
+          allow(::Rails).to receive(:root) { Pathname.new("/path/to/app") }
+
+          expect {
+            allow(::Rails).to receive(:root) { Pathname.new("/app") }
+          }.to change {
+            application.send(:default_path).to_s
+          }.from("/path/to/app/config/application.yml").to("/app/config/application.yml")
+        end
+
+        it "raises an error when Rails.root isn't set yet" do
+          allow(::Rails).to receive(:root) { nil }
+
+          expect {
+            application.send(:default_path)
+          }.to raise_error(RailsNotInitialized)
+        end
+      end
+
+      describe "#default_environment" do
+        let!(:application) { Application.new }
+
+        it "defaults to Rails.env" do
+          allow(::Rails).to receive(:env) { "development" }
+
+          expect {
+            allow(::Rails).to receive(:env) { "test" }
+          }.to change {
+            application.send(:default_environment).to_s
+          }.from("development").to("test")
+        end
+      end
+    end
+  end
+end

data/spec/figaro_spec.rb

@@ -0,0 +1,99 @@
+describe Figaro do
+  describe ".env" do
+    it "falls through to Figaro::ENV" do
+      expect(Figaro.env).to eq(Figaro::ENV)
+    end
+  end
+
+  describe ".adapter" do
+    let(:adapter) { double(:adapter) }
+
+    it "defaults to the generic application adapter" do
+      expect(Figaro.adapter).to eq(Figaro::Application)
+    end
+
+    it "is configurable" do
+      expect {
+        Figaro.adapter = adapter
+      }.to change {
+        Figaro.adapter
+      }.from(Figaro::Application).to(adapter)
+    end
+  end
+
+  describe ".application" do
+    let(:adapter) { double(:adapter) }
+    let(:application) { double(:application) }
+    let(:custom_application) { double(:custom_application) }
+
+    before do
+      allow(Figaro).to receive(:adapter) { adapter }
+      allow(adapter).to receive(:new).with(no_args) { application }
+    end
+
+    it "defaults to a new adapter application" do
+      expect(Figaro.application).to eq(application)
+    end
+
+    it "is configurable" do
+      expect {
+        Figaro.application = custom_application
+      }.to change {
+        Figaro.application
+      }.from(application).to(custom_application)
+    end
+  end
+
+  describe ".load" do
+    let(:application) { double(:application) }
+
+    before do
+      allow(Figaro).to receive(:application) { application }
+    end
+
+    it "loads the application configuration" do
+      expect(application).to receive(:load).once.with(no_args)
+
+      Figaro.load
+    end
+  end
+
+  describe ".require_keys" do
+    before do
+      ::ENV["foo"] = "bar"
+      ::ENV["hello"] = "world"
+    end
+
+    context "when no keys are missing" do
+      it "does nothing" do
+        expect {
+          Figaro.require_keys("foo", "hello")
+        }.not_to raise_error
+      end
+
+      it "accepts an array" do
+        expect {
+          Figaro.require_keys(["foo", "hello"])
+        }.not_to raise_error
+      end
+    end
+
+    context "when keys are missing" do
+      it "raises an error for the missing keys" do
+        expect {
+          Figaro.require_keys("foo", "goodbye", "baz")
+        }.to raise_error(Figaro::MissingKeys) { |error|
+          expect(error.message).not_to include("foo")
+          expect(error.message).to include("goodbye")
+          expect(error.message).to include("baz")
+        }
+      end
+
+      it "accepts an array" do
+        expect {
+          Figaro.require_keys(["foo", "goodbye", "baz"])
+        }.to raise_error(Figaro::MissingKeys)
+      end
+    end
+  end
+end

data/spec/rails_spec.rb

@@ -0,0 +1,55 @@
+describe Figaro::Rails do
+  before do
+    run_command_and_stop(<<-CMD)
+      rails new example \
+        --skip-gemfile \
+        --skip-git \
+        --skip-keeps \
+        --skip-sprockets \
+        --skip-spring \
+        --skip-listen \
+        --skip-javascript \
+        --skip-turbolinks \
+        --skip-test \
+        --skip-bootsnap \
+        --no-rc \
+        --skip-bundle \
+        --skip-webpack-install
+      CMD
+    cd("example")
+  end
+
+  describe "initialization" do
+    before do
+      write_file("config/application.yml", "foo: bar")
+    end
+
+    it "loads application.yml" do
+      run_command_and_stop("rails runner 'puts Figaro.env.foo'")
+
+      expect(all_stdout).to include("bar")
+    end
+
+    it "happens before database initialization" do
+      write_file("config/database.yml", <<-EOF)
+development:
+  adapter: sqlite3
+  database: db/<%= ENV["foo"] %>.sqlite3
+EOF
+
+      run_command_and_stop("rake db:migrate")
+
+      expect("db/bar.sqlite3").to be_an_existing_file
+    end
+
+    it "happens before application configuration" do
+      insert_into_file_after("config/application.rb", /< Rails::Application$/, <<-EOL)
+    config.foo = ENV["foo"]
+EOL
+
+      run_command_and_stop("rails runner 'puts Rails.application.config.foo'")
+
+      expect(all_stdout).to include("bar")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "bundler"
+Bundler.setup
+
+require "figaro"
+
+Bundler.require(:test)
+
+Dir[File.expand_path("../support/*.rb", __FILE__)].each { |f| require f }

data/spec/support/aruba.rb

@@ -0,0 +1,18 @@
+require "aruba/api"
+
+module ArubaHelpers
+  def insert_into_file_after(file, pattern, addition)
+    content = cd(".") { IO.read(file) }
+    content.sub!(pattern, "\\0\n#{addition}")
+    overwrite_file(file, content)
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Aruba::Api)
+  config.include(ArubaHelpers)
+
+  config.before do
+    setup_aruba
+  end
+end

data/spec/support/bin/heroku

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path("../../command_interceptor", __FILE__)
+
+CommandInterceptor.intercept("heroku")

data/spec/support/command_helpers.rb

@@ -0,0 +1,17 @@
+module CommandHelpers
+  def commands
+    CommandInterceptor.commands
+  end
+end
+
+RSpec.configure do |config|
+  config.include(CommandHelpers)
+
+  config.before(:suite) do
+    CommandInterceptor.setup
+  end
+
+  config.before do
+    CommandInterceptor.reset
+  end
+end

data/spec/support/command_interceptor.rb

@@ -0,0 +1,33 @@
+require "fileutils"
+require "ostruct"
+require "yaml"
+
+module CommandInterceptor
+  class Command < OpenStruct
+  end
+
+  BIN_PATH = File.expand_path("../bin", __FILE__)
+  LOG_PATH = File.expand_path("../../../tmp/commands.yml", __FILE__)
+
+  def self.setup
+    ENV["PATH"] = "#{BIN_PATH}:#{ENV["PATH"]}"
+  end
+
+  def self.intercept(name)
+    FileUtils.mkdir_p(File.dirname(LOG_PATH))
+    FileUtils.touch(LOG_PATH)
+
+    command = { "env" => ENV.to_hash, "name" => name, "args" => ARGV }
+    commands = self.commands << command
+
+    File.write(LOG_PATH, YAML.dump(commands))
+  end
+
+  def self.commands
+    (File.exist?(LOG_PATH) && YAML.load_file(LOG_PATH) || []).map { |c| Command.new(c) }
+  end
+
+  def self.reset
+    FileUtils.rm_f(LOG_PATH)
+  end
+end

data/spec/support/reset.rb

@@ -0,0 +1,13 @@
+RSpec.configure do |config|
+  config.before(:suite) do
+    $original_env_keys = ::ENV.keys
+  end
+
+  config.before do
+    Figaro.adapter = nil
+    Figaro.application = nil
+
+    # Restore the original state of ENV for each test
+    ::ENV.keep_if { |k, _| $original_env_keys.include?(k) }
+  end
+end