migrant 1.5.0 → 2.0.0.pre

data/test/test_data_schema.rb

@@ -1,108 +0,0 @@
-require 'helper'
-
-def assert_schema(model, name, options = {})
-  field = model.schema.column_migrations.detect {|m| m.first == name}
-  assert_not_nil(field, 'Migration was not generated')
-  options.each do |key, correct_value|
-    assert_equal(correct_value, field[1][key])
-  end
-end
-
-class TestDataSchema < Test::Unit::TestCase
-  context "The schema generator" do
-    should "generate a foreign key field for a belongs_to association" do
-      assert_schema(Business, :user_id, :type => :integer)
-      assert_schema(BusinessCategory, :business_id, :type => :integer)      
-      assert_schema(BusinessCategory, :category_id, :type => :integer)  
-      assert_schema(User, :category_id, :type => :integer) 
-    end  
-    
-    should "generate foreign key fields for a *polymorphic* belongs_to association" do
-      assert_schema(Business, :owner_id, :type => :integer)
-      assert_schema(Business, :owner_type, :type => :string)
-    end  
-    
-    should "generate a string column when given a string example" do
-      assert_schema(Business, :name)
-    end
-
-    should "generate a datetime column when given a date or time example" do
-      assert_schema(Business, :date_established, :type => :datetime)
-      assert_schema(Business, :next_sale, :type => :datetime)
-      assert_schema(Business, :date_registered, :type => :date)
-    end
-
-    should "generate a smallint column when given a small range" do
-      assert_schema(Business, :operating_days, :type => :integer)
-    end
-    
-    should "generate a large integer (size 8) for any bignum types" do
-      assert_schema(Category, :serial_number, :limit => 8, :type => :integer)
-    end
-
-    should "generate a string column when given a sentence" do
-      assert_schema(Business, :summary, :type => :string)
-    end
-    
-    should "generate a text column when given a long paragraph" do
-      assert_schema(Business, :address, :type => :text)      
-    end
-    
-    should "pass on any options provided in a structure block" do
-      assert_schema(User, :average_rating, :type => :float, :default => 0.0)
-    end
-    
-    should "generate a boolean column when a true or false is given" do
-      assert_schema(Business, :verified, :type => :boolean)      
-    end
-    
-    should "generate a column verbatim if no type is specified" do
-      assert_schema(Business, :location, :type => :string, :limit => 127)          
-    end
-    
-    should "generate a string column when no options are given" do
-      assert_schema(Category, :title, :type => :string)
-      assert_schema(Category, :summary, :type => :string)                                      
-    end
-    
-    should "generate a decimal column when a currency is given" do
-      assert_schema(User, :money_spent, :type => :decimal, :scale => 2)
-      assert_schema(User, :money_gifted, :type => :decimal, :scale => 2)      
-    end
-    
-    should "generate a floating point column when a decimal is given" do
-      assert_schema(User, :average_rating, :type => :float)    
-    end
-    
-    should "generate a string column when an email example or class is given" do
-      assert_schema(User, :email, :type => :string)    
-    end
-    
-    should "generate indexes for all foreign keys automatically" do
-      assert_contains(Business.schema.indexes, :user_id, 'Missing index on belongs_to')
-      assert_contains(Business.schema.indexes, [:owner_type, :owner_id], 'Missing index on polymorphic belongs_to')      
-      assert_contains(BusinessCategory.schema.indexes, :business_id, 'Missing index on belongs_to')      
-      assert_contains(BusinessCategory.schema.indexes, :category_id, 'Missing index on belongs_to')      
-    end
-    
-    should "generate indexes on any column when explicitly asked to" do
-      assert_contains(Category.schema.indexes, :title, 'Missing index on :index => true column')
-    end 
-    
-    should "generate a text column for serialized fields" do
-      assert_schema(Business, :awards, :type => :text)
-      assert_schema(Business, :managers, :type => :text)
-      
-      assert_equal(Array, Business.schema.columns[:awards].mock.class)
-      assert_equal(Hash, Business.schema.columns[:managers].mock.class)
-    
-      assert(Business.serialized_attributes.keys.include?("awards"), "Should call ActiveRecord::Base.serialize")
-      assert(Business.serialized_attributes.keys.include?("managers"), "Should call ActiveRecord::Base.serialize")
-    end
-  end
-
-  should "still indicate a structure is not defined if a belongs_to association is added" do
-    assert_equal(false, NonMigrantModel.structure_defined?)
-    assert_equal(true, Business.structure_defined?)
-  end
-end

