eric-adhearsion 0.7.999 → 0.8.0

data/spec/initializer/test_loading.rb

@@ -1,162 +0,0 @@
-require File.dirname(__FILE__) + "/../test_helper"
-require 'adhearsion/initializer/database'
-require 'adhearsion/initializer/asterisk'
-require 'adhearsion/initializer/rails'
-require 'active_record'
-
-context "The database initializer" do
-  
-  include DatabaseInitializationTestHelper
-  
-  test "starts a connection through ActiveRecord" do
-    connection_options = { :adapter => "sqlite3",
-                           :dbfile => "foo.sqlite3" }
-    flexmock(Adhearsion::Initializer::DatabaseInitializer).should_receive(:require_models).once
-    flexmock(ActiveRecord::Base).should_receive(:establish_connection).with(connection_options)
-    
-    start_database_initializer_with_options connection_options
-  end
-  
-  test "should make any required models available in the main namespace" do
-    bogus_model = tempfile_with_contents sample_user_model
-    flexmock(Adhearsion::Initializer::DatabaseInitializer).should_receive(:all_models).and_return([bogus_model.path])
-    start_database_initializer
-    User.superclass.should.equal ActiveRecord::Base
-  end
-  
-  test 'should enable ActiveRecord concurrency' do
-    bogus_model = tempfile_with_contents sample_user_model
-    flexmock(Adhearsion::Initializer::DatabaseInitializer).should_receive(:all_models).and_return([bogus_model.path])
-    start_database_initializer
-    ActiveRecord::Base.send(:class_variable_get, :@@allow_concurrency).should.be true
-  end
-  
-end
-
-context "The Asterisk initializer" do
-  
-  include AsteriskInitializerTestHelper
-  
-  test "starts the AGI server" do
-    initialize_asterisk_with_defaults
-    flexmock(Adhearsion::VoIP::Asterisk::AGI::Server).new_instances.should_receive(:start).once
-  end
-  
-  test "starts the AGI server with any overridden settings" do
-    overrides        = {:host => "127.0.0.1", :port => 7788}
-    config_overrides = {:listening_host => overrides[:host], :listening_port => overrides[:port]}
-    initialize_asterisk_with_options config_overrides
-    flexmock(Adhearsion::VoIP::Asterisk::AGI::Server).new_instances.should_receive(:start).once.with(overrides)
-  end
-  
-end
-
-context "The Rails initializer" do
-  
-  include RailsInitializerTestHelper
-  
-  test "should load the config/environment.rb file within the rails_root path" do
-    rails_root     = "/path/to/rails/app"
-    environment_rb = rails_root + '/config/environment.rb'
-    flexmock(Adhearsion::Initializer::RailsInitializer).should_receive(:require).once.with environment_rb
-    stub_file_checking_methods!
-    stub_before_call_hook!
-    initialize_rails_with_options :rails_root => rails_root, :environment => :development
-  end
-  
-  test "should raise an exception if the database is initialized at the same time" do
-    flexmock(Adhearsion::AHN_CONFIG).should_receive(:database_enabled?).and_return true
-    flexmock(Adhearsion::Initializer::RailsInitializer).should_receive(:require).and_return
-    stub_file_checking_methods!
-    stub_before_call_hook!
-    the_following_code {
-      initialize_rails_with_options :rails_root => '/tmp', :environment => :development  
-    }.should.raise
-  end
-  
-  test "should set the RAILS_ENV to be the argument passed in" do
-    flexmock(ENV).should_receive(:[]=).once.with("RAILS_ENV", "development")
-    flexmock(Adhearsion::Initializer::RailsInitializer).should_receive(:require).once.and_return
-    stub_file_checking_methods!
-    stub_before_call_hook!
-    initialize_rails_with_options :rails_root => '/tmp', :environment => :development
-  end
-  
-  test 'should enable ActiveRecord concurrency' do
-    flexstub(Adhearsion::Initializer::RailsInitializer).should_receive :require
-    flexstub(Adhearsion::Initializer::RailsInitializer).should_receive :load_rails
-    stub_file_checking_methods!
-    stub_before_call_hook!
-    initialize_rails_with_options :rails_root => '/path/somewhere', :environment => :development
-    ActiveRecord::Base.send(:class_variable_get, :@@allow_concurrency).should.equal true
-  end
-  
-  test 'should create a BeforeCall hook (presumably to verify the active connections)' do    
-    flexstub(Adhearsion::Initializer::RailsInitializer).should_receive :require
-    flexstub(Adhearsion::Initializer::RailsInitializer).should_receive :load_rails
-    stub_file_checking_methods!
-    flexmock(Adhearsion::Hooks::BeforeCall).should_receive(:create_hook).once
-    initialize_rails_with_options :rails_root => '/path/somewhere', :environment => :development
-  end
-  
-end
-
-BEGIN {
-module DatabaseInitializationTestHelper
-  
-  def start_database_initializer
-    start_database_initializer_with_options :adapter => "sqlite3", :dbfile => "foobar.sqlite3"
-  end
-  
-  def start_database_initializer_with_options(options)
-    Adhearsion::Configuration.configure { |config| config.enable_database(options) }
-    Adhearsion::Initializer::DatabaseInitializer.start
-  end
-  
-  def tempfile_with_contents(contents)
-    returning Tempfile.new("bogus_model") do |file|
-      file.puts contents
-      file.flush
-    end
-  end
-  
-  def sample_user_model
-    <<-CODE
-      class User < ActiveRecord::Base
-        validates_uniqueness_of :name
-      end
-    CODE
-  end
-end
-
-module AsteriskInitializerTestHelper
-  def initialize_asterisk_with_defaults
-    initialize_asterisk_with_options Hash.new
-  end
-  def initialize_asterisk_with_options(options)
-    flexmock(Adhearsion::Initializer::AsteriskInitializer).should_receive(:join_server_thread_after_initialized)
-    Adhearsion::Configuration.configure { |config| config.enable_asterisk(options) }
-    Adhearsion::Initializer::AsteriskInitializer.start
-  end
-end
-
-module RailsInitializerTestHelper
-  
-  def initialize_rails_with_options(options)
-    rails_options = flexmock "Rails options mock", options
-    flexstub(Adhearsion::AHN_CONFIG).should_receive(:rails).once.and_return(rails_options)
-    Adhearsion::Initializer::RailsInitializer.start
-  end
-  
-  def stub_file_checking_methods!
-    flexstub(File).should_receive(:directory?).and_return true
-    flexstub(File).should_receive(:exists?).and_return true
-  end
-  
-  def stub_before_call_hook!
-    flexstub(Adhearsion::Hooks::BeforeCall).should_receive :create_hook
-  end
-  
-end
-
-}

