schema_transformer 0.2.0 → 0.3.0

data/test/schema_transformer_test.rb

@@ -1,209 +1,157 @@
 #!/usr/bin/env ruby
 
-ENV['RAILS_ENV'] = 'test'
-
-require 'rubygems'
-require 'test/unit'
-require 'pp'
-require File.expand_path("../../lib/schema_transformer", __FILE__)
-
-# open to mock out methods
-$testing_books = false # im being lazy, should use mocks
-module SchemaTransformer
-  class Base
-    def ask(msg)
-      nil
-    end
-    def gets(name = nil)
-      case name
-      when :table
-        if $testing_books
-          out = "books"
-        else
-          out = "users"
-        end
-      when :mod
-        if $testing_books
-          out = "ADD COLUMN active tinyint(1) DEFAULT '0'"
-        else
-          out = "ADD COLUMN active tinyint(1) DEFAULT '0', 
-           ADD COLUMN title varchar(255) DEFAULT 'Mr', 
-           DROP COLUMN about_me"
-        end
-      else
-        raise "gets method: need to mock out #{name}"
-      end
-      out
-    end
-    def help(msg)
-      nil
-    end
-  end
-end
-
-def setup_fixtures
-  ActiveRecord::Base.connection.drop_table(:users_st_temp, :force => true) rescue nil
-  ActiveRecord::Base.connection.drop_table(:users_st_trash, :force => true) rescue nil
-  ActiveRecord::Base.connection.create_table :users, :force => true do |table|
-    table.column :name, :string
-    table.column :about_me, :string
-    table.column :updated_at, :datetime
-    table.column :created_at, :datetime
-  end
-  Object.send(:remove_const, "User") rescue nil
-  Object.const_set("User", Class.new(ActiveRecord::Base))
-  35.times do |i|
-    User.create(:name => "name_#{i}")
-  end
-  Object.send(:remove_const, "User") rescue nil
-
-  ActiveRecord::Base.connection.drop_table(:books_st_temp, :force => true) rescue nil
-  ActiveRecord::Base.connection.drop_table(:books_st_trash, :force => true) rescue nil
-  # no timestamp
-  ActiveRecord::Base.connection.create_table :books, :force => true do |table|
-    table.column :title, :string
-    table.column :author, :string
-  end
-  Object.send(:remove_const, "Book") rescue nil
-  Object.const_set("Book", Class.new(ActiveRecord::Base))
-  4.times do |i|
-    Book.create(:title => "title_#{i}")
-  end
-  Object.send(:remove_const, "Book") rescue nil
-end
+require File.expand_path("../test_helper", __FILE__)
 
 class SchemaTransformerTest < Test::Unit::TestCase
-  def count(table)
-    @conn = ActiveRecord::Base.connection
-    res = @conn.execute("SELECT count(*) AS c FROM #{table}")
-    c = res.fetch_row[0].to_i # nil case is okay: [nil][0].to_i => 0
-  end
-  
   def setup
     @base = File.expand_path("../fake_app", __FILE__)
+    @transformer = SchemaTransformer::Transform.new(@base, :batch_size => 10, :stagger => 0)
+    setup_fixtures
+    setup_stubs
+    
     @transform_file = @base+"/config/schema_transformations/users.json"
     File.delete(@transform_file) if File.exist?(@transform_file)
-    @transformer = SchemaTransformer::Base.new(@base, :batch_size => 10, :stagger => 0)
-    @conn = ActiveRecord::Base.connection
-    setup_fixtures
   end
   
