adhearsion 1.2.6 → 2.0.0.alpha1

data/spec/adhearsion/initializer_spec.rb

@@ -1,163 +1,250 @@
 require 'spec_helper'
 
-describe "Adhearsion::Initializer" do
+describe Adhearsion::Initializer do
 
   include InitializerStubs
   # TODO: create a specification for aliases
 
-  before :each do
-    Adhearsion.send(:remove_const, 'AHN_CONFIG') if Adhearsion.const_defined? 'AHN_CONFIG'
-    Adhearsion::AHN_CONFIG = Adhearsion::Configuration.new
-  end
+  let(:path) { "#{Dir.pwd}/" }
 
-  after :each do
-    Adhearsion::Events.reinitialize_theatre!
-  end
+  describe "#start" do
+    before do
+      Adhearsion::Logging.reset
+      flexmock(Adhearsion::Initializer::Logging).should_receive(:start).once.and_return('')
+      flexmock(::Logging::Appenders::File).should_receive(:assert_valid_logfile).and_return(true)
+      flexmock(::Logging::Appenders).should_receive(:file).and_return(nil)
+      Adhearsion.config = nil
+    end
 
-  it "initialization will start with only a path given" do
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      Adhearsion::Initializer.start path
+    after do
+      Adhearsion::Events.reinitialize_queue!
     end
-  end
 
-  it "should create a pid file in the app's path when given 'true' as the pid_file hash key argument" do
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-       flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
-       ahn = Adhearsion::Initializer.start path, :pid_file => true
-       ahn.pid_file[0, path.length].should == path
+    after :all do
+      Adhearsion::Logging.reset
+      Adhearsion::Initializer::Logging.start
+      Adhearsion::Logging.silence!
     end
-  end
 
-  it "should NOT create a pid file in the app's path when given 'false' as the pid_file hash key argument" do
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      ahn = Adhearsion::Initializer.start path, :pid_file => false
-      ahn.pid_file.should be nil
+    it "initialization will start with no options" do
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+        Adhearsion::Initializer.start
+      end
     end
-  end
 
-  it "should create a pid file in the app's path by default when daemonizing" do
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      flexmock(File).should_receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w', Proc)
-      ahn = Adhearsion::Initializer.start path, :mode => :daemon
-      ahn.pid_file[0, path.size].should == path
+    it "should create a pid file in the app's path when given 'true' as the pid_file hash key argument" do
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+         flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+         ahn = Adhearsion::Initializer.start :pid_file => true
+         ahn.pid_file[0, path.length].should == path
+      end
     end
-  end
 
-  it "should NOT create a pid file in the app's path when daemonizing and :pid_file is given as false" do
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      ahn = Adhearsion::Initializer.start path, :daemon => true, :pid_file => false
-      ahn.pid_file.should be nil
+    it "should NOT create a pid file in the app's path when given 'false' as the pid_file hash key argument" do
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+        ahn = Adhearsion::Initializer.start :pid_file => false
+        ahn.pid_file.should be nil
+      end
     end
-  end
 
-  it "should execute gem when .ahnrc contains gem names" do
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      ahn_rc = {
-        "gems" => {
-          "activerecord" => { "version" => ">= 1.2.0" },
-          "twitter" => nil
-        },
-        # Paths are unnecessary except to make the other part of bootstrap_rc happy.
-        "paths"=>{"dialplan"=>"dialplan.rb", "init"=>"config/startup.rb", "events"=>"events.rb",
-            "models"=> "models/*.rb"}
-      }
-      ahn = Adhearsion::Initializer.new path
-      flexmock(Adhearsion::Initializer).should_receive(:get_rules_from).once.and_return ahn_rc
-      flexmock(ahn).should_receive(:gem).once.with("activerecord", ">= 1.2.0")
-      flexmock(ahn).should_receive(:gem).once.with("twitter")
-      ahn.start
+    it "should create a pid file in the app's path by default when daemonizing" do
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+        flexmock(File).should_receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w', Proc)
+        ahn = Adhearsion::Initializer.start :mode => :daemon
+        ahn.pid_file[0, path.size].should == path
+      end
     end
-  end
 
