sproutit-sproutcore 1.0.0.20090407205609

data/spec/lib/models/manifest_entry/cacheable_url_spec.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::ManifestEntry, 'timestamp_url' do
+  
+  include SC::SpecHelpers
+  
+  before do
+    @project = fixture_project(:real_world)
+    @target = @project.target_for :contacts
+    @manifest = @target.manifest_for(:language => :en)
+    
+    # create entry manually to avoid calling prepare
+    @entry = SC::ManifestEntry.new @manifest, 
+      :filename => "filename", 
+      :url => "foo",
+      :source_path => "imaginary" / "path"
+  end
+
+  it "should return url itself if timestamp_url config is false" do
+    @target.config.timestamp_urls = false # preconditon
+    @entry.cacheable_url.should == 'foo'
+  end
+  
+  it "should return url with timestamp token appended as query string if timestamp_url is true" do
+    @target.config.timestamp_urls = true # preconditon
+    @entry.timestamp.should_not be_blank # preconditon
+    @entry.cacheable_url.should == "foo?#{@entry.timestamp}"
+  end
+
+  
+end

data/spec/lib/models/manifest_entry/prepare_spec.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::ManifestEntry, 'prepare!' do
+  
+  include SC::SpecHelpers
+  
+  before do
+    @project = fixture_project(:real_world)
+    @target = @project.target_for :contacts
+    
+    @target.buildfile.define! do
+      replace_task 'entry:prepare' do
+        ENTRY.task_did_run = (ENTRY.task_did_run || 0) + 1
+      end
+    end
+    
+    @manifest = @target.manifest_for(:language => :en)
+    
+    # create entry manually to avoid calling prepare
+    @entry = SC::ManifestEntry.new(@manifest, :filename => "filename")
+  end
+
+  it "should return self" do
+    @entry.prepare!.should eql(@entry)
+  end
+  
+  it "should execute entry:prepare if defined" do
+    @entry.prepared?.should be_false # check precondition
+    @entry.prepare!
+    @entry.prepared?.should be_true
+    @entry.task_did_run.should eql(1) # ran?
+  end
+
+  it "should do nothing if entry:prepare is not defined" do
+
+    # get an empty project with no build tasks...
+    project = empty_project
+    project.add_target '/default', :default, :source_root => project.project_root
+    target = project.targets['/default']
+    target.buildfile.lookup('entry:prepare').should be_nil
+    manifest = target.manifest_for :language => :en
+    entry = SC::ManifestEntry.new(manifest, :filename => 'filename')
+    lambda { entry.prepare! }.should_not raise_error
+    
+  end
+  
+  it "should execute entry:prepare only once" do
+    @entry.prepared?.should be_false # check precondition
+    @entry.prepare!.prepare!.prepare!
+    @entry.prepared?.should be_true
+    @entry.task_did_run.should eql(1) # ran only once?
+  end
+  
+end

data/spec/lib/models/project/add_target_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'add_target' do
+
+  include SC::SpecHelpers
+
+  before do
+    @project = SC::Project.new fixture_path('buildfiles', 'empty_project')
+  end
+  
+  it "should add a target with the passed name" do
+    @project.add_target :target_name, :target_type
+    target = @project.targets[:target_name]
+    target.should_not be_nil
+    target.target_name.should eql(:target_name)
+    target.target_type.should eql(:target_type)
+  end
+
+  it "should set the target.project automatically" do
+    @project.add_target :target_name, :target_type
+    @project.targets[:target_name].project.should eql(@project)
+  end
+  
+  it "should set any other passed options on the target itself" do
+    @project.add_target :target_name, :target_type, :foo => :foo, :bar => :bar
+    target = @project.targets[:target_name]
+    
+    target.should_not be_nil
+    target.foo.should eql(:foo)
+    target.bar.should eql(:bar)
+  end
+  
+  it "should replace an existing target if defined" do
+    @project.add_target :test1, :dummy
+    target1 = @project.targets[:test1]
+    
+    @project.add_target :test1, :dummy2
+    target2 = @project.targets[:test1]
+    
+    target2.should_not eql(target1)
+    target2.target_type.should eql(:dummy2)
+  end
+
+end

