objectified_environments 1.0.0

data/spec/objectified_environments/system/rails_integration_spec.rb

@@ -0,0 +1,111 @@
+require File.join(File.dirname(__FILE__), '..', 'helpers', 'rails_helper')
+require File.join(File.dirname(__FILE__), '..', 'helpers', 'command_helpers')
+
+describe "ObjectifiedEnvironments Rails integration" do
+  include ObjectifiedEnvironments::Specs::Helpers::CommandHelpers
+
+  before :each do
+    @gem_root = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..'))
+  end
+
+  def lib_objenv_dir
+    File.join('config', 'lib', 'objenv')
+  end
+
+  def splat_file(path, contents)
+    FileUtils.mkdir_p(File.dirname(path))
+    File.open(path, 'w') { |f| f << contents }
+  end
+
+  def append_file(path, contents)
+    File.open(path, 'a') { |f| f << contents }
+  end
+
+  def add_gem_to_gemfile
+    append_file('Gemfile', "gem 'objectified_environments', :path => '#{@gem_root}'\n")
+  end
+
+  def new_rails_helper(options = { })
+    tmp_dir = File.join(@gem_root, 'tmp')
+    ObjectifiedEnvironments::Specs::Helpers::RailsHelper.new(tmp_dir, options)
+  end
+
+  it "should instantiate and use the development environment properly when RAILS_ENV=development" do
+    new_rails_helper.run! do |rh|
+      add_gem_to_gemfile
+      splat_file(File.join(lib_objenv_dir, 'development.rb'), %{class Objenv::Development; def spec_output; "this_is_dev_env_1"; end; end})
+
+      old_rails_env = ENV['RAILS_ENV']
+      begin
+        ENV['RAILS_ENV'] = 'development'
+        result = rh.run_as_script!("puts Rails.objenv.spec_output", :script_name => "check_env_spec_script")
+        result.strip.should match(/^this_is_dev_env_1$/mi)
+      ensure
+        ENV['RAILS_ENV'] = old_rails_env
+      end
+    end
+  end
+
+  it "should be available during initializer and configuration time" do
+    new_rails_helper.run! do |rh|
+      add_gem_to_gemfile
+      splat_file(File.join(lib_objenv_dir, 'test.rb'), %{class Objenv::Test; def spec_output; "this_is_test_env_2"; end; end})
+      splat_file(File.join(rh.root, 'config', 'initializers', 'spec_initializer.rb'), "puts 'initializer: ' + Rails.objenv.spec_output")
+
+      test_env_file = File.join(rh.root, "config", "environments", "test.rb")
+      test_env = "puts 'before env: ' + Rails.objenv.spec_output\n" + File.read(test_env_file) + "\nputs 'after env: ' + Rails.objenv.spec_output\n"
+      File.open(test_env_file, 'w') { |f| f << test_env }
+
+      result = rh.run_as_script!("puts 'done'", :script_name => "check_initializer_spec_script")
+      result.should match(/^initializer: this_is_test_env_2$/mi)
+      result.should match(/^before env: this_is_test_env_2$/mi)
+      result.should match(/^after env: this_is_test_env_2$/mi)
+      result.should match(/^done$/mi)
+    end
+  end
+
+  context "generator" do
+    it "should create all necessary classes, including one for whatever RAILS_ENV is set" do
+      new_rails_helper(:rails_env => 'bar').run! do |rh|
+        add_gem_to_gemfile
+        rh.run_generator("objectified_environments")
+
+        script = <<-EOS
+%w{Bar Development Test Production LocalEnvironment ProductionEnvironment Environment}.each do |class_name|
+  klass = eval("Objenv::" + class_name) rescue nil
+  superclasses = [ ]
+
+  current_class = klass
+  while true
+    break unless current_class
+    current_class = current_class.superclass
+    break if current_class == Object
+    superclasses.unshift(current_class)
+  end
+
+  $stdout << class_name
+  $stdout << ": "
+
+  unless klass
+    $stdout << "NOT PRESENT"
+  end
+
+  superclasses = superclasses.map { |sc| sc.name }.sort
+  $stdout.puts superclasses.join(" ")
+  $stdout.flush
+end
+EOS
+
+        result = rh.run_as_script!(script, :script_name => "check_generator_spec_script")
+
+        result.should match(/^Environment: ObjectifiedEnvironments::Base$/mi)
+        result.should match(/^LocalEnvironment: ObjectifiedEnvironments::Base Objenv::Environment$/mi)
+        result.should match(/^Development: ObjectifiedEnvironments::Base Objenv::Environment Objenv::LocalEnvironment$/mi)
+        result.should match(/^Test: ObjectifiedEnvironments::Base Objenv::Environment Objenv::LocalEnvironment$/mi)
+        result.should match(/^ProductionEnvironment: ObjectifiedEnvironments::Base Objenv::Environment$/mi)
+        result.should match(/^Production: ObjectifiedEnvironments::Base Objenv::Environment Objenv::ProductionEnvironment$/mi)
+        result.should match(/^Bar: ObjectifiedEnvironments::Base Objenv::Environment$/mi)
+      end
+    end
+  end
+end