data/spec/initializer/test_paths.rb

@@ -1,43 +0,0 @@
-require File.dirname(__FILE__) + "/../test_helper"
-
-describe "Adhearsion::Paths" do
-  
-  #TODO: All this crap will go away
-  disabled_test "should find all files when given a glob" do
-    inside_initialized_app do |path|
-      tmps = %w"foo.rb BA\ R.gem _q_a_z_.c"
-      tmps.each { |f| FileUtils.touch "#{path}/helpers/#{f}" }
-      found_helpers = all_helpers
-      all_helpers.should.not.be.empty
-      all_helpers.map! {|f| File.basename f }
-      all_helpers.each { |f| all_helpers.should.include(f) }
-    end
-  end
-  test "should find files when several globs are given"
-
-  test "should allow the removal of path managers" do
-    Adhearsion::Paths.manager_for :helpers, :directory => "helpers"
-    Adhearsion::Paths.remove_manager_for :helpers
-  end
-end
-
-describe "The .ahnrc " do
-  test "should allow ERb"
-  test "should create methods for every path declared"
-  test "should add all_x and x_path methods to main namespace and pluralize names" do
-    Adhearsion::Paths.manager_for "helper", :directory => "helpers"
-    should.respond_to(:all_helpers)
-    should.respond_to(:helper_path)
-  end
-  test "should have an init key"
-  test "should allow a String to the init key"
-  test "should default the init key to config/startup.rb"
-  test "should allow an Array to the init key"
-end
-
-describe "Adhearsion's paths syntax sugar" do
-  test "should calculate helper paths properly"
-  test "should find log files properly"
-  test "should find helper config paths properly"
-  test "should return the configuration for a helper properly"
-end