-  it "should require() the lib when .ahnrc contains a require section with one name" do
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      ahn_rc = {
-        "gems" => {
-          "twitter" => {
-            "require" => "sometwitterstuffs"
-          }
-        },
-        # Paths are unnecessary except to make the other part of bootstrap_rc happy.
-        "paths"=>{"dialplan"=>"dialplan.rb", "init"=>"config/startup.rb", "events"=>"events.rb",
-            "models"=>"models/*.rb"}
-      }
-      ahn = Adhearsion::Initializer.new path
-      flexmock(Adhearsion::Initializer).should_receive(:get_rules_from).once.and_return ahn_rc
-      flexstub(ahn).should_receive(:gem).once.with("twitter")
-      flexmock(ahn).should_receive(:require).once.with("sometwitterstuffs")
-      flexmock(ahn).should_receive(:require).at_least.once.with(String)
-      ahn.start
+    it "should NOT create a pid file in the app's path when daemonizing and :pid_file is given as false" do
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+        ahn = Adhearsion::Initializer.start :daemon => true, :pid_file => false
+        ahn.pid_file.should be nil
+      end
     end
-  end
 
-  it "should create a designated pid file when supplied a String path as :pid_file" do
-    random_file = "/tmp/AHN_TEST_#{rand 100000}.pid"
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      ahn = Adhearsion::Initializer.start path, :pid_file => random_file
-      ahn.pid_file.should be(random_file)
-      File.exists?(random_file).should be true
-      File.delete random_file
+    it "should create a designated pid file when supplied a String path as :pid_file" do
+      random_file = "/tmp/AHN_TEST_#{rand 100000}.pid"
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+        ahn = Adhearsion::Initializer.start :pid_file => random_file
+        ahn.pid_file.should == random_file
+        File.exists?(random_file).should be true
+        File.delete random_file
+      end
+    end
+
+    it "should resolve the log file path to daemonize" do
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+         flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+         ahn = Adhearsion::Initializer.start :pid_file => true
+         ahn.resolve_log_file_path.should == path + Adhearsion.config.platform.logging.outputters[0]
+      end
+    end
+
+    it "should resolve the log file path to daemonize when outputters is an Array" do
+      Adhearsion.config.platform.logging.outputters = ["log/my_application.log", "log/adhearsion.log"]
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+         flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+         ahn = Adhearsion::Initializer.start :pid_file => true
+         ahn.resolve_log_file_path.should == path + Adhearsion.config.platform.logging.outputters[0]
+      end
+    end
+
+    it "should return a valid appenders array" do
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+         flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+         ahn = Adhearsion::Initializer.start :pid_file => true
+         appenders = ahn.init_get_logging_appenders
+         appenders.should have(2).items
+         appenders[1].should be_instance_of Logging::Appenders::Stdout
+      end
+    end
+
+    it "should initialize properly the log paths" do
+      ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
+        flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+        Adhearsion::Initializer.start :pid_file => true
+      end
+      flexmock(Dir).should_receive(:mkdir).with("log/")
+      ahn.initialize_log_paths
+    end
+
+    it "should initialize properly the log paths when outputters is an array" do
+      Adhearsion.config.platform.logging.outputters = ["log/my_application.log", "log/test/adhearsion.log"]
+      ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
+        flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+        Adhearsion::Initializer.start :pid_file => true
+      end
+      flexmock(Dir).should_receive(:mkdir).with("log/").twice
+      flexmock(Dir).should_receive(:mkdir).with("log/test/").once
+      ahn.initialize_log_paths
     end
   end
 