data/spec/objectified_environments/unit/base_spec.rb

@@ -0,0 +1,34 @@
+require 'objectified_environments/base'
+
+describe ObjectifiedEnvironments::Base do
+  it "should hold environment data" do
+    b = ObjectifiedEnvironments::Base.new(:rails_env => 'foo', :user_name => 'bar', :host_name => 'baz')
+    b.send(:rails_env).should == 'foo'
+    b.send(:user_name).should == 'bar'
+    b.send(:host_name).should == 'baz'
+  end
+
+  it "should not require any data but rails_env" do
+    b = ObjectifiedEnvironments::Base.new(:rails_env => 'foo')
+    b.send(:rails_env).should == 'foo'
+    b.send(:user_name).should == nil
+    b.send(:host_name).should == nil
+  end
+
+  it "should not expose this data by default" do
+    lambda { b.rails_env }.should raise_error
+    lambda { b.user_name }.should raise_error
+    lambda { b.host_name }.should raise_error
+  end
+
+  it "should implement #must_implement as something that raises" do
+    b = ObjectifiedEnvironments::Base.new(:rails_env => 'foo')
+    class << b
+      def foo
+        must_implement
+      end
+    end
+
+    lambda { b.foo }.should raise_error
+  end
+end

data/spec/objectified_environments/unit/data_provider_spec.rb