data/test/test_migration_generator.rb

@@ -1,251 +0,0 @@
-require 'helper'
-require 'rake'
-
-def rake_migrate
-   Dir.chdir(Rails.root.join('.')) do
-        Rake::Task['db:migrate'].execute
-   end
-end
-
-class TestMigrationGenerator < Test::Unit::TestCase
-  def generate_migrations
-    Profiler.run(:migration_generator) do
-      assert_equal true, Migrant::MigrationGenerator.new.run, "Migration Generator reported an error"
-    end
-  end
-
-  def run_against_template(template)
-    generate_migrations
-    Dir.glob(File.join(File.dirname(__FILE__), 'rails_app', 'db' ,'migrate', '*.rb')).each do |migration_file|
-        if migration_file.include?(template)
-          to_test = File.open(migration_file, 'r') { |r| r.read}.strip
-          File.open(File.join(File.dirname(__FILE__), 'verified_output', 'migrations', template+'.rb'), 'r') do |file|
-            while (line = file.gets)
-              assert_not_nil(to_test.gsub(/[\.\(\)]/, '').match(line.gsub(/[\.\(\)]/, '').strip), "Generated migration #{migration_file} missing line: #{line.gsub(/[\.\(\)]/, '').strip}")
-            end
-          end
-          rake_migrate
-          return
-        end
-    end
-    flunk "No migration could be found like '#{template}'"
-  end
-
-  def any_template_match?(template)
-    Dir.glob(File.join(File.dirname(__FILE__), 'rails_app', 'db' ,'migrate', '*.rb')).each do |migration_file|
-      if migration_file.include?(template)
-        return true
-      end
-    end
-    false
-  end
-
-  def delete_last_migration
-    File.delete(Dir.glob(File.join(File.dirname(__FILE__), 'rails_app', 'db' ,'migrate', '*.rb')).last)
-  end
-
-  context "The migration generator" do
-    should "create migrations for all new tables" do
-      generate_migrations
-      Dir.glob(File.join(File.dirname(__FILE__), 'rails_app', 'db' ,'migrate', '*.rb')).each do |migration_file|
-         to_test = File.open(migration_file, 'r') { |r| r.read}.strip
-         File.open(File.join(File.dirname(__FILE__), 'verified_output', 'migrations', migration_file.sub(/^.*\d+_/, '')), 'r') do |file|
-           while (line = file.gets)
-             assert_not_nil(to_test.match(line.strip), "Generated migration #{migration_file} missing line: #{line}")
-           end
-         end
-      end
-      rake_migrate
-    end
-
-    should "generate a migration for new added fields" do
-      Business.structure do
-        estimated_value 5000.0
-        notes
-      end
-      run_against_template('estimated_value_notes')
-    end
-
-    should "generate a migration to alter existing columns where no data loss would occur" do
-      Business.structure do
-        landline :text
-      end
-
-      run_against_template('landline')
-    end
-
-    should "generate a migration to alter existing columns while adding a new table" do
-      load File.join(File.dirname(__FILE__), 'additional_models', 'review.rb')
-      User.belongs_to(:business) # To generate a business_id on a User
-      User.no_structure # To force schema update
-
-      run_against_template('create_reviews')
-      run_against_template('business_id')
-    end
-
-    should "generate created_at and updated_at when given the column timestamps" do
-      Business.structure do
-        timestamps
-      end
-      run_against_template('created_at')
-    end
-
-    should "prompt the user to confirm changing existing columns where data loss may occur" do
-      STDIN._mock_responses('N')
-
-      Business.structure do
-        landline :integer # Was previously a string, which obviously may incur data loss
-      end
-      Migrant::MigrationGenerator.new.run
-      assert(any_template_match?('modified_landline'), 'Ignored a request not to generate a dangerous migration!')
-      Business.structure do
-        landline :text # Undo our bad for the next tests
-      end
-    end
-
-    should "exit immediately if there are pending migrations" do
-     manual_migration = Rails.root.join("db/migrate/9999999999999999_my_new_migration.rb")
-     File.open(manual_migration, 'w') { |f| f.write ' ' }
-     assert_equal(false, Migrant::MigrationGenerator.new.run)
-     File.delete(manual_migration)
-    end
-
-    should "still create sequential migrations for the folks not using timestamps" do
-      Business.structure do
-        new_field_i_made_up
-      end
-      # Remove migrations
-      ActiveRecord::Base.timestamped_migrations = false
-      generate_migrations
-      ActiveRecord::Base.timestamped_migrations = true
-
-      assert_equal(Dir.glob(File.join(File.dirname(__FILE__), 'rails_app', 'db' ,'migrate', '*.rb')).select { |migration_file| migration_file.include?('new_field_i_made_up') }.length,
-                   1,
-                   "Migration should have been generated (without a duplicate)")
-      rake_migrate
-    end
-
-    should "recursively generate mocks for every model" do
-      BusinessCategory.structure do
-        test_mockup_of_text :text
-        test_mockup_of_string :string
-        test_mockup_of_integer :integer
-        test_mockup_of_float   :float
-        test_mockup_of_datetime :datetime
-        test_mockup_of_currency DataType::Currency
-        test_mockup_serialized :serialized
-        test_mockup_hash OpenStruct.new({'a' => 'b'})
-        test_mockup_serialized_example :serialized, :example => OpenStruct.new({'c' => 'd'})
-      end
-
-
-      BusinessCategory.belongs_to(:notaclass, :polymorphic => true)
-      generate_migrations
-      rake_migrate
-      BusinessCategory.reset_column_information
-      m = BusinessCategory.mock!
-      mock = BusinessCategory.last
-
-      assert_not_nil(mock)
-      assert(mock.test_mockup_of_text.is_a?(String))
-      assert(mock.test_mockup_of_string.is_a?(String))
-      assert(mock.test_mockup_of_integer.is_a?(Fixnum))
-      assert(mock.test_mockup_of_float.is_a?(Float))
-      assert(mock.test_mockup_of_currency.is_a?(BigDecimal))
-      assert(mock.test_mockup_of_datetime.is_a?(Time))
-      assert(DataType::Base.default_mock.is_a?(String))
-      assert(mock.test_mockup_serialized.is_a?(Hash))
-      assert(mock.test_mockup_hash.is_a?(OpenStruct))
-      assert_equal(mock.test_mockup_hash.a, 'b')
-      assert(mock.test_mockup_serialized_example.is_a?(OpenStruct))
-      assert_equal(mock.test_mockup_serialized_example.c, 'd')
-    end
-
-    should "not rescursively generate mocks for an inherited model when prohibited by the user" do
-      category_mock = BusinessCategory.mock!({}, false)
-      assert_not_nil(category_mock)
-    end
-
-    should "generate example mocks for an inherited model when STI is in effect" do
-      assert_equal(5.00, Customer.mock.average_rating)
-      assert_equal("somebody@somewhere.com", Customer.mock.email)
-      assert(Customer.mock.is_a?(Customer))
-    end
-
-
-    should "remove columns when requested and confirmed by the user" do
-      Chameleon.structure
-      Chameleon.reset_structure!
-      Chameleon.no_structure
-
-      STDIN._mock_responses('D', 'y')
-      run_against_template('deleted_incompatible_spot')
-    end
-
-    should "not remove columns when the user does not confirm" do
-      Chameleon.reset_structure!
-      Chameleon.no_structure
-
-      STDIN._mock_responses('D', 'n')
-      generate_migrations
-      rake_migrate
-      Chameleon.structure do
-        spots
-      end
-    end
-
-    should "successfully rename a column missing from the schema to a new column specified by the user" do
-      Chameleon.structure do
-        old_spots
-      end
-      generate_migrations
-      rake_migrate
-      Chameleon.reset_structure!
-      Chameleon.structure do
-        new_spots
-      end
-      STDIN._mock_responses('M', 'new_spots')
-      run_against_template('renamed_old_spots')
-    end
-
-    should "transfer data to an new incompatible column if the operation is safe" do
-      Chameleon.reset_column_information
-      Chameleon.create!(:new_spots => "22")
-      Chameleon.reset_structure!
-      Chameleon.structure do
-        new_longer_spots "100", :as => :text
-      end
-      STDIN._mock_responses('M', 'new_longer_spots', 'M')
-      run_against_template('chameleons_added_new_longer_spots_and_moved_new_spots')
-      Chameleon.reset_column_information
-      assert_equal(Chameleon.first.new_longer_spots, "22")
-    end
-
-    should "remove any column if a user elects to when a column can't be moved due to incompatible types" do
-      Chameleon.reset_structure!
-      Chameleon.structure do
-        incompatible_spot 5
-      end
-
-      STDIN._mock_responses('M', 'incompatible_spot', 'N', 'Y')
-      run_against_template('added_incompatible_spot_and_deleted_spots')
-    end
-
-    should "update a column to include a new default" do
-      Business.structure do
-        verified true, :default => true
-      end
-
-      run_against_template('modified_verified')
-    end
-
-    should "update indexes on a model" do
-      Business.structure do
-        name "The Kernel's favourite fried chickens.", :index => true
-      end
-
-      run_against_template('businesses_indexed_name')
-    end
-  end
-end
-