-  def test_no_updated_at_no_data
-    @conn.execute("delete from books")
-    $testing_books = true
-    @transformer.generate
-    @transformer.gather_info("books")
+  # def test_books_no_updated_at_no_data
+  #   @transformer = SchemaTransformer::Transform.new(@base, :batch_size => 10, :stagger => 0)
+  #   @conn.execute("delete from books")
+  # 
+  #   @transformer.expects(:gets).with(:table).returns("books")
+  #   @transformer.expects(:gets).with(:mod).returns("ADD COLUMN active tinyint(1) DEFAULT '0'")
+  #   
+  #   @transformer.generate
+  #   @transformer.gather_info("books")
+  # 
+  #   assert_table_exist("books")
+  #   assert_table_not_exist("books_st_temp")
+  #   @transformer.create
+  #   assert_table_exist("books_st_temp")
+  # 
+  #   @transformer.final_sync
+  # end
+  # 
+  # def test_books_no_updated_at_with_data
+  #   @transformer = SchemaTransformer::Transform.new(@base, :batch_size => 10, :stagger => 0)
+  #   @transformer.expects(:gets).with(:table).returns("books")
+  #   @transformer.expects(:gets).with(:mod).returns("ADD COLUMN active tinyint(1) DEFAULT '0'")
+  #   
+  #   @transformer.generate
+  #   @transformer.gather_info("books")
+  # 
+  #   assert_table_exist("books")
+  #   assert_table_not_exist("books_st_temp")
+  #   @transformer.create
+  #   assert_table_exist("books_st_temp")
+  # 
+  #   @transformer.final_sync
+  # end
+  # 
+  # def test_find_in_batches
+  #   i = 0
+  #   bounds = [[8, 17], [18, 27], [28,35]]
+  #   @transformer.find_in_batches("users", :start => 8, :batch_size => 10) do |batch|
+  #     # puts "batch #{batch.inspect}"
+  #     lower = batch.first
+  #     upper = batch.last
+  #     assert_equal bounds[i][0], lower
+  #     assert_equal bounds[i][1], upper
+  #     # puts("syncing over records #{lower} to #{upper}...")
+  #     i += 1
+  #   end
+  # end
+  # 
+  # def test_run_sync_black_box
+  #   @transformer.generate
+  #   c1 = count("users")
+  #   SchemaTransformer::Transform.run(:base => @base, :action => ["sync", "users"])
+  #   c2 = count("users_st_temp")
+  #   assert_equal c1, c2
+  # end
+  # 
+  # def test_run_sync_black_box_repeatedly
+  #   @transformer.generate
+  #   c1 = count("users")
+  #   # first run
+  #   SchemaTransformer::Transform.run(:base => @base, :action => ["sync", "users"])
+  #   assert_equal c1, count("users_st_temp")
+  #   @conn.execute("delete from users_st_temp order by id desc limit 10")
+  #   assert_equal c1, count("users_st_temp") + 10
+  #   # second run
+  #   SchemaTransformer::Transform.run(:base => @base, :action => ["sync", "users"])
+  #   assert_equal c1, count("users_st_temp")
+  # end
+  # 
+  # def test_run_switch_black_box
+  #   @transformer.generate
+  #   c1 = count("users")
+  #   SchemaTransformer::Transform.run(:base => @base, :action => ["sync", "users"])
+  #   c2 = count("users_st_temp")
+  #   assert_equal c1, c2
+  #   @conn.execute("delete from users_st_temp order by id desc limit 10")
+  #   assert_equal c1, count("users_st_temp") + 10
+  # 
+  #   # This is what Im testing
+  #   col1 = User.columns.size
+  #   SchemaTransformer::Transform.run(:base => @base, :action => ["switch", "users"])
+  #   User.reset_column_information
+  #   assert_equal col1 + 1, User.columns.size
+  #   assert_equal c1, count("users") # this is the new table
+  # end
+  # 
+  # def test_run_tranformations_white_box
+  #   @transformer.generate
+  #   @transformer.gather_info("users")
+  #   
+  #   assert_table_exist("users")
+  #   assert_table_not_exist("users_st_temp")
+  #   @transformer.create
+  #   assert_table_exist("users_st_temp")
+  #   
+  #   assert_equal 0, UsersStTemp.count
+  #   @transformer.sync
+  #   assert_equal User.count, UsersStTemp.count
+  #   
+  #   assert_table_exist("users")
+  #   @transformer.switch
+  #   assert_table_exist("users_st_trash")
+  #   assert_table_not_exist("users_st_temp")
+  #   
+  #   @transformer.cleanup
+  #   assert_table_exist("users")
+  #   assert_table_not_exist("users_st_trash")
+  #   assert_table_not_exist("users_st_temp")
+  # end
+  # 
+  # def test_generate_transformations
+  #   assert !File.exist?(@transform_file)
+  #   @transformer.generate
+  #   assert File.exist?(@transform_file)
+  #   data = JSON.parse(IO.read(@transform_file))
+  #   assert_equal "users", data["table"]
+  #   assert_match /ADD COLUMN/, data["mod"]
+  #   
+  #   @transformer.gather_info("users")
+  #   assert_equal "users", @transformer.instance_variable_get(:@table)
+  #   assert_match /ADD COLUMN/, @transformer.instance_variable_get(:@mod)
+  # end
   
