adhearsion 1.0.1 → 1.0.2

data/lib/adhearsion/component_manager/component_tester.rb

@@ -47,9 +47,7 @@ module ComponentTester
 
   def initialize!
     metadata = component_module.metaclass.send(:instance_variable_get, :@metadata)
-    if metadata && metadata[:initialization_block].kind_of?(Proc)
-      metadata[:initialization_block].call
-    end
+    metadata[:initialization_block].call if metadata && metadata[:initialization_block].kind_of?(Proc)
   end
 
 end

data/lib/adhearsion/component_manager/spec_framework.rb

@@ -1,14 +1,8 @@
 require 'adhearsion/component_manager/component_tester'
 begin
-  require 'spec'
+  require 'rspec'
 rescue LoadError
-  abort 'You do not have the "rspec" gem installed! You must install it to continue.\n\nsudo gem install rspec\n\n'
-end
-
-begin
-  require 'rr'
-rescue LoadError
-  abort 'You do not have the "rr" gem installed! You must install it to continue.\n\nsudo gem install rr\n\n'
+  abort "You do not have the 'rspec' gem installed! You must install it to continue.\n\nsudo gem install rspec\n\n"
 end
 
 module ComponentConfigurationSpecHelper
@@ -18,7 +12,7 @@ module ComponentConfigurationSpecHelper
   end
 end
 
-Spec::Runner.configure do |config|
-  config.mock_with :rr
+RSpec.configure do |config|
+  config.mock_with :rspec
   config.include ComponentConfigurationSpecHelper
 end

data/lib/adhearsion/foundation/object.rb

@@ -0,0 +1,10 @@
+# Monkey patch Object to support the #tap method.
+# This method is present in Ruby 1.8.7 and later.
+if !Object.respond_to?(:tap)
+  class Object
+    def tap
+      yield self
+      self
+    end
+  end
+end

data/lib/adhearsion/version.rb

@@ -2,7 +2,7 @@ module Adhearsion #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1 unless defined? MAJOR
     MINOR = 0 unless defined? MINOR
-    TINY  = 1 unless defined? TINY
+    TINY  = 2 unless defined? TINY
 
     STRING = [MAJOR, MINOR, TINY].join('.') unless defined? STRING
   end

data/spec/ahn_command_spec.rb