@@ -0,0 +1,155 @@
+require 'objectified_environments/data_provider'
+
+describe ObjectifiedEnvironments::DataProvider do
+  it "should be instantiable with no arguments" do
+    lambda { subject.class.new }.should_not raise_error
+  end
+
+  describe "Rails.env" do
+    it "should expose correctly" do
+      expect(Rails).to receive(:env).once { 'bongo' }
+      subject.rails_env.should == 'bongo'
+    end
+
+    it "should raise an error if there's none" do
+      expect(Rails).to receive(:env).once { nil }
+      lambda { subject.rails_env }.should raise_error
+    end
+  end
+
+  describe "user_name" do
+    before(:each) { @saved_env = { }; ENV.each { |k,v| @saved_env[k] = v } }
+    after(:each) { @saved_env.each { |k,v| ENV[k] = v } }
+
+    context "Etc.getlogin" do
+      require 'etc'
+
+      it "should return this first" do
+        expect(Etc).to receive(:getlogin).once { 'marph' }
+        subject.user_name.should == 'marph'
+      end
+
+      it "should skip this if blank" do
+        expect(Etc).to receive(:getlogin).once { '  ' }
+        ENV['USER'] = 'foo'
+
+        subject.user_name.should == 'foo'
+      end
+
+      it "should skip this if nil" do
+        expect(Etc).to receive(:getlogin).once { nil }
+        ENV['USER'] = 'bar'
+
+        subject.user_name.should == 'bar'
+      end
+    end
+
+    context "environment variables" do
+      def check_env(user, logname, username, expected_result)
+        ENV['USER'] = user
+        ENV['LOGNAME'] = logname
+        ENV['USERNAME'] = username
+
+        allow(Etc).to receive(:getlogin) { nil }
+
+        dp = subject.class.new
+        dp.user_name.should == expected_result
+      end
+
+      it "should check them in the right order" do
+        check_env('foo', 'bar', 'baz', 'foo')
+        check_env('   ', 'bar', 'baz', 'bar')
+        check_env(nil, 'bar', 'baz', 'bar')
+
+        check_env(nil, '   ', 'baz', 'baz')
+        check_env(nil, nil, 'baz', 'baz')
+      end
+
+      it "should return nil if nothing is available" do
+        check_env(nil, nil, nil, nil)
+      end
+    end
+  end
+
+  describe "host_name" do
+    require 'socket'
+
+    def set_hostname_from_hostname_command(dp, x)
+      class << dp
+        def specified_host_name=(x)
+          @_specified_host_name = x
+        end
+
+        def host_name_from_hostname_command
+          @_specified_host_name
+        end
+      end
+
+      dp.specified_host_name = x
+    end
+
+    it "should return it from the hostname command by default" do
+      set_hostname_from_hostname_command(subject, 'baz')
+      subject.host_name.should == 'baz'
+    end
+
+    it "should strip whitespace from the hostname command and normalize it" do
+      set_hostname_from_hostname_command(subject, "\n    Ba-Z\n  \n")
+      subject.host_name.should == 'ba_z'
+    end
+
+    it "should skip the hostname command if blank" do
+      set_hostname_from_hostname_command(subject, '   ')
+      expect(Socket).to receive(:gethostname).once { 'foo' }
+      subject.host_name.should == 'foo'
+    end
+
+    it "should skip the hostname command if nil" do
+      set_hostname_from_hostname_command(subject, nil)
+      expect(Socket).to receive(:gethostname).once { 'foo' }
+      subject.host_name.should == 'foo'
+    end
+
+    it "should skip the hostname command if garbage" do
+      set_hostname_from_hostname_command(subject, '$#@*($')
+      expect(Socket).to receive(:gethostname).once { 'foo' }
+      subject.host_name.should == 'foo'
+    end
+
+    it "should skip the hostname command if not a Ruby identifier" do
+      set_hostname_from_hostname_command(subject, '0bar')
+      expect(Socket).to receive(:gethostname).once { 'foo' }
+      subject.host_name.should == 'foo'
+    end
+
+    it "should skip Socket.gethostname if blank" do
+      set_hostname_from_hostname_command(subject, nil)
+      expect(Socket).to receive(:gethostname).once { '   ' }
+      subject.host_name.should be_nil
+    end
+
+    it "should skip Socket.gethostname if nil" do
+      set_hostname_from_hostname_command(subject, nil)
+      expect(Socket).to receive(:gethostname).once { nil }
+      subject.host_name.should be_nil
+    end
+
+    it "should skip Socket.gethostname if garbage" do
+      set_hostname_from_hostname_command(subject, nil)
+      expect(Socket).to receive(:gethostname).once { "$*(@$" }
+      subject.host_name.should be_nil
+    end
+
+    it "should skip Socket.gethostname if not a Ruby identifir" do
+      set_hostname_from_hostname_command(subject, nil)
+      expect(Socket).to receive(:gethostname).once { "0foo" }
+      subject.host_name.should be_nil
+    end
+
+    it "should skip Socket.gethostname if it raises" do
+      set_hostname_from_hostname_command(subject, nil)
+      expect(Socket).to receive(:gethostname).once { raise "kaboom!" }
+      subject.host_name.should be_nil
+    end
+  end
+end

data/spec/objectified_environments/unit/environment_builder_spec.rb