data/spec/lib/models/project/buildfile_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'buildfile' do
+
+  include SC::SpecHelpers
+
+  it "should return a new, empty buildfile if no Buildfile can be found in the project" do
+    project = SC::Project.new fixture_path('buildfiles', 'empty_project')
+    puts project.buildfile.loaded_paths
+    project.buildfile.loaded_paths.size.should eql(0)
+    project.buildfile.tasks.size.should eql(0)
+  end
+  
+  it "should load a buildfile if one is found in project_root" do
+    project = SC::Project.new fixture_path('buildfiles', 'installed')
+    project.buildfile.loaded_paths.size.should eql(1)
+    project.buildfile.tasks.size.should eql(2)
+  end
+  
+  it "should load all files matching SC.env.buildfile_names" do
+    SC.env.buildfile_names = ['Buildfile', 'Buildfile2']
+    project = SC::Project.new fixture_path('buildfiles', 'installed')
+    project.buildfile.loaded_paths.size.should eql(2)
+    SC.env.delete :buildfile_names
+  end
+
+  it "should merge over top of a parent project buildfile if there is one" do
+    installed = SC::Project.new fixture_path('buildfiles', 'installed')
+    basic = SC::Project.new fixture_path('buildfiles', 'basic'), :parent => installed
+    basic.buildfile.lookup(:installed_task).should_not be_nil
+    basic.buildfile.lookup(:test_task1).should_not be_nil
+  end
+  
+end
+

data/spec/lib/models/project/find_targets_for_spec.rb

@@ -0,0 +1,77 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'find_targets_for' do
+
+  include SC::SpecHelpers
+  
+  # path for a target inside fixtures for this test
+  def target_path(*args)
+    fixture_path(*args.unshift('find_targets'))
+  end
+  
+  # Should be a hash of target type -> array of expected target names
+  def expect_targets(targets, expected_targets = {})
+    known_targets = targets.keys
+    expected_targets.each do | target_type, expected |
+      expected.each do |target_name|
+        target_name = target_name.to_sym
+        known_targets.should include(target_name)
+        targets[target_name].target_type.should eql(target_type)
+        known_targets.delete target_name
+      end
+    end
+  end
+  
+  it "should search recursively for apps, clients, themes, and frameworks dirs with standard options -- also should ignore CaSeOfDir" do
+    
+    project = SC::Project.new(target_path('standard'), :parent => builtin_project)
+
+    # verify preconditions
+    target_types = project.config.target_types
+    target_types.size.should eql(4)
+    target_types[:apps].should eql(:app)
+    target_types[:clients].should eql(:app)
+    target_types[:frameworks].should eql(:framework)
+    target_types[:themes].should eql(:theme)
+    project.config.allow_nested_targets.should be_true
+    
+    # Note, this expectation assumes the fixtures in find_targets/standard has
+    # the following:
+    #  - different cases (see Apps + apps dirs)
+    #  - an apps, clients, and frameworks directory
+    #  - multiple targets in same dir (see framework1, framework2)
+    #  - nesting one type inside another (see app1/framework1, app1/fmwk2)
+    #  - nesting same type inside another (see framework1/framework1)
+    #
+    expect_targets project.targets, 
+      :app => %w(/app1 /client1),
+      :framework => %w(/framework1 /framework2 /app1/framework1 /app1/framework2 /framework1/framework1),
+      :theme => %w(/theme1 /theme2)
+  end
+  
+  it "should find targets based on target_types hash, including overrides in  target Buildfiles" do
+    
+    project = SC::Project.new(target_path('custom'))
+    
+    # NOTE: find_targets_spec/custom/Buildfile defines foo & bar types
+    # custom/foos/custom_foos/Buildfiels overrides.
+    expect_targets project.targets,
+      :foo => %w(/foo1 /custom_foos /custom_foos/foo1 /custom_foos/foo2 /bar1/foo1 /bar1/foo2),
+      :bar => %w(/bar1 /bar1/bar1 /bar1/bar2 /foo1/bar1 /foo1/bar2)
+    
+  end
+  
+  it "should recursively find targets unless allows_nested_targets = false; should respect overrides in Buildfiles" do
+    
+    project = SC::Project.new(target_path('nested'))
+    
+    # NOTE: find_targets_spec/custom/Buildfile defines foo & bar types
+    # custom/foos/custom_foos/Buildfiels overrides.
+    expect_targets project.targets,
+      :app => %w(/app1)
+    project.targets['/app1/nested_app'].should be_nil
+  end
+  
+  
+end
+  

