ittayd-buildr 1.3.4 → 1.3.5

data/spec/core/common_spec.rb

@@ -1,670 +0,0 @@
-# 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.join(File.dirname(__FILE__), '../spec_helpers')
-
-describe Buildr.method(:struct) do
-  before do
-    @hash = { :foo=>'foo:jar', :bar=>'bar:jar' }
-    @struct = struct(@hash)
-  end
-
-  it 'should be object with key-value pairs' do
-    @struct.foo.should eql('foo:jar')
-    @struct.bar.should eql('bar:jar')
-  end
-
-  it 'should fail when requesting non-existent key' do
-    lambda { @struct.foobar }.should raise_error(NoMethodError)
-  end
-
-  it 'should return members when requested' do
-    @struct.members.sort.should eql(@hash.keys.map(&:to_s).sort)
-  end
-
-  it 'should return valued when requested' do
-    @struct.values.sort.should eql(@hash.values.sort)
-  end
-end
-
-
-describe Buildr.method(:write) do
-  it 'should create path' do
-    write 'foo/test'
-    File.directory?('foo').should be_true
-    File.exist?('foo/test').should be_true
-  end
-
-  it 'should write content to file' do
-    write 'test', 'content'
-    File.read('test').should eql('content')
-  end
-
-  it 'should retrieve content from block, if block given' do
-    write('test') { 'block' }
-    File.read('test').should eql('block')
-  end
-
-  it 'should write empty file if no content provided' do
-    write 'test'
-    File.read('test').should eql('')
-  end
-
-  it 'should return content as a string' do
-    write('test', 'content').should eql('content')
-  end
-
-  it 'should return empty string if no content provided' do
-    write('test').should eql('')
-  end
-end
-
-
-describe Buildr.method(:read) do
-  before do
-    write @file = 'test', @content = 'content'
-  end
-
-  it 'should return contents of named file' do
-    read(@file).should eql(@content)
-  end
-
-  it 'should yield to block if block given' do
-    read @file do |content|
-      content.should eql(@content)
-    end
-  end
-
-  it 'should return block response if block given' do
-    read(@file) { 5 }.should be(5)
-  end
-end
-
-
-describe Buildr.method(:download) do
-  before do
-    @content = 'we has download!'
-    @http = mock('http')
-    @http.stub!(:request).and_return(Net::HTTPNotModified.new(nil, nil, nil))
-  end
-
-  def tasks()
-    [ download('http://localhost/download'), download('downloaded'=>'http://localhost/download') ]
-  end
-
-  it 'should be a file task' do
-    tasks.each { |task| task.should be_kind_of(Rake::FileTask) }
-  end
-
-  it 'should accept a String and download from that URL' do
-    define 'foo' do
-      download('http://localhost/download').tap do |task|
-        task.source.should_receive(:read).and_yield [@content]
-        task.invoke
-        task.should contain(@content)
-      end
-    end
-  end
-
-  it 'should accept a URI and download from that URL' do
-    define 'foo' do
-      download(URI.parse('http://localhost/download')).tap do |task|
-        task.source.should_receive(:read).and_yield [@content]
-        task.invoke
-        task.should contain(@content)
-      end
-    end
-  end
-
-  it 'should accept a path and String and download from that URL' do
-    define 'foo' do
-      download('downloaded'=>'http://localhost/download').tap do |task|
-        task.source.should_receive(:read).and_yield [@content]
-        task.invoke
-        task.should contain(@content)
-      end
-    end
-  end
-
-  it 'should accept an artifact and String and download from that URL' do
-    define 'foo' do
-      artifact('com.example:library:jar:2.0').tap do |artifact|
-        download(artifact=>'http://localhost/download').source.should_receive(:read).and_yield [@content]
-        artifact.invoke
-        artifact.should contain(@content)
-      end
-    end
-  end
-
-  it 'should accept a path and URI and download from that URL' do
-    define 'foo' do
-      download('downloaded'=>URI.parse('http://localhost/download')).tap do |task|
-        task.source.should_receive(:read).and_yield [@content]
-        task.invoke
-        task.should contain(@content)
-      end
-    end
-  end
-
-  it 'should create path for download' do
-    define 'foo' do
-      download('path/downloaded'=>URI.parse('http://localhost/download')).tap do |task|
-        task.source.should_receive(:read).and_yield [@content]
-        task.invoke
-        task.should contain(@content)
-      end
-    end
-  end
-
-  it 'should fail if resource not found' do
-    tasks.each do |task|
-      task.source.should_receive(:read).and_raise URI::NotFoundError
-      lambda { task.invoke }.should raise_error(URI::NotFoundError)
-    end
-    tasks.last.should_not exist
-  end
-
-  it 'should fail on any other error' do
-    tasks.each do |task|
-      task.source.should_receive(:read).and_raise RuntimeError
-      lambda { task.invoke }.should raise_error(RuntimeError)
-    end
-    tasks.last.should_not exist
-  end
-
-  it 'should execute only if file does not already exist' do
-    define 'foo' do
-      download('downloaded'=>'http://localhost/download').tap do |task|
-        task.source.should_not_receive(:read)
-        write task.to_s, 'not really'
-        task.invoke
-      end
-    end
-  end
-
-  it 'should execute without a proxy if none specified' do
-    Net::HTTP.should_receive(:new).with('localhost', 80).twice.and_return(@http)
-    tasks.each(&:invoke)
-  end
-
-  it 'should pass Buildr proxy options' do
-    Buildr.options.proxy.http = 'http://proxy:8080'
-    Net::HTTP.should_receive(:new).with('localhost', 80, 'proxy', 8080, nil, nil).twice.and_return(@http)
-    tasks.each(&:invoke)
-  end
-
-  it 'should set HTTP proxy from HTTP_PROXY environment variable' do
-    ENV['HTTP_PROXY'] = 'http://proxy:8080'
-    Net::HTTP.should_receive(:new).with('localhost', 80, 'proxy', 8080, nil, nil).twice.and_return(@http)
-    tasks.each(&:invoke)
-  end
-end
-
-
-describe Buildr.method(:filter) do
-  def source
-    File.expand_path('src')
-  end
-  
-  it 'should return a Filter for the source' do
-    filter(source).should be_kind_of(Filter)
-  end
-
-  it 'should use the source directory' do
-    filter(source).sources.should include(file(source))
-  end
-
-  it 'should use the source directories' do
-    dirs = ['first', 'second']
-    filter('first', 'second').sources.should include(*dirs.map { |dir| file(File.expand_path(dir)) })
-  end
-
-  it 'should accept a file task' do
-    task = file(source)
-    filter(task).sources.each { |source| source.should be(task) }
-  end
-end
-
-
-describe Buildr::Filter do
-  before do
-    @filter = Filter.new
-    1.upto(4) do |i|
-      write "src/file#{i}", "file#{i} raw"
-    end
-    @early = Time.now - 1000
-  end
-
-  it 'should respond to :from and return self' do
-    @filter.from('src').should be(@filter)
-  end
-
-  it 'should respond to :from and add source directory' do
-    lambda { @filter.from('src') }.should change { @filter.sources }
-  end
-
-  it 'should respond to :from and add source directories' do
-    dirs = ['first', 'second']
-    @filter.from(*dirs)
-    @filter.sources.should include(*dirs.map { |dir| file(File.expand_path(dir)) })
-  end
-
-  it 'should return source directories as file task' do
-    @filter.from('src').sources.each { |source| source.should be_kind_of(Rake::FileTask) }
-  end
-
-  it 'should return source directories as expanded path' do
-    @filter.from('src').sources.each { |source| source.to_s.should eql(File.expand_path('src')) }
-  end
-
-  it 'should respond to :into and return self' do
-    @filter.into('target').should be(@filter)
-  end
-
-  it 'should respond to :into and set target directory' do
-    lambda { @filter.into('src') }.should change { @filter.target }
-    @filter.into('target').target.should be(file(File.expand_path('target')))
-  end
-
-  it 'should return target directory as file task' do
-    @filter.into('target').target.should be_kind_of(Rake::FileTask)
-  end
-
-  it 'should return target directory as expanded path' do
-    @filter.into('target').target.to_s.should eql(File.expand_path('target'))
-  end
-
-  it 'should respond to :using and return self' do
-    @filter.using().should be(@filter)
-  end
-
-  it 'should respond to :using and set mapping from the argument' do
-    mapping = { 'foo'=>'bar' }
-    lambda { @filter.using mapping }.should change { @filter.mapping }.to(mapping)
-  end
-
-  it 'should respond to :using and set mapping from the block' do
-    @filter.using { 5 }.mapping.call.should be(5)
-  end
-
-  it 'should respond to :include and return self' do
-    @filter.include('file').should be(@filter)
-  end
-
-  it 'should respond to :include and use these inclusion patterns' do
-    @filter.from('src').into('target').include('file2', 'file3').run
-    Dir['target/*'].sort.should eql(['target/file2', 'target/file3'])
-  end
-
-  it 'should respond to :exclude and return self' do
-    @filter.exclude('file').should be(@filter)
-  end
-
-  it 'should respond to :exclude and use these exclusion patterns' do
-    @filter.from('src').into('target').exclude('file2', 'file3').run
-    Dir['target/*'].sort.should eql(['target/file1', 'target/file4'])
-  end
-
-  it 'should copy files over' do
-    @filter.from('src').into('target').run
-    Dir['target/*'].sort.each do |file|
-      read(file).should eql("#{File.basename(file)} raw")
-    end
-  end
-
-  it 'should copy dot files over' do
-    write 'src/.config', '# configuration'
-    @filter.from('src').into('target').run
-    read('target/.config').should eql('# configuration')
-  end
-
-  it 'should copy empty directories as well' do
-    mkpath 'src/empty'
-    @filter.from('src').into('target').run
-    File.directory?('target/empty').should be_true
-  end
-
-  it 'should copy files from multiple source directories' do
-    4.upto(6) { |i| write "src2/file#{i}", "file#{i} raw" }
-    @filter.from('src', 'src2').into('target').run
-    Dir['target/*'].each do |file|
-      read(file).should eql("#{File.basename(file)} raw")
-    end
-    Dir['target/*'].should include(*(1..6).map { |i| "target/file#{i}" })
-  end
-
-  it 'should copy files recursively' do
-    mkpath 'src/path1' ; write 'src/path1/left'
-    mkpath 'src/path2' ; write 'src/path2/right'
-    @filter.from('src').into('target').run
-    Dir['target/**/*'].should include(*(1..4).map { |i| "target/file#{i}" })
-    Dir['target/**/*'].should include('target/path1/left', 'target/path2/right')
-  end
-
-  it 'should apply hash mapping using Maven style' do
-    1.upto(4) { |i| write "src/file#{i}", "file#{i} with ${key1} and ${key2}" }
-    @filter.from('src').into('target').using('key1'=>'value1', 'key2'=>'value2').run
-    Dir['target/*'].each do |file|
-      read(file).should eql("#{File.basename(file)} with value1 and value2")
-    end
-  end
-
-  it 'should apply hash mapping using Ant style' do
-    1.upto(4) { |i| write "src/file#{i}", "file#{i} with @key1@ and @key2@" }
-    @filter.from('src').into('target').using(:ant, 'key1'=>'value1', 'key2'=>'value2').run
-    Dir['target/*'].each do |file|
-      read(file).should eql("#{File.basename(file)} with value1 and value2")
-    end
-  end
-
-  it 'should apply hash mapping using Ruby style' do
-    1.upto(4) { |i| write "src/file#{i}", "file#{i} with \#{key1} and \#{key2}" }
-    @filter.from('src').into('target').using(:ruby, 'key1'=>'value1', 'key2'=>'value2').run
-    Dir['target/*'].each do |file|
-      read(file).should eql("#{File.basename(file)} with value1 and value2")
-    end
-  end
-
-  it 'should use erb when given a binding' do
-    1.upto(4) { |i| write "src/file#{i}", "file#{i} with <%= key1 %> and <%= key2 * 2 %>" }
-    key1 = 'value1'
-    key2 = 12
-    @filter.from('src').into('target').using(binding).run
-    Dir['target/*'].each do |file|
-      read(file).should eql("#{File.basename(file)} with value1 and 24")
-    end
-  end
-
-  it 'should apply hash mapping using erb' do
-    1.upto(4) { |i| write "src/file#{i}", "file#{i} with <%= key1 %> and <%= key2 * 2 %>" }
-    @filter.from('src').into('target').using(:erb, 'key1'=>'value1', 'key2'=> 12).run
-    Dir['target/*'].each do |file|
-      read(file).should eql("#{File.basename(file)} with value1 and 24")
-    end
-  end
-
-  it 'should use an object binding when using erb' do
-    1.upto(4) { |i| write "src/file#{i}", "file#{i} with <%= key1 %> and <%= key2 * 2 %>" }
-    obj = Struct.new(:key1, :key2).new('value1', 12)
-    @filter.from('src').into('target').using(:erb, obj).run
-    Dir['target/*'].each do |file|
-      read(file).should eql("#{File.basename(file)} with value1 and 24")
-    end
-  end
-
-  it 'should use a given block context when using erb' do
-    1.upto(4) { |i| write "src/file#{i}", "file#{i} with <%= key1 %> and <%= key2 * 2 %>" }
-    key1 = 'value1'
-    key2 = 12
-    @filter.from('src').into('target').using(:erb){}.run
-    Dir['target/*'].each do |file|
-      read(file).should eql("#{File.basename(file)} with value1 and 24")
-    end
-  end
-
-  it 'should using Maven mapper by default' do
-    @filter.using('key1'=>'value1', 'key2'=>'value2').mapper.should eql(:maven)
-  end
-
-  it 'should apply hash mapping using regular expression' do
-    1.upto(4) { |i| write "src/file#{i}", "file#{i} with #key1# and #key2#" }
-    @filter.from('src').into('target').using(/#(.*?)#/, 'key1'=>'value1', 'key2'=>'value2').run
-    Dir['target/*'].each do |file|
-      read(file).should eql("#{File.basename(file)} with value1 and value2")
-    end
-  end
-
-  it 'should apply proc mapping' do
-    @filter.from('src').into('target').using { |file, content| 'proc mapped' }.run
-    Dir['target/*'].each do |file|
-      read(file).should eql('proc mapped')
-    end
-  end
-
-  it 'should apply proc mapping with relative file name' do
-    @filter.from('src').into('target').using { |file, content| file.should =~ /^file\d$/ }.run
-  end
-
-  it 'should apply proc mapping with file content' do
-    @filter.from('src').into('target').using { |file, content| content.should =~ /^file\d raw/ }.run
-  end
-
-  it 'should make target directory' do
-    lambda { @filter.from('src').into('target').run }.should change { File.exist?('target') }.to(true)
-  end
-
-  it 'should touch target directory' do
-    mkpath 'target' ; File.utime @early, @early, 'target'
-    @filter.from('src').into('target').run
-    File.stat('target').mtime.should be_close(Time.now, 10)
-  end
-
-  it 'should not touch target directory unless running' do
-    mkpath 'target' ; File.utime @early, @early, 'target'
-    @filter.from('src').into('target').exclude('*').run
-    File.mtime('target').should be_close(@early, 10)
-  end
-
-  it 'should run only on new files' do
-    # Make source files older so they're not copied twice.
-    Dir['src/**/*'].each { |file| File.utime(@early, @early, file) }
-    @filter.from('src').into('target').run
-    @filter.from('src').into('target').using { |file, content| file.should eql('file2') }.run
-  end
-
-  it 'should return true when run copies any files' do
-    @filter.from('src').into('target').run.should be(true)
-  end
-
-  it 'should return false when run does not copy any files' do
-    # Make source files older so they're not copied twice.
-    Dir['src/**/*'].each { |file| File.utime(@early, @early, file) }
-    @filter.from('src').into('target').run
-    @filter.from('src').into('target').run.should be(false)
-  end
-
-  it 'should fail if source directory doesn\'t exist' do
-    lambda { Filter.new.from('srced').into('target').run }.should raise_error(RuntimeError, /doesn't exist/)
-  end
-
-  it 'should fail is target directory not set' do
-    lambda { Filter.new.from('src').run }.should raise_error(RuntimeError, /No target directory/)
-  end
-
-  it 'should copy read-only files as writeable' do
-    Dir['src/*'].each { |file| File.chmod(0444, file) }
-    @filter.from('src').into('target').run
-    Dir['target/*'].sort.each do |file|
-      File.readable?(file).should be_true
-      File.writable?(file).should be_true
-      (File.stat(file).mode & 0o200).should == 0o200
-    end
-  end
-end
-
-describe Filter::Mapper do 
-  
-  module MooMapper
-    def moo_config(*args, &block)
-      raise ArgumentError, "Expected moo block" unless block_given?
-      { :moos => args, :callback => block }
-    end
-    
-    def moo_transform(content, path = nil)
-      content.gsub(/moo+/i) do |str|
-        moos = yield :moos # same than config[:moos]
-        moo = moos[str.size - 3] || str
-        config[:callback].call(moo)
-      end
-    end
-  end
-
-  it 'should allow plugable mapping types' do
-    mapper = Filter::Mapper.new.extend(MooMapper)
-    mapper.using(:moo, 'ooone', 'twoo') do |str|
-      i = nil; str.capitalize.gsub(/\w/) { |s| s.send( (i = !i) ? 'upcase' : 'downcase' ) }
-    end
-    mapper.transform('Moo cow, mooo cows singing mooooo').should == 'OoOnE cow, TwOo cows singing MoOoOo'
-  end
-
-end
-
-describe Buildr.method(:options) do
-  it 'should return an Options object' do
-    options.should be_kind_of(Options)
-  end
-
-  it 'should return an Options object each time' do
-    options.should be(options)
-  end
-
-  it 'should return the same Options object when called on Object, Buildr or Project' do
-    options.should be(Buildr.options)
-    define('foo') { options.should be(Buildr.options) }
-  end
-end
-
-describe Buildr::Options, 'proxy.exclude' do
-  before do
-    options.proxy.http = 'http://myproxy:8080'
-    @domain = 'domain'
-    @host = "host.#{@domain}"
-    @uri = URI("http://#{@host}")
-    @no_proxy_args = [@host, 80]
-    @proxy_args = @no_proxy_args + ['myproxy', 8080, nil, nil]
-    @http = mock('http')
-    @http.stub!(:request).and_return(Net::HTTPNotModified.new(nil, nil, nil))
-  end
-
-  it 'should be an array' do
-    options.proxy.exclude.should be_empty
-    options.proxy.exclude = @domain
-    options.proxy.exclude.should include(@domain)
-  end
-
-  it 'should support adding to array' do
-    options.proxy.exclude << @domain
-    options.proxy.exclude.should include(@domain)
-  end
-
-  it 'should support resetting array' do
-    options.proxy.exclude = @domain
-    options.proxy.exclude = nil
-    options.proxy.exclude.should be_empty
-  end
-
-  it 'should use proxy when not excluded' do
-    Net::HTTP.should_receive(:new).with(*@proxy_args).and_return(@http)
-    @uri.read :proxy=>options.proxy
-  end
-
-  it 'should use proxy unless excluded' do
-    options.proxy.exclude = "not.#{@domain}"
-    Net::HTTP.should_receive(:new).with(*@proxy_args).and_return(@http)
-    @uri.read :proxy=>options.proxy
-  end
-
-  it 'should not use proxy if excluded' do
-    options.proxy.exclude = @host
-    Net::HTTP.should_receive(:new).with(*@no_proxy_args).and_return(@http)
-    @uri.read :proxy=>options.proxy
-  end
-
-  it 'should support multiple host names' do
-    options.proxy.exclude = ['optimus', 'prime']
-    Net::HTTP.should_receive(:new).with('optimus', 80).and_return(@http)
-    URI('http://optimus').read :proxy=>options.proxy
-    Net::HTTP.should_receive(:new).with('prime', 80).and_return(@http)
-    URI('http://prime').read :proxy=>options.proxy
-    Net::HTTP.should_receive(:new).with('bumblebee', *@proxy_args[1..-1]).and_return(@http)
-    URI('http://bumblebee').read :proxy=>options.proxy
-  end
-
-  it 'should support glob pattern on host name' do
-    options.proxy.exclude = "*.#{@domain}"
-    Net::HTTP.should_receive(:new).with(*@no_proxy_args).and_return(@http)
-    @uri.read :proxy=>options.proxy
-  end
-end
-
-
-describe Hash, '::from_java_properties' do
-  it 'should return hash' do
-    hash = Hash.from_java_properties(<<-PROPS)
-name1=value1
-name2=value2
-    PROPS
-    hash.should == {'name1'=>'value1', 'name2'=>'value2'}
-  end
-
-  it 'should ignore comments and empty lines' do
-    hash = Hash.from_java_properties(<<-PROPS)
-
-name1=value1
-
-name2=value2
-
-PROPS
-    hash.should == {'name1'=>'value1', 'name2'=>'value2'}
-  end
-
-  it 'should allow multiple lines' do
-    hash = Hash.from_java_properties(<<-PROPS)
-name1=start\
- end
-
-name2=first\
- second\
- third
-
-PROPS
-    hash.should == {'name1'=>'start end', 'name2'=>'first second third'}
-  end
-
-  it 'should handle \t, \r, \n and \f' do
-    hash = Hash.from_java_properties(<<-PROPS)
-
-name1=with\tand\r
-
-name2=with\\nand\f
-
-name3=double\\\\hash
-PROPS
-    hash.should == {'name1'=>"with\tand", 'name2'=>"with\nand\f", 'name3'=>'double\hash'}
-  end
-  
-  it 'should ignore whitespace' do
-    hash = Hash.from_java_properties('name1 = value1')
-    hash.should == {'name1'=>'value1'}
-  end
-end
-
-
-describe Hash, '#to_java_properties' do
-  it 'should return name/value pairs' do
-    props = {'name1'=>'value1', 'name2'=>'value2'}.to_java_properties
-    props.split("\n").size.should be(2)
-    props.split("\n").should include('name1=value1')
-    props.split("\n").should include('name2=value2')
-  end
-
-  it 'should handle \t, \r, \n and \f' do
-    props = {'name1'=>"with\tand\r", 'name2'=>"with\nand\f", 'name3'=>'double\hash'}.to_java_properties
-    props.split("\n").should include("name1=with\\tand\\r")
-    props.split("\n").should include("name2=with\\nand\\f")
-    props.split("\n").should include("name3=double\\\\hash")
-  end
-end