data/test/test_validations.rb

@@ -1,49 +0,0 @@
-require 'helper'
-
-class TestValidations < Test::Unit::TestCase
-  should "validate via ActiveRecord when the validates symbol is supplied" do
-    Business.structure do
-      website :string, :validates => :presence
-    end
-
-    business = Business.create
-    assert(business.errors.include?(:website), "Validation was not applied")
-  end
-
-  should "validate via ActiveRecord when the full validation hash is supplied" do
-    Category.structure do
-      summary :string, :validates => { :format => { :with => /Symphony\d/ } }
-    end
-
-    bad_category = Category.create
-    good_category = Category.create(:summary => "Symphony5")
-    assert(bad_category.errors.include?(:summary), "Validation was not applied")
-    assert(!good_category.errors.include?(:summary), "Validation options were incorrect")
-  end
-
-  should "validate via ActiveRecord when no field name is given" do
-    User.structure do
-      email :validates => :presence
-    end
-
-    user = User.create
-    assert(user.errors.include?(:email), "Validation was not applied")
-  end
-  
-  should "validate multiple validations via ActiveRecord when an array is given" do
-    Review.structure do
-      name "ABCD", :validates => [:presence, {:length => {:maximum => 4}}]
-    end    
-    
-    not_present = Review.create
-    too_long = Review.create(:name => "Textthatistoolong")
-    correct = Review.create(:name => "ABC")
-    
-    assert(not_present.errors.include?(:name), "primary validation was not applied")
-    assert(too_long.errors.include?(:name), "secondary validation was not applied")
-    assert(!correct.errors.include?(:name), "validation for a correct model failed")
-    
-  end
-
-end
-

data/test/test_zzz_performance.rb

@@ -1,13 +0,0 @@
-require 'helper'
-
-#SimpleProfiler.results
-
-class TestZZZPerformance < Test::Unit::TestCase
-  context "Performance" do
-  should "be within acceptable limits" do
-    # Just a utility test for printing profiler results
-    Profiler.results
-    assert true
-  end
-  end
-end

data/test/verified_output/migrations/added_incompatible_spot_and_deleted_spots.rb

@@ -1,11 +0,0 @@
-class ChangedChameleonsAddedIncompatibleSpotAndDeletedSpots < ActiveRecord::Migration
-  def self.up
-    add_column :chameleons, :incompatible_spot, :integer
-    remove_column :chameleons, :spots
-  end
-  
-  def self.down
-    add_column :chameleons, :spots, :string, :limit=>255
-    remove_column :chameleons, :incompatible_spot
-  end
-end

data/test/verified_output/migrations/business_id.rb

@@ -1,10 +0,0 @@
-class ChangedUsersAddedBusinessId < ActiveRecord::Migration
-  def self.up
-    add_column :users, :business_id, :integer
-    add_index :users, :business_id
-  end
-  
-  def self.down
-    remove_column :users, :business_id
-  end
-end