data/spec/lib/models/project/load_nearest_project_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'load_nearest_project' do
+  
+  include SC::SpecHelpers
+  
+  it "should find the highest-level directory with a Buildfile" do
+    # Note: since the fixtures live INSIDE the source directory and the 
+    # source directory contains a Buildfile, the _proper_ result here is to 
+    # actually return the top-level directory...
+    project = SC::Project.load_nearest_project fixture_path('buildfiles', 'basic')
+    project.project_root.should eql(fixture_path('..', '..'))
+  end
+  
+  it "should stop if it finds a Buildfile with project! set" do
+    project = SC::Project.load_nearest_project fixture_path('buildfiles', 'project_test', 'not_project', 'child')
+    
+    # The Buildfile at project_test indicates that it is a project -- so it
+    # should stop searching here...
+    project.project_root.should eql(fixture_path('buildfiles', 'project_test'))
+  end
+  
+end

data/spec/lib/models/project/target_for_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'target_for' do
+
+  include SC::SpecHelpers
+
+  before do
+    @project = fixture_project(:real_world)
+  end
+  
+  it "should lookup absolute target names (/foo) from the top" do
+    target = @project.target_for('/sproutcore')
+    target.should_not be_nil
+    target.target_name.to_s.should eql('/sproutcore')
+  end
+  
+  it "should lookup relative target names from the top (like absolute)" do
+    target = @project.target_for(:sproutcore)
+    target.should_not be_nil
+    target.target_name.to_s.should eql('/sproutcore')
+  end
+  
+  it "should return nil if no matching target could be found" do
+    target = @project.target_for(:does_not_exist)
+    target.should be_nil
+  end
+  
+  it "should NOT call prepare! on new targets" do
+    target = @project.target_for(:contacts)
+    target.prepared?.should be_false
+  end
+  
+end

data/spec/lib/models/project/targets_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'targets' do
+
+  include SC::SpecHelpers
+
+  it "should clone targets from a parent project" do
+    
+    # Generate a dummy class to manually add a target.  This way we isolate
+    # the tests for merging from tests of finding targets...
+    test_project = Class.new(SC::Project) do
+      def find_targets_for(root_path, root_name, config)
+        self.add_target :base1, :dummy_type, { :source_root => "foo" }
+      end
+    end
+    parent = test_project.new fixture_path('buildfiles', 'empty_project')
+    
+    # Now generate a real project with an empty path.  This should clone 
+    # targets from the parent...
+    project = SC::Project.new fixture_path('buildfiles', 'empty_project'), :parent => parent
+    project.targets.size.should eql(1)
+    
+    t = project.targets['base1']
+    t.target_name.should == :base1
+    t.target_type.should == :dummy_type
+    t.source_root.should  == "foo"
+  end
+  
+  # We want to test this because find_targets_for() is a callback we expect
+  # people who customize the build tools to override.
+  it "should invoke the find_targets_for method on itself" do
+    
+    # Generate dummy class with custom find_targets_for.
+    test_project = Class.new(SC::Project) do
+      
+      attr_reader :did_call_find_targets_for
+      attr_reader :passed_root_path
+      attr_reader :passed_root_name
+      attr_reader :passed_config
+      
+      def find_targets_for(root_path, root_name, config)
+        @did_call_find_targets_for = true
+        @passed_root_path = root_path
+        @passed_root_name = root_name
+        @passed_config = config
+        return self
+      end
+    end
+    
+    # create project & get targets
+    project = test_project.new fixture_path('buildfiles', 'empty_project')
+    project.targets.size.should eql(0)
+    
+    # verify that callback method was run
+    project.did_call_find_targets_for.should be_true
+    project.passed_root_path.should eql(project.project_root)
+    project.passed_root_name.should be_nil
+    project.passed_config.should eql(project.config)
+  end
+    
+end
+