@@ -0,0 +1,232 @@
+require 'objectified_environments/environment_builder'
+
+describe ObjectifiedEnvironments::EnvironmentBuilder do
+  class FakeDataProvider
+    def initialize(rails_env, user_name, host_name)
+      @rails_env = rails_env
+      @user_name = user_name
+      @host_name = host_name
+    end
+
+    attr_reader :rails_env, :user_name, :host_name
+  end
+
+  def new_with(*args)
+    fake_data_provider = FakeDataProvider.new(*args)
+    ObjectifiedEnvironments::EnvironmentBuilder.new(fake_data_provider)
+  end
+
+  describe "construction" do
+    it "should require a non-blank, non-nil Rails.env" do
+      lambda { new_with('  ', nil, nil) }.should raise_error
+      lambda { new_with(nil, nil, nil) }.should raise_error
+    end
+
+    it "should work with just a Rails.env" do
+      lambda { new_with('foo', nil, nil) }.should_not raise_error
+    end
+  end
+
+  describe "#environment" do
+    def define_classes_for(name_or_names, options = { }, &block)
+      names = Array(name_or_names)
+
+      names.each do |name|
+        n = name
+        root = Object
+
+        while n =~ /^([^:]+)::(.*)$/
+          module_name = $1; n = $2
+          is_defined = eval("defined?(#{module_name})")
+          unless is_defined
+            root.module_eval "module #{module_name}; end"
+          end
+          root = eval("#{root.name}::#{module_name}")
+        end
+
+        root.module_eval "class #{name}; end"
+      end
+
+      block.call
+
+      names.each do |name|
+        root = Object
+        if name =~ /^(.*)::([^:]+)$/
+          root = $1.constantize
+          name = $2
+        end
+
+        root.send(:remove_const, name.to_sym)
+      end
+    end
+
+    context "simple Rails.env classes" do
+      it "should create an environment just named after Rails.env if defined" do
+        define_classes_for('Objenv::Foo') do
+          env = new_with('foo', 'bar', 'baz').environment
+          env.class.should == Objenv::Foo
+        end
+      end
+
+      it "should create an environment just named after Rails.env even if user and host are missing" do
+        define_classes_for('Objenv::Foo') do
+          env = new_with('foo', nil, nil).environment
+          env.class.should == Objenv::Foo
+        end
+      end
+
+      it "should fail with a nice error message if the class is not defined, showing what we looked for" do
+        define_classes_for('Objenv::Marph') do
+          eb = new_with('foo', 'bar', 'baz')
+
+          exception = nil
+          begin
+            eb.environment
+          rescue ObjectifiedEnvironments::EnvironmentMissingError => eme
+            exception = eme
+          end
+
+          exception.should_not be_nil
+
+          exception.message.should =~ /foo/
+          exception.message.should =~ /bar/
+          exception.message.should =~ /baz/
+
+          exception.message.should =~ /Objenv::Foo/
+          exception.message.should =~ /Objenv::User::BarFoo/
+          exception.message.should =~ /Objenv::Host::BazFoo/
+          exception.message.should =~ /Objenv::UserHost::BarBazFoo/
+        end
+      end
+
+      it "should fail with a nice error message if the class blows up upon instantiation" do
+        define_classes_for('Objenv::Foo') do
+          class Objenv::Foo
+            def initialize(*args)
+              raise "kaboomba"
+            end
+          end
+
+          eb = new_with('foo', 'bar', 'baz')
+
+          exception = nil
+          begin
+            eb.environment
+          rescue ObjectifiedEnvironments::UnableToInstantiateEnvironmentError => utiee
+            exception = utiee
+          end
+
+          exception.should_not be_nil
+
+          exception.message.should =~ /Objenv::Foo/
+          exception.message.should =~ /kaboomba/
+        end
+      end
+
+      it "should fail with a nice error message if the class's constructor takes too many parameters" do
+        define_classes_for('Objenv::Foo') do
+          class Objenv::Foo
+            def initialize(x, y)
+              # ok
+            end
+          end
+
+          eb = new_with('foo', 'bar', 'baz')
+
+          exception = nil
+          begin
+            eb.environment
+          rescue ObjectifiedEnvironments::UnableToInstantiateEnvironmentError => utiee
+            exception = utiee
+          end
+
+          exception.should_not be_nil
+
+          exception.message.should =~ /Objenv::Foo/
+        end
+      end
+
+      it "should pass in environment information if the class accepts it" do
+        define_classes_for('Objenv::Foo') do
+          class Objenv::Foo
+            def initialize(h)
+              @h = h
+            end
+            attr_reader :h
+          end
+
+          env = new_with('foo', 'bar', 'baz').environment
+          env.class.should == Objenv::Foo
+          env.h[:rails_env].should == 'foo'
+          env.h[:user_name].should == 'bar'
+          env.h[:host_name].should == 'baz'
+        end
+      end
+
+      it "should pass in environment information if the class accepts it with optional arguments" do
+        define_classes_for('Objenv::Foo') do
+          class Objenv::Foo
+            def initialize(h, x = nil, y = nil)
+              @h = h
+            end
+            attr_reader :h
+          end
+
+          env = new_with('foo', 'bar', 'baz').environment
+          env.class.should == Objenv::Foo
+          env.h[:rails_env].should == 'foo'
+          env.h[:user_name].should == 'bar'
+          env.h[:host_name].should == 'baz'
+        end
+      end
+    end
+
+    context "with a username" do
+      it "should prefer a username-specified class" do
+        define_classes_for([ 'Objenv::User::BarFoo', 'Objenv::Foo' ]) do
+          env = new_with('foo', 'bar', 'baz').environment
+          env.class.should == Objenv::User::BarFoo
+        end
+      end
+
+      it "should not require a Rails-env-only class" do
+        define_classes_for([ 'Objenv::User::BarFoo' ]) do
+          env = new_with('foo', 'bar', 'baz').environment
+          env.class.should == Objenv::User::BarFoo
+        end
+      end
+    end
+
+    context "with a hostname" do
+      it "should prefer a hostname-specified class" do
+        define_classes_for([ 'Objenv::Host::BazFoo', 'Objenv::Foo' ]) do
+          env = new_with('foo', 'bar', 'baz').environment
+          env.class.should == Objenv::Host::BazFoo
+        end
+      end
+
+      it "should not require a Rails-env-only class" do
+        define_classes_for([ 'Objenv::Host::BazFoo' ]) do
+          env = new_with('foo', 'bar', 'baz').environment
+          env.class.should == Objenv::Host::BazFoo
+        end
+      end
+    end
+
+    context "with a username and hostname both" do
+      it "should prefer a username-and-hostname-specified class" do
+        define_classes_for([ 'Objenv::UserHost::BarBazFoo', 'Objenv::Host::BazFoo', 'Objenv::User::BarFoo', 'Objenv::Foo' ]) do
+          env = new_with('foo', 'bar', 'baz').environment
+          env.class.should == Objenv::UserHost::BarBazFoo
+        end
+      end
+
+      it "should not require any other classes" do
+        define_classes_for([ 'Objenv::UserHost::BarBazFoo' ]) do
+          env = new_with('foo', 'bar', 'baz').environment
+          env.class.should == Objenv::UserHost::BarBazFoo
+        end
+      end
+    end
+  end
+end