-  it "should initialze events properly" do
-    require 'theatre'
-    events_rb = Tempfile.new "events.rb"
-    initializer = Adhearsion::Initializer.new("/does/not/matter")
-    flexmock(Adhearsion::AHN_CONFIG).should_receive(:files_from_setting).at_least.once.with("paths", "events").
-        and_return([events_rb.path])
-    flexmock(Adhearsion::Events.framework_theatre).should_receive(:load_events_file).once.with events_rb.path
-    flexmock(Adhearsion::Events.framework_theatre).should_receive(:start!).once
-
-    initializer.send :init_events_subsystem
-    initializer.send :init_events_file
+  describe "Initializing logger" do
+    before do
+      Adhearsion::Logging.reset
+      flexmock(::Logging::Appenders::File).should_receive(:assert_valid_logfile).and_return(true)
+      flexmock(::Logging::Appenders).should_receive(:file).and_return(nil)
+      Adhearsion.config = nil
+    end
+
+    after :all do
+      Adhearsion::Logging.reset
+      Adhearsion::Initializer::Logging.start
+      Adhearsion::Logging.silence!
+      Adhearsion::Events.reinitialize_queue!
+    end
+
+    it "should start logging with valid parameters" do
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+        flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+        flexmock(Adhearsion::Initializer::Logging).should_receive(:start).once.with(Array, :info, nil).and_return('')
+        Adhearsion::Initializer.start :pid_file => true
+      end
+    end
   end
 
-  private
-    def path
-      '/any/ole/path'
+  describe "#load_lib_folder" do
+    before do
+      Adhearsion.ahn_root = path
+    end
+
+    it "should load the contents of lib directory" do
+      flexmock(Dir).should_receive(:chdir).with(File.join(path, "lib"), Proc).and_return []
+      Adhearsion::Initializer.new.load_lib_folder
+    end
+
+    it "should return false if folder does not exist" do
+      Adhearsion.config.platform.lib = "my_random_lib_directory"
+      Adhearsion::Initializer.new.load_lib_folder.should == false
+    end
+
+    it "should return false and not load any file if config folder is set to nil" do
+      Adhearsion.config.platform.lib = nil
+      Adhearsion::Initializer.new.load_lib_folder.should == false
     end
+
+    it "should load the contents of the preconfigured directory" do
+      Adhearsion.config.platform.lib = "foo"
+      flexmock(Dir).should_receive(:chdir).with("/any/ole/path/foo", Proc).and_return []
+      Adhearsion::Initializer.new.load_lib_folder
+    end
+  end
 end
 
-describe "AHN_ROOT" do
+describe "Updating RAILS_ENV variable" do
   include InitializerStubs
-  before(:each) do
-    Object.send(:remove_const, :AHN_ROOT) if defined? AHN_ROOT
-  end
 
-  it "initializing will create the AHN_ROOT" do
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      ahn = Adhearsion::Initializer.start path
-      Object.constants.map(&:to_s).include?("AHN_ROOT").should be true
-    end
+  before do
+    Adhearsion::Logging.reset
+    flexmock(Adhearsion::Initializer::Logging).should_receive(:start).once.and_return('')
+    flexmock(::Logging::Appenders::File).should_receive(:assert_valid_logfile).and_return(true)
+    flexmock(::Logging::Appenders).should_receive(:file).and_return(nil)
+    Adhearsion.config = nil
   end
 
-  it "swapping out the base_path for the duration of the block" do
-    original_base_path = '.'
-    temporary_base     = '/foo'
+  after do
+    ENV['RAILS_ENV'] = nil
+  end
 
-    path = Adhearsion::PathString.new(original_base_path)
-    path.should == original_base_path
+  describe "when neither RAILS_ENV nor AHN_ENV are set" do
+    [:development, :production, :staging, :test].each do |env|
+      it "should set the RAILS_ENV to #{env.to_s} when Adhearsion environment is set to #{env.to_s}" do
+        ahn = nil
+        stub_behavior_for_initializer_with_no_path_changing_behavior do
+          Adhearsion.config.platform.environment = env
+          ahn = Adhearsion::Initializer.start
+        end
+        ahn.update_rails_env_var
+        ENV['RAILS_ENV'].should == env.to_s
+      end
+    end
 
-    path.using_base_path temporary_base do
-      path.should == temporary_base
+    context "when RAILS_ENV is set" do
+
+      after do
+        ENV['RAILS_ENV'] = nil
+        ENV['AHN_ENV'] = nil
+      end
+
+      it "should preserve the RAILS_ENV value if AHN_ENV is unset" do
+        ENV['RAILS_ENV'] = "test"
+        ahn = nil
+        stub_behavior_for_initializer_with_no_path_changing_behavior do
+          ahn = Adhearsion::Initializer.start
+        end
+        ahn.update_rails_env_var
+        ENV['RAILS_ENV'].should == "test"
+      end
+
+      it "should update the RAILS_ENV value with the AHN_ENV value" do
+        ENV['RAILS_ENV'] = "test"
+        ENV['AHN_ENV'] = "production"
+        ahn = nil
+        stub_behavior_for_initializer_with_no_path_changing_behavior do
+          ahn = Adhearsion::Initializer.start
+        end
+        ahn.update_rails_env_var
+        ENV['RAILS_ENV'].should == "production"
+      end
     end