data/spec/silence.rb

@@ -1,10 +0,0 @@
-#
-# Seeing the dump of pending specs every time you run them is distracting.
-# This file lets you skip pending specs.
-class Test::Unit::TestResult
-  def add_disabled(name)
-    #nothing!
-  end
-end
-
-Adhearsion::Logging.silence!

data/spec/test_ahn_command.rb

@@ -1,149 +0,0 @@
-require File.dirname(__FILE__) + "/test_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=String.random)
-    File.join Dir.tmpdir, filename
-  end
-  
-  
-end
-
-context 'The Ahn Command helper' do
-  
-  include AhnCommandSpecHelper
-  
-  test "args are simulated properly" do
-    before = ARGV.clone
-    simulate_args "create", "/tmp/blah"
-    ARGV.should.not.equal before
-  end
-  
-  test "STDOUT should be captured" do
-    capture_stdout do
-      puts "wee"
-    end.should.equal "wee\n"
-  end
-  
-end
-
-context "A simulated use of the 'ahn' command" do
-  
-  include AhnCommandSpecHelper
-  
-  test "USAGE is defined" do
-    assert Adhearsion::CLI::AhnCommand.const_defined?('USAGE')
-  end
-  
-  test "arguments to 'create' are executed properly properly" do
-    some_path = "/path/somewhere"
-    simulate_args "create", some_path
-    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:create).once.with(some_path, :default)
-    capture_stdout { Adhearsion::CLI::AhnCommand.execute! }
-  end
-  
-  test "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
-  
-  test "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
-  
-  test '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
-  
-  test '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
-  
-  test '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
-  
-  test "if no path is provided, running Ahn command blows up" do
-    the_following_code {
-      Adhearsion::CLI::AhnCommand.parse_arguments(['start'])
-    }.should.raise Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand
-  end
-  
-  test "printing the version" do
-    capture_stdout do
-      simulate_args 'version'
-      Adhearsion::CLI::AhnCommand.execute!
-    end.should =~ Regexp.new(Regexp.escape(Adhearsion::VERSION::STRING))
-  end
-  
-  test "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
-  
-  test "reacting to unrecognized commands" do
-    the_following_code {
-      simulate_args "alpha", "beta"
-      Adhearsion::CLI::AhnCommand.execute!
-    }.should.raise(Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand)
-  end
-  
-  test "giving a path that doesn't contain a project raises an exception" do
-    the_following_code {
-      simulate_args "start", "/asjdfas/sndjfabsdfbqwb/qnjwejqbwh"
-      Adhearsion::CLI::AhnCommand.execute!
-    }.should.raise(Adhearsion::CLI::AhnCommand::CommandHandler::PathInvalid)
-  end
-  
-  test "giving an unrecognized project name raises an exception" do
-    the_following_code {
-      nonexistent_app_name, nonexistent_path = "a2n8y3gny2", "/tmp/qjweqbwas"
-      simulate_args "create:#{nonexistent_app_name}", nonexistent_path
-      Adhearsion::CLI::AhnCommand.execute!
-    }.should.raise Adhearsion::CLI::AhnCommand::CommandHandler::UnknownProject
-  end
-end
-
-context 'A real use of the "ahn" command' do
-  
-  include AhnCommandSpecHelper
-  
-  test "the 'create' command" 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! }
-      File.exists?(File.join(tmp_path, ".ahnrc")).should.be true
-    }.should.not.raise
-  end
-  
-end