@@ -0,0 +1,284 @@
+require 'spec_helper'
+require 'adhearsion/cli'
+
+module AhnCommandSpecHelper
+
+  def simulate_args(*args)
+    ARGV.clear
+    ARGV.concat args
+  end
+
+  def capture_stdout(&block)
+    old = $stdout
+    $stdout = io = StringIO.new
+    yield
+  ensure
+    $stdout = old
+    return io.string
+  end
+
+  def new_tmp_dir(filename=new_guid)
+    File.join Dir.tmpdir, filename
+  end
+
+  def create_component_sandbox
+    new_tmp_dir.tap do |dir|
+      Dir.mkdir dir
+      FileUtils.touch dir + "/.ahnrc"
+      Dir.mkdir dir + "/components"
+    end
+  end
+
+  def execute_ahn_command
+    Adhearsion::CLI::AhnCommand.execute!
+  end
+
+  def executing_ahn_command_should_fail_with(exception)
+    flexmock(Adhearsion::CLI::AhnCommand).should_receive(:fail_and_print_usage).with(exception).once
+    execute_ahn_command
+  end
+
+end
+
+describe 'The Ahn Command helper' do
+
+  include AhnCommandSpecHelper
+
+  it "args are simulated properly" do
+    before = ARGV.clone
+    simulate_args "create", "/tmp/blah"
+    ARGV.should_not be before
+  end
+
+  it "STDOUT should be captured" do
+    capture_stdout do
+      puts "wee"
+    end.should == "wee\n"
+  end
+
+end
+
+describe "A simulated use of the 'ahn' command" do
+
+  include AhnCommandSpecHelper
+
+  it "USAGE is defined" do
+    Adhearsion::CLI::AhnCommand.const_defined?('USAGE').should be true
+  end
+
+  it "arguments to 'create' are executed properly" do
+    some_path = "/path/somewhere"
+    simulate_args "create", some_path
+    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:create).once.with(some_path)
+    capture_stdout { Adhearsion::CLI::AhnCommand.execute! }
+  end
+
+  it "arguments to 'start' are executed properly properly" do
+    some_path = "/tmp/blargh"
+    simulate_args "start", some_path
+    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:start).once.with(some_path, false, nil)
+    Adhearsion::CLI::AhnCommand.execute!
+  end
+
+  it "should execute arguments to 'start' for daemonizing properly" do
+    somewhere = "/tmp/blarghh"
+    simulate_args "start", 'daemon', somewhere
+    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:start).once.with(somewhere, true, nil)
+    Adhearsion::CLI::AhnCommand.execute!
+  end
+
+  it 'parse_arguments should recognize start with daemon properly' do
+    path = '/path/to/somesuch'
+    arguments = ["start", 'daemon', path]
+    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, path, true, nil]
+  end
+
+  it 'should recognize start with daemon and pid file properly' do
+    project_path  = '/second/star/on/the/right'
+    pid_file_path = '/straight/on/til/morning'
+    arguments = ["start", "daemon", project_path, "--pid-file=#{pid_file_path}"]
+    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, project_path, true, pid_file_path]
+  end
+
+  it 'parse_arguments should recognize start without daemon properly' do
+    path = '/path/to/somewhere'
+    arguments = ['start', path]
+    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, path, false, nil]
+  end
+
+  it "if no path is provided, running Ahn command blows up" do
+    flexmock(Adhearsion::CLI::AhnCommand).should_receive(:fail_and_print_usage).once.and_return
+    Adhearsion::CLI::AhnCommand.parse_arguments(['start'])
+  end
+
+  it "printing the version" do
+    capture_stdout do
+      simulate_args 'version'
+      Adhearsion::CLI::AhnCommand.execute!
+    end.should =~ Regexp.new(Regexp.escape(Adhearsion::VERSION::STRING))
+  end
+
+  it "printing the help" do
+    capture_stdout do
+      simulate_args 'help'
+      Adhearsion::CLI::AhnCommand.execute!
+    end.should =~ Regexp.new(Regexp.escape(Adhearsion::CLI::AhnCommand::USAGE))
+  end
+
+  it "reacting to unrecognized commands" do
+    simulate_args "alpha", "beta"
+    flexmock(Adhearsion::CLI::AhnCommand).should_receive(:fail_and_print_usage).once.and_return
+    Adhearsion::CLI::AhnCommand.execute!
+  end
+
+  it "giving a path that doesn't contain a project raises an exception" do
+    simulate_args "start", "/asjdfas/sndjfabsdfbqwb/qnjwejqbwh"
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::PathInvalid
+  end
+
+end
+
+describe "Component-related commands" do
+
+  include AhnCommandSpecHelper
+
+
+  it "should move a folder from the components/disabled/ folder of an app to the components/ directory if it exists" do
+    sandbox      = create_component_sandbox
+    disabled_dir = "#{sandbox}/components/disabled/foobar"
+    enabled_dir  = "#{sandbox}/components/foobar"
+
+    FileUtils.mkdir_p disabled_dir
+    FileUtils.touch disabled_dir + "/foobar.rb"
+
+    flexmock(Dir).should_receive(:pwd).once.and_return disabled_dir
+
+    simulate_args "enable", "component", "foobar"
+    capture_stdout { execute_ahn_command }
+
+    File.directory?(disabled_dir).should_not be true
+    File.exists?(enabled_dir + "/foobar.rb").should be true
+  end
+
+  it "should raise a ComponentError exception if there is no disabled folder" do
+    sandbox = create_component_sandbox
+
+    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
+
+    simulate_args "enable", "component", "foo"
+
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
+  end
+
+  it "should raise an exception if the disabled component exists and there's an enabled component of the same name" do
+    sandbox = create_component_sandbox
+
+    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
+
+    FileUtils.mkdir_p sandbox + "/disabled/lolcats"
+    FileUtils.mkdir_p sandbox + "/lolcats"
+
+    simulate_args "enable", "component", "foo"
+
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
+  end
+
+  it "should raise a PathInvalid error if the current directory does not belong to an Adhearsion app" do
+    flexmock(Dir).should_receive("pwd").and_return "/"
+    simulate_args "enable", "component", "foo"
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::PathInvalid
+  end
+
+  it "should properly create the disabled folder if it doesn't exist when disabling a component" do
+    sandbox = create_component_sandbox
+    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
+
+    FileUtils.mkdir_p sandbox + "/components/rickroller"
+
+    simulate_args 'disable', 'component', 'rickroller'
+    capture_stdout { execute_ahn_command }
+    File.directory?(sandbox + "/components/disabled/rickroller").should be true
+    File.directory?(sandbox + "/components/rickroller").should be false
+  end
+
+  it "should raise an UnknownCommand error when trying to enable a kind of feature which doesn't exist" do
+    simulate_args "enable", "bonobo"
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand
+  end
+
+  it "should raise an UnknownCommand error when trying to disable a kind of feature which doesn't exist" do
+    simulate_args "disable", "thanksgiving_dinner"
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand
+  end
+
+  it "should raise a ComponentError when the component to disable doesn't exist" do
+    sandbox = create_component_sandbox
+    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
+
+    simulate_args "disable", "component", "monkeybars"
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
+  end
+
+  it "should raise an exception when disabling a component and the component's disabled directory already exists" do
+    sandbox = create_component_sandbox
+
+    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
+
+    FileUtils.mkdir_p sandbox + "/disabled/lolcats"
+    FileUtils.mkdir_p sandbox + "/lolcats"
+
+    simulate_args "disable", "component", "foo"
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
+  end
+
+end
+
+describe 'The "create" command' do
+
+  include AhnCommandSpecHelper
+
+  it "creating a project" do
+    the_following_code {
+      tmp_path = new_tmp_dir
+      simulate_args "create", tmp_path
+      RubiGen::Base.default_options.merge! :quiet => true
+      # capture_stdout { Adhearsion::CLI::AhnCommand.execute! }
+      execute_ahn_command
+      File.exists?(File.join(tmp_path, ".ahnrc")).should be true
+    }.should_not raise_error
+  end
+
+  it "should raise an UnknownCommand if running create with no arguments" do
+    simulate_args "create"
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand
+  end
+
+  it "should raise a ComponentError if the name of the component is not a valid Ruby symbol name" do
+    bad_names = ["!))", "37signals", "foo bar", "*"]
+    bad_names.each do |bad_name|
+      simulate_args "create", "component", bad_name
+      executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
+    end
+  end
+
+  it "should raise a ComponentError if the component name already exists in the folder" do
+    sandbox = create_component_sandbox
+    Dir.mkdir sandbox + "/components/blehhh"
+    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
+    simulate_args "create", "component", "blehhh"
+
+    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
+  end
+
+  it "should create a folder with matching .rb file and .yml file when all guards pass" do
+    sandbox = create_component_sandbox
+    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
+
+    simulate_args "create", "component", "ohai"
+    capture_stdout { execute_ahn_command }
+
+    File.exists?(sandbox + "/components/ohai/lib/ohai.rb").should be true
+    File.exists?(sandbox + "/components/ohai/config/ohai.yml").should be true
+  end
+
+end