data/spec/objectified_environments/unit/errors_spec.rb

@@ -0,0 +1,17 @@
+require 'objectified_environments/errors'
+
+describe ObjectifiedEnvironments do
+  it "should have the right hierarchy" do
+    ObjectifiedEnvironments::ObjectifiedEnvironmentError.superclass.should == StandardError
+    ObjectifiedEnvironments::EnvironmentMissingError.superclass.should == ObjectifiedEnvironments::ObjectifiedEnvironmentError
+    ObjectifiedEnvironments::UnableToInstantiateEnvironmentError.superclass.should == ObjectifiedEnvironments::ObjectifiedEnvironmentError
+  end
+
+  it "should be able to be created with just a message" do
+    m = "foo"
+
+    lambda { ObjectifiedEnvironments::ObjectifiedEnvironmentError.new(m) }.should_not raise_error
+    lambda { ObjectifiedEnvironments::EnvironmentMissingError.new(m) }.should_not raise_error
+    lambda { ObjectifiedEnvironments::UnableToInstantiateEnvironmentError.new(m) }.should_not raise_error
+  end
+end

data/spec/objectified_environments/unit/version_spec.rb

@@ -0,0 +1,7 @@
+require 'objectified_environments/version'
+
+describe "ObjectifiedEnvironments::VERSION" do
+  it "should return the right version" do
+    ObjectifiedEnvironments::VERSION.should == "1.0.0"
+  end
+end