-    assert @conn.tables.include?("books")
-    assert !@conn.tables.include?("books_st_temp")
-    @transformer.create
-    assert @conn.tables.include?("books_st_temp")
-
-    @transformer.final_sync
-    $testing_books = false
+  def test_analyze_timestamps
+    @analyze = SchemaTransformer::Analyze.new(@base)
+    tables = @analyze.timestamps
+    assert tables.include?("users") # has updated_at timestamp
+    assert !tables.include?("books") # does not have updated_at timestamp
+    tables = @analyze.no_timestamps
+    assert !tables.include?("users") # has updated_at timestamp
+    assert tables.include?("books") # does not have updated_at timestamp
   end
 
-  def test_no_updated_at_with_data
-    $testing_books = true
-    @transformer.generate
-    @transformer.gather_info("books")
-  
-    assert @conn.tables.include?("books")
-    assert !@conn.tables.include?("books_st_temp")
-    @transformer.create
-    assert @conn.tables.include?("books_st_temp")
-
-    @transformer.final_sync
-    $testing_books = false
-  end
-
-  def test_find_in_batches
-    i = 0
-    bounds = [[8, 17], [18, 27], [28,35]]
-    @transformer.find_in_batches("users", :start => 8, :batch_size => 10) do |batch|
-      # puts "batch #{batch.inspect}"
-      lower = batch.first
-      upper = batch.last
-      assert_equal bounds[i][0], lower
-      assert_equal bounds[i][1], upper
-      # puts("syncing over records #{lower} to #{upper}...")
-      i += 1
-    end
-  end
-  
-  def test_run_sync_black_box
-    @transformer.generate
-    c1 = count("users")
-    SchemaTransformer::Base.run(:base => @base, :action => ["sync", "users"])
-    c2 = count("users_st_temp")
-    assert_equal c1, c2
-  end
-  
-  def test_run_sync_black_box_repeatedly
-    @transformer.generate
-    c1 = count("users")
-    # first run
-    SchemaTransformer::Base.run(:base => @base, :action => ["sync", "users"])
-    assert_equal c1, count("users_st_temp")
-    @conn.execute("delete from users_st_temp order by id desc limit 10")
-    assert_equal c1, count("users_st_temp") + 10
-    # second run
-    SchemaTransformer::Base.run(:base => @base, :action => ["sync", "users"])
-    assert_equal c1, count("users_st_temp")
-  end
-  
-  def test_run_switch_black_box
-    @transformer.generate
-    c1 = count("users")
-    SchemaTransformer::Base.run(:base => @base, :action => ["sync", "users"])
-    c2 = count("users_st_temp")
-    assert_equal c1, c2
-    @conn.execute("delete from users_st_temp order by id desc limit 10")
-    assert_equal c1, count("users_st_temp") + 10
-  
-    # This is what Im testing
-    col1 = User.columns.size
-    SchemaTransformer::Base.run(:base => @base, :action => ["switch", "users"])
-    User.reset_column_information
-    assert_equal col1 + 1, User.columns.size
-    assert_equal c1, count("users") # this is the new table
-  end
-  
-  def test_run_tranformations_white_box
-    @transformer.generate
-    @transformer.gather_info("users")
-    
-    assert @conn.tables.include?("users")
-    assert !@conn.tables.include?("users_st_temp")
-    @transformer.create
-    assert @conn.tables.include?("users_st_temp")
-    
-    assert_equal 0, UsersStTemp.count
-    @transformer.sync
-    assert_equal User.count, UsersStTemp.count
-    
-    assert @conn.tables.include?("users")
-    @transformer.switch
-    assert @conn.tables.include?("users_st_trash")
-    assert !@conn.tables.include?("users_st_temp")
-    
-    @transformer.cleanup
-    assert @conn.tables.include?("users")
-    assert !@conn.tables.include?("users_st_trash")
-    assert !@conn.tables.include?("users_st_temp")
-  end
-  
-  def test_generate_transformations
-    assert !File.exist?(@transform_file)
-    @transformer.generate
-    assert File.exist?(@transform_file)
-    data = JSON.parse(IO.read(@transform_file))
-    assert_equal "users", data["table"]
-    assert_match /ADD COLUMN/, data["mod"]
-    
-    @transformer.gather_info("users")
-    assert_equal "users", @transformer.instance_variable_get(:@table)
-    assert_match /ADD COLUMN/, @transformer.instance_variable_get(:@mod)
+  def test_analyze_indexes
+    @analyze = SchemaTransformer::Analyze.new(@base)
+    tables = @analyze.indexes
+    assert_equal [], tables
+    tables = @analyze.no_indexes
+    assert tables.include?("users") # has updated_at timestamp, but index
   end
 end
 

