sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

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

@@ -1,31 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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
-