seielit-figaro 1.1.2

data/spec/figaro/cli/heroku_set_spec.rb

@@ -0,0 +1,67 @@
+# describe "figaro heroku:set" do
+#   before do
+#     create_dir("example")
+#     cd("example")
+#     write_file("config/application.yml", "foo: bar")
+#   end
+
+#   it "sends Figaro configuration to Heroku" do
+#     run_simple("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_simple("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_simple("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_simple("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_simple("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_simple("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_dir("example")
+    cd("example")
+  end
+
+  it "creates a configuration file" do
+    run_simple("figaro install")
+
+    check_file_presence(["config/application.yml"], true)
+  end
+
+  it "respects path" do
+    run_simple("figaro install -p env.yml")
+
+    check_file_presence(["env.yml"], true)
+  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_simple("figaro install")
+
+      check_file_content(".gitignore", %r(^/foo$), true)
+      check_file_content(".gitignore", %r(^/bar$), true)
+      check_file_content(".gitignore", %r(^/config/application\.yml$), true)
+    end
+
+    it "respects path" do
+      run_simple("figaro install -p env.yml")
+
+      check_file_content(".gitignore", %r(^/env\.yml$), true)
+    end
+  end
+
+  context "without a .gitignore file" do
+    it "doesn't generate a new .gitignore file" do
+      run_simple("figaro install")
+
+      check_file_presence([".gitignore"], false)
+    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,47 @@
+require 'figaro/rails/application'
+
+module Figaro
+  module Rails
+    describe Application do
+      before do
+        stub_const('Rails', double('Rails'))
+      end
+
+      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/settings_spec.rb

@@ -0,0 +1,109 @@
+describe Figaro::Settings do
+  subject(:set) { Figaro::Settings }
+
+  before do
+    ::ENV["HELLO"] = "1234"
+    ::ENV["foo"] = "bar"
+    ::ENV["foo__bar"] = "baz"
+
+    ::ENV["true1"] = "on"
+    ::ENV["true2"] = "true"
+    ::ENV["true3"] = "yes"
+    ::ENV["true4"] = "enabled"
+
+    ::ENV["false1"] = "off"
+    ::ENV["false2"] = "false"
+    ::ENV["false3"] = "no"
+    ::ENV["false4"] = "disabled"
+  end
+
+  describe "#[]" do
+    context "building key" do
+      it "builds a simple key correctly" do
+        expect(set[:foo].key).to eq('foo')
+      end
+
+      it "builds a namespaced key correctly" do
+        expect(set[:foo][:bar].key).to eq('foo__bar')
+      end
+    end
+
+    context "accessing values" do
+      it "makes ENV values accessible using a simple key" do
+        expect(set[:foo].value).to eq('bar')
+      end
+      it "makes ENV values accessible using a namespaced key" do
+        expect(set[:foo][:bar].value).to eq('baz')
+      end
+    end
+
+    context "type conversion" do
+      context "plain methods" do
+        it "converts correct values successfully" do
+          expect(set[:foo].string).to eq('bar')
+          expect(set[:hello].int).to eq(1234)
+          expect(set[:hello].float).to eq(1234.0)
+          expect(set[:hello].decimal).to eq(BigDecimal(1234))
+          expect(set[:true1].bool).to be(true)
+          expect(set[:true2].bool).to be(true)
+          expect(set[:true3].bool).to be(true)
+          expect(set[:true4].bool).to be(true)
+          expect(set[:false1].bool).to be(false)
+          expect(set[:false2].bool).to be(false)
+          expect(set[:false3].bool).to be(false)
+          expect(set[:false4].bool).to be(false)
+        end
+
+        it "returns nil when value is invalid or non existing" do
+          expect(set[:foo].int).to be_nil
+          expect(set[:foos].int).to be_nil
+        end
+      end
+
+      context "bang methods" do
+        it "converts correct values successfully" do
+          expect(set[:foo].string!).to eq('bar')
+          expect(set[:hello].int!).to eq(1234)
+          expect(set[:hello].float!).to eq(1234.0)
+          expect(set[:hello].decimal!).to eq(BigDecimal(1234))
+        end
+
+        it "raises when value is invalid" do
+          expect { set[:foo].int! }.to raise_error(Figaro::Settings::DataTypes::InvalidKey)
+          expect { set[:foos].int! }.to raise_error(Figaro::Settings::DataTypes::InvalidKey)
+        end
+      end
+    end
+  end
+
+  describe "extending" do
+    context "requiring" do
+      it "requires valid settings without raising error" do
+        expect {
+          class TestSettings < Figaro::Settings
+            requires :hello,
+              :int
+            requires :foo
+          end
+        }.not_to raise_error
+      end
+
+      it "requires raises an error when requiring non-existing setting" do
+        expect {
+          class TestSettings < Figaro::Settings
+            requires :foos
+          end
+        }.to raise_error(Figaro::MissingKey)
+      end
+
+      it "requires raises an error when requiring invalid setting" do
+        expect {
+          class TestSettings < Figaro::Settings
+            requires :foo,
+              :int
+          end
+        }.to raise_error(Figaro::Settings::DataTypes::InvalidKey)
+      end
+    end
+  end
+end