data/spec/component_manager_spec.rb

@@ -0,0 +1,292 @@
+require 'spec_helper'
+require 'adhearsion/component_manager/component_tester'
+
+module ComponentManagerTestHelper
+
+  def mock_component_config(component_name, yaml)
+    yaml = YAML.load(yaml) if yaml.kind_of?(String)
+    flexmock(@component_manager.lazy_config_loader).should_receive(component_name).and_return yaml
+  end
+
+  def run_component_code(code)
+    @component_manager.load_code(code)
+  end
+
+  def new_object_with_scope(scope)
+    @component_manager.extend_object_with(Object.new, scope)
+  end
+end
+
+describe "Adhearsion's component system" do
+
+  include ComponentManagerTestHelper
+
+  before :each do
+    @component_manager = Adhearsion::Components::ComponentManager.new "/filesystem/access/should/be/mocked/out"
+    Object.send :remove_const, :COMPONENTS if Object.const_defined?(:COMPONENTS)
+    Object.send :const_set, :COMPONENTS, @component_manager.lazy_config_loader
+  end
+
+  it "constants should be available in the main namespace" do
+    constant_name = "FOO_#{rand(10000000000)}"
+    begin
+      run_component_code <<-RUBY
+        #{constant_name} = 123
+      RUBY
+      Module.const_get(constant_name).should be 123
+    ensure
+      Object.send(:remove_const, constant_name) rescue nil
+    end
+  end
+
+  it "defined constants should be available within the methods_for block" do
+    constant_name = "I_HAVE_#{rand(100000000000000)}_GUMMY_BEARS"
+    code = <<-RUBY
+      #{constant_name} = :its_true!
+      methods_for :dialplan do
+        throw #{constant_name}
+      end
+    RUBY
+    the_following_code {
+      run_component_code code
+    }.should throw_symbol :its_true!
+  end
+
+  it "initialization block should be called after the methods_for() blocks"
+
+  it "defined methods should be recognized once defined" do
+    run_component_code <<-RUBY
+      methods_for :events do
+        def foo
+          :inside_foo!
+        end
+      end
+    RUBY
+    container_object = new_object_with_scope :events
+    container_object.foo.should be :inside_foo!
+  end
+
+  it "a method defined in one scope should not be available in another" do
+    code = <<-RUBY
+      methods_for :events do
+        def in_events
+          in_dialplan
+        end
+      end
+      methods_for :dialplan do
+        def in_dialplan
+          in_events
+        end
+      end
+    RUBY
+
+  end
+
+  it "methods defined in separate blocks should be available if they share a scope" do
+    run_component_code <<-RUBY
+      methods_for :dialplan do
+        def get_symbol
+          :i_am_the_best_symbol_in_the_world
+        end
+      end
+      methods_for :dialplan do
+        def throw_best_symbol_in_the_world
+          throw get_symbol
+        end
+      end
+    RUBY
+    obj = new_object_with_scope :dialplan
+    the_following_code {
+      obj.throw_best_symbol_in_the_world
+    }.should throw_symbol :i_am_the_best_symbol_in_the_world
+  end
+
+  it "privately defined methods should remain private" do
+    return_value = "hear! hear! i'm private, indeed!"
+    run_component_code <<-RUBY
+      methods_for :generators do
+        def i_am_public
+          i_am_private.reverse
+        end
+
+        private
+
+        def i_am_private
+          "#{return_value}"
+        end
+      end
+    RUBY
+    object = new_object_with_scope(:generators)
+    object.i_am_public.should == return_value.reverse
+    the_following_code {
+      object.i_am_private
+    }.should raise_error NoMethodError
+  end
+
+  it "load_components should load code with the proper filenames" do
+    components_dir_path = "/path/to/somewhere/components"
+    component_names = %w[fooo barr qazz]
+    component_paths = component_names.map { |name| "#{components_dir_path}/#{name}" }
+
+    flexmock(Dir).should_receive(:glob).once.with(components_dir_path + "/*").
+        and_return(component_paths + ["disabled"])
+    flexstub(File).should_receive(:exists?).and_return true
+    flexstub(File).should_receive(:directory?).and_return true
+
+    manager = Adhearsion::Components::ComponentManager.new(components_dir_path)
+    component_paths.each do |path|
+      flexmock(manager).should_receive(:load_file).once.with "#{path}/lib/#{File.basename(path)}.rb"
+    end
+
+    manager.load_components
+  end
+
+  it "the :global scope" do
+    run_component_code <<-RUBY
+      methods_for :global do
+        def i_should_be_globally_available
+          :found!
+        end
+      end
+    RUBY
+    @component_manager.globalize_global_scope!
+    i_should_be_globally_available.should be :found!
+  end
+
+  it "methods defined in outside of any scope should not be globally available" do
+    run_component_code <<-RUBY
+      def i_should_not_be_globally_available
+        :found!
+      end
+    RUBY
+    the_following_code {
+      i_should_not_be_globally_available
+    }.should raise_error NameError
+  end
+
+  it "should have access to the COMPONENTS constant" do
+    component_name = "am_not_for_kokoa"
+    mock_component_config(component_name, <<-YAML)
+host: localhost
+port: 7007
+array:
+  - 1
+  - 2
+  - 3
+    YAML
+    run_component_code <<-RUBY
+    methods_for(:dialplan) do
+      def host
+        COMPONENTS.#{component_name}["host"]
+      end
+      def port
+        COMPONENTS.#{component_name}["port"]
+      end
+      def array
+        COMPONENTS.#{component_name}["array"]
+      end
+    end
+    RUBY
+    obj = new_object_with_scope :dialplan
+    obj.host.should =="localhost"
+    obj.port.should ==7007
+    obj.array.should ==[1,2,3]
+  end
+
+  it "the delegate method should properly delegate arguments and a block to a specified object" do
+    component_name = "writing_this_at_peets_coffee"
+    mock_component_config(component_name, "{jay: phillips}")
+    run_component_code <<-RUBY
+
+    initialization do
+      obj = Object.new
+      def obj.foo
+        :foo
+      end
+      def obj.bar
+        :bar
+      end
+      COMPONENTS.#{component_name}[:foobar] = obj
+    end
+
+    methods_for :dialplan do
+      delegate :#{component_name}, :to => :COMPONENTS
+    end
+    RUBY
+    obj = new_object_with_scope :dialplan
+    obj.send(component_name)[:foobar].foo.should be :foo
+  end
+
+  it "an initialized component should not have an 'initialize' private method since it's confusing"
+
+  it "should find components in a project properly"
+  it "should run the initialization block" do
+    code = <<-RUBY
+      initialization do
+        throw :got_here!
+      end
+    RUBY
+    the_following_code {
+      run_component_code code
+    }.should throw_symbol :got_here!
+
+  end
+
+  it "should alias the initialization method to initialisation" do
+    code = <<-RUBY
+      initialisation do
+        throw :BRITISH!
+      end
+    RUBY
+    the_following_code {
+      run_component_code code
+    }.should throw_symbol :BRITISH!
+  end
+
+  it "should properly expose any defined constants" do
+    container = run_component_code <<-RUBY
+      TEST_ONE   = 1
+      TEST_TWO   = 2
+      TEST_THREE = 3
+    RUBY
+    container.constants.sort.map{|s| s.to_sym}.should == [:TEST_ONE, :TEST_THREE, :TEST_TWO]
+    container.constants.map do |constant|
+      container.const_get(constant)
+    end.sort.should ==[1,2,3]
+  end
+
+end
+
+describe "ComponentTester" do
+  it "should allow the scope-resolution operator to access a component's constants" do
+    component_name = "my_awesomeness"
+    flexmock(File).should_receive(:read).once.with(/#{component_name}\.rb$/).and_return "AWESOME = :YES!"
+    tester = ComponentTester.new(component_name, "/path/shouldnt/matter")
+    tester::AWESOME.should be :YES!
+  end
+
+  it "should return an executable helper method properly" do
+    component_name = "one_two_three"
+    flexmock(File).should_receive(:read).once.with(/#{component_name}\.rb$/).and_return "def hair() :long end"
+    tester = ComponentTester.new(component_name, "/path/shouldnt/matter")
+    tester.helper_method(:hair).call.should be :long
+  end
+
+  it "should load the configuration for the given helper properly" do
+    component_name = "i_like_configurations"
+    config = {:german => {1 => :eins, 2 => :zwei, 3 => :drei}}
+    flexmock(File).should_receive(:read).once.with(/#{component_name}\.rb$/).and_return ""
+    component_manager = flexmock "ComponentManager"
+    component_manager.should_receive(:configuration_for_component_named).once.with(component_name).and_return config
+    flexmock(Adhearsion::Components::ComponentManager).should_receive(:new).once.and_return component_manager
+    ComponentTester.new(component_name, "/path/shouldnt/matter").config[:german][1].should be :eins
+  end
+
+  it "should execute the initialize block when calling ComponentTester#initialize!()" do
+    component_name = "morrissey"
+    flexmock(File).should_receive(:read).once.with(/#{component_name}\.rb$/).and_return "initialization { $YES_I_WAS_CALLED = TRUE }"
+    ComponentTester.new(component_name, "/path/shouldnt/matter").initialize!
+    $YES_I_WAS_CALLED.should == true
+  end
+
+end