-    path.should == original_base_path
-  end
 
-  it "creating the AHN_ROOT will set defaults" do
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      flexstub(Adhearsion::Initializer).new_instances.should_receive(:load).and_return
-      ahn = Adhearsion::Initializer.start path
-      full_path = File.expand_path(path)
-      AHN_ROOT.to_s.should == full_path
-      AHN_ROOT.component_path.should == File.join(full_path, "components")
-      AHN_ROOT.log_path.should == File.join(full_path, "logs")
-      AHN_ROOT.dialplan_path.should == full_path
+    context "when RAILS_ENV is unset and AHN_ENV is set" do
+      after do
+        ENV['RAILS_ENV'] = nil
+        ENV['AHN_ENV'] = nil
+      end
+
+      it "should define the RAILS_ENV value with the AHN_ENV value" do
+        ENV['AHN_ENV'] = "production"
+        ahn = nil
+        stub_behavior_for_initializer_with_no_path_changing_behavior do
+          ahn = Adhearsion::Initializer.start
+        end
+        ahn.update_rails_env_var
+        ENV['RAILS_ENV'].should == "production"
+      end
     end
   end
-  private
-    def path
-      '/any/ole/path'
-    end
+
 end

data/spec/adhearsion/logging_spec.rb

@@ -1,50 +1,47 @@
 require 'spec_helper'
 
-describe 'The ahn_log command' do
+Foo       = Class.new
+Foo::Bar  = Class.new
 
-  it 'should add the ahn_log method to the global namespace' do
-    ahn_log.should be Adhearsion::Logging::DefaultAdhearsionLogger
-  end
+describe Adhearsion::Logging do
 
-  it "should log to the standard Adhearsion logger when given arguments" do
-    message = "o hai. ur home erly."
-    flexmock(Log4r::Logger['ahn']).should_receive(:info).once.with(message)
-    ahn_log message
+  before do
+    defined?(Logging) and Logging.reset
+    Adhearsion::Initializer::Logging.start
+    Adhearsion::Logging.silence!
   end
 
-  it 'should create a new logger when given method_missing' do
-    ahn_log.micromenus 'danger will robinson!'
-    Log4r::Logger['micromenus'].should_not be nil
+  it 'should be added to any Object' do
+    Foo.should respond_to(:logger)
   end
 
-  it 'should define a singleton method on itself of any name found by method_missing' do
-    ahn_log.agi "SOMETHING IMPORTANT HAPPENED"
-    Adhearsion::Logging::AdhearsionLogger.instance_methods.map{|m| m.to_sym}.should include :agi
+  it 'should created the predefined set of log levels' do
+    ::Logging::LEVELS.length.should eql(Adhearsion::Logging::LOG_LEVELS.length)
   end
 
-  it "dynamically generated loggers should support logging with blocks" do
-    # I had to comment out this it because Flexmock makes it impossible to#
-    # set up an expectation for receiving blocks.
+  it 'should be added to any Object instance' do
+    Foo.new.should respond_to(:logger)
+  end
 
-    # proc_to_log = lambda { [1,2,3].reverse.join }
-    #
-    # info_catcher = flexmock "A logger that responds to info()"
-    # info_catcher.should_receive(:info).once.with(&proc_to_log)
-    #
-    # flexmock(Log4r::Logger).should_receive(:[]).with('log4r')
-    # flexmock(Log4r::Logger).should_receive(:[]).once.with('ami').and_return info_catcher
-    #
-    # ahn_log.ami(&proc_to_log)
+  it "should log to the Object logger when given arguments" do
+    message = "o hai. ur home erly."
+    foo = Foo.new
+    flexmock(::Logging.logger[Foo]).should_receive(:info).once.with(message)
+    foo.logger.info message
   end
 
