# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with this
# work for additional information regarding copyright ownership.  The ASF
# licenses this file to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
# License for the specific language governing permissions and limitations under
# the License.


require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helpers'))


describe Buildr::Application do

  describe 'home_dir' do
    it 'should point to ~/.buildr' do
      Buildr.application.home_dir.should eql(File.expand_path('.buildr', ENV['HOME']))
    end

    it 'should point to existing directory' do
      File.directory?(Buildr.application.home_dir).should be_true
    end
  end

  describe '#run' do
    before(:each) do
      FileUtils.touch 'Buildfile'
    end
    
    it 'should execute *_load methods in order' do
      order = [:load_gems, :load_artifact_ns, :load_tasks, :raw_load_buildfile]
      order.each { |method| Buildr.application.should_receive(method).ordered }
      Buildr.application.stub(:exit) # With this, shows the correct error instead of SystemExit.
      Buildr.application.run
    end

    it 'should load imports after loading buildfile' do
      method = Buildr.application.method(:raw_load_buildfile)
      Buildr.application.should_receive(:raw_load_buildfile) do
        Buildr.application.should_receive(:load_imports)
        method.call
      end
      Buildr.application.stub(:exit) # With this, shows the correct error instead of SystemExit.
      Buildr.application.run
    end

    it 'should evaluate all projects after loading buildfile' do
      Buildr.application.should_receive(:load_imports) do
        Buildr.should_receive(:projects)
      end
      Buildr.application.stub(:exit) # With this, shows the correct error instead of SystemExit.
      Buildr.application.run
    end
  end

  describe 'environment' do
    it 'should return value of BUILDR_ENV' do
      ENV['BUILDR_ENV'] = 'qa'
      Buildr.application.environment.should eql('qa')
    end

    it 'should default to development' do
      Buildr.application.environment.should eql('development')
    end

    it 'should set environment name from -e argument' do
      ARGV.push('-e', 'test')
      Buildr.application.send(:handle_options)
      Buildr.application.environment.should eql('test')
      ENV['BUILDR_ENV'].should eql('test')
    end

    it 'should be echoed to user' do
      write 'buildfile'
      ENV['BUILDR_ENV'] = 'spec'
      Buildr.application.send(:handle_options)
      lambda { Buildr.application.send :load_buildfile }.should show(%r{(in .*, spec)})
    end
  end

  describe 'options' do
    it "should have 'tasks' as the sole default rakelib" do
      Buildr.application.send(:handle_options)
      Buildr.application.options.rakelib.should == ['tasks']
    end

    it 'should show the version when prompted with -V' do
      ARGV.push('-V')
      test_exit(0) { Buildr.application.send(:handle_options) }.should show(/Buildr #{Buildr::VERSION}.*/)
    end

    it 'should show the version when prompted with --version' do
      ARGV.push('--version')
      test_exit(0) { Buildr.application.send(:handle_options) }.should show(/Buildr #{Buildr::VERSION}.*/)
    end

    it 'should enable tracing with --trace' do
      ARGV.push('--trace')
      Buildr.application.send(:handle_options)
      Buildr.application.options.trace.should == true
    end

    it 'should enable tracing of [:foo, :bar] categories with --trace=foo,bar' do
      ARGV.push('--trace=foo,bar')
      Buildr.application.send(:handle_options)
      Buildr.application.options.trace.should == true
      Buildr.application.options.trace_categories.should == [:foo, :bar]
      trace?(:foo).should == true
      trace?(:not).should == false
    end

    it 'should enable tracing for all categories with --trace=all' do
      ARGV.push('--trace=all')
      Buildr.application.send(:handle_options)
      Buildr.application.options.trace.should == true
      Buildr.application.options.trace_all.should == true
      trace?(:foo).should == true
    end

  end

  describe 'gems' do
    before do
      class << Buildr.application
        public :load_gems
      end
    end

    def load_with_yaml
      write 'build.yaml', <<-YAML
        gems:
        - rake
        - rspec ~> 2.9.0
      YAML
      Buildr.application.should_receive(:listed_gems).and_return([[Gem.loaded_specs['rspec'],Gem.loaded_specs['rake']],[]])
      Buildr.application.load_gems
    end

    it 'should return empty array if no gems specified' do
      Buildr.application.load_gems
      Buildr.application.gems.should be_empty
    end

    it 'should return one entry for each gem specified in buildr.yaml' do
      load_with_yaml
      Buildr.application.gems.size.should be(2)
    end

    it 'should parse Gem name correctly' do
      load_with_yaml
      Buildr.application.gems.map(&:name).should include('rspec', 'rake')
    end

    it 'should find installed version of Gem' do
      load_with_yaml
      Buildr.application.gems.each { |gem| gem.version.should eql(Gem.loaded_specs[gem.name].version) }
    end
  end

  describe 'load_gems' do
    before do
      class << Buildr.application
        public :load_gems
      end
      @spec = Gem::Specification.new do |spec|
        spec.name = 'buildr-foo'
        spec.version = '1.2'
      end
      $stdout.stub(:isatty).and_return(true)
    end

    it 'should do nothing if no gems specified' do
      lambda { Buildr.application.load_gems }.should_not raise_error
    end

    it 'should install nothing if specified gems already installed' do
      Buildr.application.should_receive(:listed_gems).and_return([[Gem.loaded_specs['rspec']],[]])
      Util.should_not_receive(:ruby)
      lambda { Buildr.application.load_gems }.should_not raise_error
    end

    it 'should fail if required gem not installed' do
      Buildr.application.should_receive(:listed_gems).and_return([[],[Gem::Dependency.new('buildr-foo', '>=1.1')]])
      lambda { Buildr.application.load_gems }.should raise_error(LoadError, /cannot be found/i)
    end

    it 'should load previously installed gems' do
      Gem.loaded_specs['rspec'].should_receive(:activate)
      Buildr.application.should_receive(:listed_gems).and_return([[Gem.loaded_specs['rspec']],[]])
      #Buildr.application.should_receive(:gem).with('rspec', Gem.loaded_specs['rspec'].version.to_s)
      Buildr.application.load_gems
    end

    it 'should default to >=0 version requirement if not specified' do
      write 'build.yaml', 'gems: buildr-foo'
      should_attempt_to_load_dependency(Gem::Dependency.new('buildr-foo', '>= 0'))
    end

    it 'should parse exact version requirement' do
      write 'build.yaml', 'gems: buildr-foo 2.5'
      should_attempt_to_load_dependency(Gem::Dependency.new('buildr-foo', '=2.5'))
    end

    it 'should parse range version requirement' do
      write 'build.yaml', 'gems: buildr-foo ~>2.3'
      should_attempt_to_load_dependency(Gem::Dependency.new('buildr-foo', '~>2.3'))
    end

    it 'should parse multiple version requirements' do
      write 'build.yaml', 'gems: buildr-foo >=2.0 !=2.1'
      should_attempt_to_load_dependency(Gem::Dependency.new('buildr-foo', ['>=2.0', '!=2.1']))
    end

    def should_attempt_to_load_dependency(dep)
      missing_gems = Buildr.application.send(:listed_gems)[1]
      missing_gems.size.should eql(1)
      missing_gems[0].eql?(dep)
    end
  end

  describe 'load_tasks' do
    before do
      class << Buildr.application
        public :load_tasks
      end
      @original_loaded_features = $LOADED_FEATURES.dup
      Buildr.application.options.rakelib = ["tasks"]
    end

    after do
      $taskfiles = nil
      ($LOADED_FEATURES - @original_loaded_features).each do |new_load|
        $LOADED_FEATURES.delete(new_load)
      end
    end

    def write_task(filename)
      write filename, <<-RUBY
        $taskfiles ||= []
        $taskfiles << __FILE__
      RUBY
    end

    def loaded_tasks
      @loaded ||= Buildr.application.load_tasks
      $taskfiles
    end

    it "should load {options.rakelib}/foo.rake" do
      write_task 'tasks/foo.rake'
      loaded_tasks.should have(1).task
      loaded_tasks.first.should =~ %r{tasks/foo\.rake$}
    end

    it 'should load all *.rake files from the rakelib' do
      write_task 'tasks/bar.rake'
      write_task 'tasks/quux.rake'
      loaded_tasks.should have(2).tasks
    end

    it 'should not load files which do not have the .rake extension' do
      write_task 'tasks/foo.rb'
      write_task 'tasks/bar.rake'
      loaded_tasks.should have(1).task
      loaded_tasks.first.should =~ %r{tasks/bar\.rake$}
    end

    it 'should load files only from the directory specified in the rakelib option' do
      Buildr.application.options.rakelib = ['extensions']
      write_task 'extensions/amp.rake'
      write_task 'tasks/bar.rake'
      write_task 'extensions/foo.rake'
      loaded_tasks.should have(2).tasks
      %w[amp foo].each do |filename|
        loaded_tasks.select{|x| x =~ %r{extensions/#{filename}\.rake}}.should have(1).entry
      end
    end

    it 'should load files from all the directories specified in the rakelib option' do
      Buildr.application.options.rakelib = ['ext', 'more', 'tasks']
      write_task 'ext/foo.rake'
      write_task 'tasks/bar.rake'
      write_task 'tasks/zeb.rake'
      write_task 'more/baz.rake'
      loaded_tasks.should have(4).tasks
    end

    it 'should not load files from the rakelib more than once' do
      write_task 'tasks/new_one.rake'
      write_task 'tasks/already.rake'
      $LOADED_FEATURES << File.expand_path('tasks/already.rake')

      loaded_tasks.should have(1).task
      loaded_tasks.first.should =~ %r{tasks/new_one\.rake$}
    end
  end

  describe 'exception handling' do

    it 'should exit when given a SystemExit exception' do
      test_exit(3) { Buildr.application.standard_exception_handling { raise SystemExit.new(3) } }
    end

    it 'should exit with status 1 when given an OptionParser::ParseError exception' do
      test_exit(1) { Buildr.application.standard_exception_handling { raise OptionParser::ParseError.new() } }
    end

    it 'should exit with status 1 when given any other type of exception exception' do
      test_exit(1) { Buildr.application.standard_exception_handling { raise Exception.new() } }
    end

    it 'should print the class name and the message when receiving an exception (except when the exception is named Exception)' do

      # Our fake $stderr for the exercise. We could start it with a matcher instead
      class FakeStdErr

        attr_accessor :messages

        def puts(*args)
          @messages ||= []
          @messages += args
        end

        alias :write :puts
      end

      # Save the old $stderr and make sure to restore it in the end.
      old_stderr = $stderr
      begin

        $stderr = FakeStdErr.new
        test_exit(1) {
          Buildr.application.send :standard_exception_handling do
            class MyOwnNicelyNamedException < Exception
            end
            raise MyOwnNicelyNamedException.new('My message')
          end
        }.call
        $stderr.messages.select {|msg| msg =~ /.*MyOwnNicelyNamedException : My message.*/}.size.should == 1
        $stderr.messages.clear
        test_exit(1) {
          Buildr.application.send :standard_exception_handling do
            raise Exception.new('My message')
          end
        }.call
        $stderr.messages.select {|msg| msg =~ /.*My message.*/ && !(msg =~ /Exception/)}.size.should == 1
      end
      $stderr = old_stderr
    end
  end

end


describe Buildr, 'settings' do

  describe 'user' do

    it 'should be empty hash if no settings.yaml file' do
      Buildr.settings.user.should == {}
    end

    it 'should return loaded settings.yaml file' do
      write 'home/.buildr/settings.yaml', 'foo: bar'
      Buildr.settings.user.should == { 'foo'=>'bar' }
    end

    it 'should return loaded settings.yml file' do
      write 'home/.buildr/settings.yml', 'foo: bar'
      Buildr.settings.user.should == { 'foo'=>'bar' }
    end

    it 'should fail if settings.yaml file is not a hash' do
      write 'home/.buildr/settings.yaml', 'foo bar'
      lambda { Buildr.settings.user }.should raise_error(RuntimeError, /expecting.*settings.yaml/i)
    end

    it 'should be empty hash if settings.yaml file is empty' do
      write 'home/.buildr/settings.yaml'
      Buildr.settings.user.should == {}
    end
  end

  describe 'configuration' do
    it 'should be empty hash if no build.yaml file' do
      Buildr.settings.build.should == {}
    end

    it 'should return loaded build.yaml file' do
      write 'build.yaml', 'foo: bar'
      Buildr.settings.build.should == { 'foo'=>'bar' }
    end

    it 'should return loaded build.yml file' do
      write 'build.yml', 'foo: bar'
      Buildr.settings.build.should == { 'foo'=>'bar' }
    end

    it 'should fail if build.yaml file is not a hash' do
      write 'build.yaml', 'foo bar'
      lambda { Buildr.settings.build }.should raise_error(RuntimeError, /expecting.*build.yaml/i)
    end

    it 'should be empty hash if build.yaml file is empty' do
      write 'build.yaml'
      Buildr.settings.build.should == {}
    end
  end

  describe 'profiles' do
    it 'should be empty hash if no profiles.yaml file' do
      Buildr.settings.profiles.should == {}
    end

    it 'should return loaded profiles.yaml file' do
      write 'profiles.yaml', <<-YAML
        development:
          foo: bar
      YAML
      Buildr.settings.profiles.should == { 'development'=> { 'foo'=>'bar' } }
    end

    it 'should return loaded profiles.yml file' do
      write 'profiles.yml', <<-YAML
        development:
          foo: bar
      YAML
      Buildr.settings.profiles.should == { 'development'=> { 'foo'=>'bar' } }
    end

    it 'should fail if profiles.yaml file is not a hash' do
      write 'profiles.yaml', 'foo bar'
      lambda { Buildr.settings.profiles }.should raise_error(RuntimeError, /expecting.*profiles.yaml/i)
    end

    it 'should be empty hash if profiles.yaml file is empty' do
      write 'profiles.yaml'
      Buildr.settings.profiles.should == {}
    end
  end

  describe 'profile' do
    before do
    end

    it 'should be empty hash if no profiles.yaml' do
      Buildr.settings.profile.should == {}
    end

    it 'should be empty hash if no matching profile' do
      write 'profiles.yaml', <<-YAML
        test:
          foo: bar
      YAML
      Buildr.settings.profile.should == {}
    end

    it 'should return profile matching environment name' do
      write 'profiles.yaml', <<-YAML
        development:
          foo: bar
        test:
          foo: baz
      YAML
      Buildr.settings.profile.should == { 'foo'=>'bar' }
    end
  end

  describe 'buildfile task' do
    before do
      @buildfile_time = Time.now - 10
      write 'buildfile'; File.utime(@buildfile_time, @buildfile_time, 'buildfile')
    end

    it 'should point to the buildfile' do
      Buildr.application.buildfile.should point_to_path('buildfile')
    end

    it 'should be a defined task' do
      Buildr.application.buildfile.should == file(File.expand_path('buildfile'))
    end

    it 'should ignore any rake namespace' do
      namespace 'dummy_ns' do
        Buildr.application.buildfile.should point_to_path('buildfile')
      end
    end

    it 'should have the same timestamp as the buildfile' do
      Buildr.application.buildfile.timestamp.should be_within(1).of(@buildfile_time)
    end

    it 'should have the same timestamp as build.yaml if the latter is newer' do
      write 'build.yaml'; File.utime(@buildfile_time + 5, @buildfile_time + 5, 'build.yaml')
      Buildr.application.run
      Buildr.application.buildfile.timestamp.should be_within(1).of(@buildfile_time + 5)
    end

    it 'should have the same timestamp as the buildfile if build.yaml is older' do
      write 'build.yaml'; File.utime(@buildfile_time - 5, @buildfile_time - 5, 'build.yaml')
      Buildr.application.run
      Buildr.application.buildfile.timestamp.should be_within(1).of(@buildfile_time)
    end

    it 'should have the same timestamp as build.rb in home dir if the latter is newer (until version 1.6)' do
      Buildr::VERSION.should < '1.6'
      buildfile_should_have_same_timestamp_as 'home/buildr.rb'
    end

    it 'should have the same timestamp as build.rb in home dir if the latter is newer' do
      buildfile_should_have_same_timestamp_as 'home/.buildr/buildr.rb'
    end

    it 'should have the same timestamp as .buildr.rb in buildfile dir if the latter is newer' do
      buildfile_should_have_same_timestamp_as '.buildr.rb'
    end

    it 'should have the same timestamp as _buildr.rb in buildfile dir if the latter is newer' do
      buildfile_should_have_same_timestamp_as '_buildr.rb'
    end

    def buildfile_should_have_same_timestamp_as(file)
      write file; File.utime(@buildfile_time + 5, @buildfile_time + 5, file)
      Buildr.application.send :load_tasks
      Buildr.application.buildfile.timestamp.should be_within(1).of(@buildfile_time + 5)
    end
  end
end


describe Buildr do

  describe 'environment' do
    it 'should be same as Buildr.application.environment' do
      Buildr.environment.should eql(Buildr.application.environment)
    end
  end

  describe 'application' do
    it 'should be same as Rake.application' do
      Buildr.application.should == Rake.application
    end
  end

  describe 'settings' do
    it 'should be same as Buildr.application.settings' do
      Buildr.settings.should == Buildr.application.settings
    end
  end

end

describe Rake do
  describe 'define_task' do
   it 'should restore call chain when invoke is called' do
     task1 = Rake::Task.define_task('task1') do
     end

     task2 = Rake::Task.define_task('task2') do
       chain1 = Thread.current[:rake_chain]
       task1.invoke
       chain2 = Thread.current[:rake_chain]
       chain2.should == chain1
     end

     task2.invoke
   end
 end
end