data/spec/lib/models/target/compute_build_number_spec.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+require 'tempfile'
+require 'fileutils'
+
+describe SC::Target, 'compute_build_number' do
+
+  include SC::SpecHelpers
+
+  before do
+    @project = temp_project(:real_world)
+  end
+  
+  after do
+    @project.cleanup
+  end
+    
+  def add_dummyfile(project)
+    file = File.new(File.join(project.source_root, 'dummyfile'), 'w')
+    file.write "TEST!"
+    file.close
+  end
+    
+  it "uses the config.build_number if specified for the target" do
+    # add build number for target to general buildfile
+    @project.buildfile.define! do
+      config :sproutcore, :build_number => 'foo'
+    end
+    target = @project.target_for(:sproutcore)
+    target.compute_build_number.should eql('foo')
+  end
+  
+  it "uses the config.build_numbers.target_name if specified" do
+    # add a build_numbers hash
+    @project.buildfile.define! do
+      config :all, :build_numbers => { '/sproutcore' => 'foo' }
+    end
+    target = @project.target_for(:sproutcore)
+    target.compute_build_number.should eql('foo')
+  end
+  
+  it "uses config.build_numbers.target_name, even if specified with symbols" do
+    @project.buildfile.define! do
+      config :all, :build_numbers => { :'/sproutcore' => :foo }
+    end
+    target = @project.target_for(:sproutcore)
+    target.compute_build_number.should eql('foo')
+  end
+    
+  
+  describe "accurate method to compute build number" do
+    
+    before do
+      @target = @project.target_for(:sproutcore)
+      @target.config.build_numbers = nil #precondition
+      @target.config.build_number = nil  #precondition
+    end
+      
+    it "generates a unique build number based on content if nothing is explicitly set" do
+      @target.compute_build_number.should_not be_nil
+    end
+  
+    it "changes its generated build number if contents of source files change" do
+      old_build_number = @target.compute_build_number
+    
+      # write an extra file into target for testing
+      add_dummyfile(@target)
+    
+      # get new build number
+      new_build_number = @target.compute_build_number
+      new_build_number.should_not eql(old_build_number)
+    end
+  end
+
+  it "changes generated build number if build number for a required target changes" do
+    target = @project.target_for(:sproutcore)
+    target.should_not be_nil
+
+    required = target.target_for(:desktop)
+    required.should_not be_nil
+    required.config.build_numbers = nil #precondition
+    required.config.build_number = nil  #precondition
+  
+    target.config.build_numbers = nil #precondition
+    target.config.build_number = nil  #precondition
+    target.required_targets.should include(required) #precondition
+  
+    old_build_number = target.compute_build_number
+  
+    # write an extra file into required target for testing -- changes number
+    add_dummyfile(required)
+  
+    # get new build number
+    new_build_number = target.compute_build_number
+    new_build_number.should_not eql(old_build_number)
+  end
+
+  it "does not change generated build number if a nested target that is not required by target changes" do
+    target = @project.target_for(:sproutcore)
+    target.should_not be_nil
+
+    not_required = target.target_for(:mobile)
+    not_required.should_not be_nil
+
+    #precondition
+    target.expand_required_targets.should_not include(not_required) 
+  
+    target = @project.target_for(:sproutcore)
+    old_build_number = target.compute_build_number
+  
+    # write an extra file into required target for testing -- changes number
+    add_dummyfile(not_required)
+  
+    # get new build number
+    new_build_number = target.compute_build_number
+    new_build_number.should eql(old_build_number)
+  end
+  
+  it "recursively required project should not cause an error" do
+    recursive = fixture_project(:recursive_project)
+    target = recursive.target_for :sproutcore
+    lambda { target.compute_build_number }.should_not raise_error
+  end
+  
+end
+