data/spec/test_code_quality.rb

@@ -1,87 +0,0 @@
-# #!/usr/bin/env spec
-# 
-# # TODO: Forget regexps. Use Rubinius.
-# # This spec is somewhat unique. It essentially reads the code
-# # and ensures the best practices are followed.
-# 
-# # TODO: Create a be_a_proper_method_definition assertion
-# # TODO: Create a syntax checking spec
-# # TODO: Report code that has spaces between the dot when defining the method on an object
-# 
-# module CodeQualityHelper
-#   # TODO: Allow strings with a Hash in them before it
-#   
-#   BadMethodRegexp = /def\s+([$@]?[a-zA-Z_][\w_]*\s*\.\s*)?[a-zA-Z_][\w_]*[=!?]?[^(^\Z]/
-#   @root = File.dirname(__FILE__) + "/.."
-#   
-#   def ruby_files
-#     @ruby_files ||= Dir[@root + "/**/*.rb"].map { |f| File.expand_path f }
-#   end
-#   
-# end
-# 
-# describe "My 'bad method definition' finding regular expression" do
-#   
-#   # ATTENTION: If this spec ever blows up for a method definition it shouldn't,
-#   # please add the definition that caused it to explode here as an assertion.
-#   # It would also be nice to fix the regular expression too :)
-#   
-#   include CodeQualityHelper
-#   
-#   it "should NOT match method definitions with no arguments" do
-#     "def foo".should !~ CodeQualityHelper::BadMethodRegexp
-#     " def    monkey   ".should !~ CodeQualityHelper::BadMethodRegexp
-#     ' unless "#{bar}".empty? then def @zebra.spock '.should !~ CodeQualityHelper::BadMethodRegexp
-#   end
-#   
-#   it "should NOT match method definitions with arguments and parenthesis" do
-#     "def foo(bar)".should !~ CodeQualityHelper::BadMethodRegexp
-#     "\tdef $MONKEY . foo( bar, qaz = blam!) ".should !~ CodeQualityHelper::BadMethodRegexp
-#     "if(this) then def $MONKEY . foo( qaz = blam!, *args, &b) ".should !~ CodeQualityHelper::BadMethodRegexp
-#     " @something.each do |x| def something".should !~ CodeQualityHelper::BadMethodRegexp
-#   end
-#   
-#   it "should match method definitions with a space between the name and parenthesis" do
-#     "def foo (bar)".should =~ CodeQualityHelper::BadMethodRegexp
-#     "def  \t m \t (*args)".should =~ CodeQualityHelper::BadMethodRegexp
-#   end
-#   
-#   it "should match method definitions with no parenthesis around its arguments" do
-#     "def foo bar".should =~ CodeQualityHelper::BadMethodRegexp
-#     "\tif $x then def foo bar # Commentacular".should =~ CodeQualityHelper::BadMethodRegexp
-#   end
-# end
-# 
-# describe "All method definitions" do
-#   
-#   include CodeQualityHelper
-#   
-#   before:all do
-#     @root = File.dirname(__FILE__) + "/.."
-#   end
-#   
-#   it "should have parenthesis around their arguments" do
-#     ruby_files.each do |file|
-#       puts file
-#       File.read(file).grep(CodeQualityHelper::BadMethodRegexp).should be_empty
-#     end
-#   end
-# end
-# 
-# # describe "The syntax of all Ruby source files" do
-# #   
-# #   include CodeQualityHelper
-# #   
-# #   before:all do
-# #     @root = File.dirname(__FILE__) + "/.."
-# #   end
-# #   
-# #   it "should be valid" do
-# #     incorrect = ruby_files.map { |f| File.expand_path f }.select do |file|
-# #       `ruby -c #{file}`
-# #       not $?.success?
-# #     end
-# #     
-# #     incorrect.should be_empty
-# #   end
-# # end