data/test/test_helper.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+ENV['RAILS_ENV'] = 'test'
+
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'pp'
+require File.expand_path("../../lib/schema_transformer", __FILE__)
+
+module TestExtensions
+  def setup_fixtures
+    @conn = ActiveRecord::Base.connection # shortcut to connection
+    
+    # cleanup in case tests fail half way
+    @conn.drop_table(:users_st_temp, :force => true) rescue nil
+    @conn.drop_table(:users_st_trash, :force => true) rescue nil
+    
+    @conn.create_table :users, :force => true do |table|
+      table.column :name, :string
+      table.column :about_me, :string
+      table.column :updated_at, :datetime
+      table.column :created_at, :datetime
+    end
+    Object.send(:remove_const, "User") rescue nil
+    Object.const_set("User", Class.new(ActiveRecord::Base))
+    35.times do |i|
+      User.create(:name => "name_#{i}")
+    end
+    Object.send(:remove_const, "User") rescue nil
+
+    # cleanup in case tests fail half way
+    @conn.drop_table(:books_st_temp, :force => true) rescue nil
+    @conn.drop_table(:books_st_trash, :force => true) rescue nil
+    # no timestamp
+    @conn.create_table :books, :force => true do |table|
+      table.column :title, :string
+      table.column :author, :string
+    end
+    Object.send(:remove_const, "Book") rescue nil
+    Object.const_set("Book", Class.new(ActiveRecord::Base))
+    4.times do |i|
+      Book.create(:title => "title_#{i}")
+    end
+    Object.send(:remove_const, "Book") rescue nil
+  end
+  
+  def setup_stubs
+    SchemaTransformer::Transform.any_instance.stubs(:gets).with(:table).returns("users")
+    SchemaTransformer::Transform.any_instance.stubs(:gets).with(:mod).returns(
+      "ADD COLUMN active tinyint(1) DEFAULT '0', 
+       ADD COLUMN title varchar(255) DEFAULT 'Mr', 
+       DROP COLUMN about_me"
+    )
+    SchemaTransformer::Transform.any_instance.stubs(:ask).returns(nil)
+    SchemaTransformer::Transform.any_instance.stubs(:help).returns(nil)
+  end
+
+  def count(table)
+    res = @conn.execute("SELECT count(*) AS c FROM #{table}")
+    c = res.fetch_row[0].to_i # nil case is okay: [nil][0].to_i => 0
+  end
+  
+  def assert_table_exist(table)
+    assert @conn.tables.include?(table)
+  end
+
+  def assert_table_not_exist(table)
+    assert !@conn.tables.include?(table)
+  end
+end
+
+class Test::Unit::TestCase
+  include TestExtensions
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: schema_transformer
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Tung Nguyen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-23 00:00:00 -07:00
+date: 2010-10-24 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -30,18 +30,20 @@ extra_rdoc_files:
 files: 
 - bin/schema_transformer
 - gemspec.rb
+- lib/schema_transformer/analyze.rb
 - lib/schema_transformer/base.rb
 - lib/schema_transformer/cli.rb
 - lib/schema_transformer/help.rb
+- lib/schema_transformer/transform.rb
 - lib/schema_transformer/version.rb
 - lib/schema_transformer.rb
 - Rakefile
 - README.markdown
 - test/fake_app/config/database.yml
 - test/fake_app/config/schema_transformations/books.json
-- test/fake_app/config/schema_transformations/users.json
 - test/fake_app/log/schema_transformer.log
 - test/schema_transformer_test.rb
+- test/test_helper.rb
 - TODO
 has_rdoc: true
 homepage: http://github.com/tongueroo/schema_transformer