-  it 'new loggers created by method_missing() should be instances of AdhearsionLogger' do
-    ahn_log.qwerty.should be_a_kind_of Adhearsion::Logging::AdhearsionLogger
+  it "should log to the Object logger when given arguments (II)" do
+    message = "o hai. ur home erly."
+    bar = Foo::Bar.new
+    flexmock(::Logging.logger[Foo::Bar]).should_receive(:info).once.with(message)
+    bar.logger.info message
   end
 
-  it "handles crazy logger names" do
-    ahn_log.send :'locals@DEMO_call&', "hey"
-    Log4r::Logger['locals@DEMO_call&'].should_not be nil
-    ahn_log.send(:'localsdemo_call').should == Log4r::Logger['locals@DEMO_call&']
+  it 'should create a new logger when given method_missing' do
+    FooBar = Class.new Foo
+    ::Logging::Repository.instance[FooBar].should be_nil
+    FooBar.logger.info "o hai. ur home erly."
+    ::Logging::Repository.instance[FooBar].should_not be_nil
   end
 
 end
@@ -52,7 +49,12 @@ end
 # Essential for running the tests
 describe 'Logger level changing' do
 
-  after :each do
+  before do
+    defined?(Logging) and Logging.reset
+    Adhearsion::Initializer::Logging.start
+  end
+
+  after do
     Adhearsion::Logging.logging_level = :info
   end
 
@@ -61,32 +63,41 @@ describe 'Logger level changing' do
   end
 
   it 'changing the logging level should affect all loggers' do
-    loggers = [ahn_log.one, ahn_log.two, ahn_log.three]
-    loggers.map(&:level).should_not == [Log4r::WARN] * 3
+    loggers = [::Foo.logger, ::Foo::Bar.logger]
+    loggers.map(&:level).should_not == [::Logging::LEVELS["debug"]] * 2
+    loggers.map(&:level).should == [::Logging::LEVELS["info"]] * 2
     Adhearsion::Logging.logging_level = :warn
-    loggers.map(&:level).should == [Log4r::WARN] * 3
+    loggers.map(&:level).should == [::Logging::LEVELS["warn"]] * 2
+  end
+
+  it 'changing the logging level, using level=, should affect all loggers' do
+    loggers = [Foo.logger, ::Foo::Bar.logger]
+    loggers.map(&:level).should_not == [::Logging::LEVELS["debug"]] * 2
+    loggers.map(&:level).should == [::Logging::LEVELS["info"]] * 2
+    Adhearsion::Logging.level = :warn
+    loggers.map(&:level).should == [::Logging::LEVELS["warn"]] * 2
+  end
+
+  it 'should change all the Logger instance level' do
+    Foo.logger.level.should be Adhearsion::Logging::INFO
+    Adhearsion::Logging.logging_level = :fatal
+    Foo.logger.level.should be Adhearsion::Logging::FATAL
   end
 
-  it 'a new logger should have the global Adhearsion logging level' do
-    ahn_log.foo.level.should be Log4r::INFO
+  it 'a new logger should have the :root logging level' do
+    Foo.logger.level.should be Adhearsion::Logging::INFO
     Adhearsion::Logging.logging_level = :fatal
-    ahn_log.brand_new.level.should be Log4r::FATAL
+    Foo::Bar.logger.level.should be Adhearsion::Logging::FATAL
   end
 
   it '#silence!() should change the level to be FATAL' do
-    flexmock(Adhearsion::Logging::DefaultAdhearsionLogger).should_receive(:level=).once.with(Log4r::FATAL)
     Adhearsion::Logging.silence!
-    # Verify and close manually here because the after-test hook breaks the expectation
-    flexmock_verify
-    flexmock_close
+    Adhearsion::Logging.logging_level.should be(Adhearsion::Logging::FATAL)
   end
 
   it '#unsilence!() should change the level to be INFO' do
-    flexmock(Adhearsion::Logging::DefaultAdhearsionLogger).should_receive(:level=).once.with(Log4r::INFO)
     Adhearsion::Logging.unsilence!
-    # Verify and close manually here because the after-test hook breaks the expectation
-    flexmock_verify
-    flexmock_close
+    Adhearsion::Logging.logging_level.should be(Adhearsion::Logging::INFO)
   end
 
 end