maglevrecord 0.1.1 → 0.1.2

data/test/snapshot/test_methods.rb

@@ -0,0 +1,136 @@
+require "snapshot/test_snapshot"
+
+class FastMethodSnapshotTestBase < FastSnapshotTest
+  def setup
+    super
+    def Lecture.removed_method;end
+    Lecture.class_eval{def removed_i_method;end}
+    Lecture.attr_accessor :accessor1
+    snapshot!
+    def Lecture.new_method;end
+    Lecture.class_eval{def new_i_method;5;end}
+    Lecture.remove_method :removed_i_method
+    Lecture.singleton_class.remove_method :removed_method
+  end
+
+  def test
+    Lecture.fill_with_examples
+    assert_equal 5, Lecture.first.new_i_method
+  end
+end
+
+class FastMethodSnapshotEnvironmentTest < FastMethodSnapshotTestBase
+
+  # depends on FastMethodSnapshotTestBase
+
+  def test_Lecture_has_new_method
+    assert_include? Lecture.instance_methods, "new_i_method"
+    assert_include? Lecture.methods, "new_method"
+  end
+
+  def test_Lecture_has_no_removed_method
+    assert_not_include? Lecture.instance_methods, "removed_i_method"
+    assert_not_include? Lecture.methods, "removed_method"
+  end
+
+  def test_Lecture3_has_methods_of_Lecture
+    assert_include? Lecture3.instance_methods, "new_i_method"
+    assert_include? Lecture3.methods, "new_method"
+  end
+
+  def test_Lecture3_has_no_removed_method
+    assert_not_include? Lecture3.instance_methods, "removed_i_method"
+    assert_not_include? Lecture3.methods, "removed_method"
+  end
+end
+
+class FastMethodSnapshotTest < FastMethodSnapshotTestBase
+
+  # depends on FastMethodSnapshotEnvironmentTest
+
+  def test_Lecture_has_new_method
+    assert_include? snapshot[Lecture].class_methods, "new_method"
+    assert_include? snapshot[Lecture].instance_methods, "new_i_method"
+  end
+
+  def test_Lecture_has_no_removed_method
+    assert_not_include? snapshot[Lecture].class_methods, "removed_method"
+    assert_not_include? snapshot[Lecture].instance_methods, "removed_i_method"
+  end
+
+  def test_Lecture3_has_no_new_method
+    assert_not_include? snapshot[Lecture3].class_methods, "new_method"
+    assert_not_include? snapshot[Lecture3].instance_methods, "new_i_method"
+  end
+  def test_Lecture3_has_no_removed_method
+    assert_not_include? snapshot[Lecture3].class_methods, "removed_method"
+    assert_not_include? snapshot[Lecture3].instance_methods, "removed_i_method"
+  end
+end
+
+class FastMethodChangeTest < FastMethodSnapshotTestBase
+
+  # depends on FastMethodSnapshotTest
+
+  def test_only_Lecture_changed
+    assert_equal [], changes.new_classes
+    assert_equal [], changes.removed_classes
+    assert_equal 1, changes.changed_classes.size, "#{changes.changed_classes.size}"
+  end
+
+  def lecture_changes
+    changes.changed_classes.first
+  end
+
+  def test_removed_instance_method
+    assert_equal ["removed_i_method"], lecture_changes.removed_instance_methods
+  end
+
+  def test_removed_class_method
+    assert_equal ["removed_method"], lecture_changes.removed_class_methods
+  end
+
+  def test_new_instance_method
+    assert_equal ["new_i_method"], lecture_changes.new_instance_methods
+  end
+
+  def test_new_class_method
+    assert_equal ["new_method"], lecture_changes.new_class_methods
+  end
+
+end
+
+class FastMethodVSAcessorChangeTest < FastMethodChangeTest
+
+  def setup
+    super
+    Lecture.remove_method :accessor1
+    Lecture.remove_method :accessor1=
+    Lecture.attr_accessor :accessor2
+  end
+
+  def test_new_instance_method
+    assert_equal ["new_i_method"], lecture_changes.new_instance_methods
+  end
+
+  def test_new_instance_method
+    assert_equal ["accessor2", "accessor2=", "new_i_method"], lecture_changes.new_instance_methods
+  end
+
+  def test_removed_instance_method
+    assert_equal ["accessor1", "accessor1=", "removed_i_method"], lecture_changes.removed_instance_methods
+  end
+
+end
+
+class FastMethodVSAcessorSnapshotTest < FastMethodSnapshotTestBase
+
+  def setup
+    super
+    Lecture.remove_method :accessor1
+    Lecture.remove_method :accessor1=
+    Lecture.attr_accessor :accessor2
+  end
+end
+
+# TODO add test for attr becomes method and reverse

data/test/snapshot/test_methods.slow.rb

@@ -0,0 +1,67 @@
+require "snapshot/test_snapshot.slow"
+
+class MethodSnapshotTest < SnapshotTest
+
+  def self.changes
+    @changes
+  end
+
+  as_instance_method :changes
+
+  def self.startup
+    super
+    clean
+    @changes = compare(
+       class_string('MyTestClass2', 'def exists1;end; def exists;end;def self.cls1;end;def self.cls;end;'),
+       class_string('MyTestClass2', 'def exists2;end; def exists;end;def self.cls2;end;def self.cls;end;'))
+  end
+
+  def self.shutdown
+    super
+    clean
+  end
+
+  def test_snapshot_without_error
+    assert_not_nil changes
+  end
+
+  def test_no_class_removed
+    assert_equal changes.removed_classes, []
+  end
+
+  def test_class_changed
+    assert_equal changes.changed_classes.size, 1
+  end
+
+  def test_no_class_was_added
+    assert_equal [], changes.new_classes
+  end
+
+  def changed_class
+    assert_not_nil changes.changed_classes[0], 'a class must have changed'
+    changes.changed_classes[0]
+  end
+
+  def test_method_added
+    assert_equal changed_class.new_instance_methods, ["exists2"]
+  end
+
+  def test_method_removed
+    assert_equal changed_class.removed_instance_methods, ["exists1"]
+  end
+
+  def test_class_method_added
+    assert_equal changed_class.new_class_methods, ["cls2"]
+  end
+
+  def test_class_method_removed
+    assert_equal changed_class.removed_class_methods, ["cls1"]
+  end
+
+  # TODO: test subclasses to not contain methods of superclasses
+
+end
+
+
+
+

data/test/snapshot/test_reset.rb

@@ -0,0 +1,68 @@
+require "migration/operation_setup"
+
+class ResetTest < Test::Unit::TestCase
+
+  def setup
+    setup_migration_operations
+  end
+
+  def teardown
+    teardown_migration_operations
+  end
+
+  def test_reset_an_no_methods_remain
+    Lecture.reset
+    assert_equal [], Lecture.methods(false)
+    assert_equal [], Lecture.instance_methods(false)
+  end
+
+  def test_subclasses_do_not_dfelete_superclass_methods
+    assert_equal Lecture, Lecture3.superclass
+    Lecture3.reset
+    assert_equal [], Lecture3.instance_methods(false)
+    assert_not_equal [], Lecture.instance_methods(false)
+  end
+
+  def test_also_subclasses_lose_methods
+    Lecture3.reset
+    assert_equal [], Lecture3.methods(false)
+    assert_not_equal [], Lecture.methods(false)
+  end
+
+  def test_methods_can_be_restored
+    m = Lecture3.methods(false)
+    im = Lecture3.instance_methods(false)
+    restore = Lecture3.reset
+    restore.call
+    assert_equal m, Lecture3.methods(false)
+    assert_equal im, Lecture3.instance_methods(false)
+  end
+
+  def test_even_new_methods_get_restored
+    def Lecture.something
+      5
+    end
+    restore = Lecture.reset
+    assert_raises(NoMethodError){ Lecture.something }
+    restore.call
+    assert_equal 5, Lecture.something
+  end
+
+  def test_accessors
+    Lecture.attr_accessor :lala
+    assert_include? Lecture.attributes, "lala"
+  end
+
+  def test_attributes_get_removed
+    Lecture.attr_accessor :lala
+    Lecture.reset
+    assert_equal Lecture.attributes, []
+  end
+
+  def test_attributes_get_restored
+    Lecture.attr_accessor :lala
+    restore = Lecture.reset
+    restore.call
+    assert_include? Lecture.attributes, "lala"
+  end
+end

data/test/snapshot/test_snapshot.rb

@@ -1,99 +1,65 @@
-require "maglev_record"
 require "more_asserts"
+require "migration/operation_setup"
 
-class SnapshotTest < Test::Unit::TestCase
-  
-  # the file with the content of what shell be snapshot
-  def self.module_file_path
-    # todo: pot this into a temp dir
-    'module_content.rb'
+class FastSnapshotTest < Test::Unit::TestCase
+
+  def lectures
+    MaglevRecord::Snapshotable.snapshotable_classes.select{ |cls|
+      cls.name.start_with? "Lecture"
+    }
   end
 
-  # the file content that snapshots
-  def self.snapshot_content
-    <<-EOF
-      $LOAD_PATH << "lib"
-      require "rubygems"
-      require "maglev_record"
-      load "#{module_file_path}"
-      Maglev::PERSISTENT_ROOT['test_snapshot'] = MaglevRecord::Snapshot.new
-      Maglev.commit_transaction
-    EOF
+  def assert_migration_string(string, *args)
+    assert_equal string, changes.migration_string(*args)
   end
 
-  # the path of the file that snapshots
-  def self.snapshot_file_path
-    filepath = 'caller_content.rb'
-    File.open(filepath, 'w') { |file| file.write(snapshot_content) }
-    filepath
+  def snapshot
+    MaglevRecord::Snapshot.new(lectures)
   end
 
-  #
-  # snapshot the program after the sting was executed
-  # returns the snapshot and aborts the transaction
-  #
-  def self.snapshot(module_content)
-    File.open(module_file_path, 'w') { |file| file.write(module_content) }
-    stone = Maglev::System.stone_name
-    command =  "export MAGLEV_OPTS=\"-W0 --stone #{stone}\" && "
-    command += "bundle exec "
-    command += "maglev-ruby #{snapshot_file_path}"
-    IO.popen(command) { |f|
-      line = f.gets
-      status = 1 # $? does not work here so we work around
-      while not line.nil?
-        puts line
-        line = f.gets
-      end
-      status
-    }
-    Maglev.abort_transaction
-    Maglev::PERSISTENT_ROOT['test_snapshot']
+  def changes
+    snapshot.changes_since snapshot0
   end
 
-  def self.shutdown
-    File.delete(snapshot_file_path)
-    File.delete(module_file_path) if File.file?(module_file_path)
+  def setup
+    setup_migration_operations
+    snapshot!
   end
 
-  #
-  # compare two sources and return the MaglevRecord Snapshot
-  #
-  def self.compare(s1, s2)
-    s1 = snapshot(s1)
-    s2 = snapshot(s2)
-    s2.changes_since(s1) unless s1.nil? or s2.nil?
+  def teardown
+    teardown_migration_operations
   end
 
-  def self.class_string(name, content = '')
-    "class #{name}
-      include MaglevRecord::Base
-      self.maglev_record_persistable
-      # content follows
-      #{content}
-      # content ends
-    end"
+  def snapshot!
+    @snapshot0 = snapshot
   end
 
-  def self.clean
-    Maglev.abort_transaction
-    consts = [:MyTestClass, :MyTestClass2]
+  def snapshot0
+    @snapshot0
+  end
+
+  def remove_class(*classes)
     Maglev.persistent do
-      consts.each { |const|
-        Object.remove_const(const) if Object.const_defined? const
+      classes.each { |cls|
+        Object.remove_const cls.name
+        LECTURES_NOT_TO_LOAD << cls.name
       }
     end
-    Maglev.commit_transaction
   end
 
-  as_instance_method :class_string, :compare, :snapshot, :clean
-
-  ############### Test
-
-  def test_class_string_include_class_name
-    s = class_string('MyTestClass123123', 'xxxx')
-    assert_include? s, 'class MyTestClass123123'
-    assert_include? s, 'xxxx'
+  def test_removed_class
+    remove_class Lecture3
+    assert_raise(NameError) {
+      Lecture3
+    }
+    assert_not_include? Object.constants, "Lecture3"
+    assert_equal ["Lecture3"], LECTURES_NOT_TO_LOAD
+    Kernel.load LECTURE_TEMPFILE.path
+    assert_raise(NameError) {
+      Lecture3
+    }
   end
 
 end
+
+

data/test/snapshot/test_snapshot.slow.rb

@@ -0,0 +1,98 @@
+require "more_asserts"
+
+class SnapshotTest < Test::Unit::TestCase
+  
+  # the file with the content of what shell be snapshot
+  def self.module_file_path
+    # todo: pot this into a temp dir
+    'module_content.rb'
+  end
+
+  # the file content that snapshots
+  def self.snapshot_content
+    <<-EOF
+      $LOAD_PATH << "lib"
+      require "rubygems"
+      require "maglev_record"
+      load "#{module_file_path}"
+      Maglev::PERSISTENT_ROOT['test_snapshot'] = MaglevRecord::Snapshot.new
+      Maglev.commit_transaction
+    EOF
+  end
+
+  # the path of the file that snapshots
+  def self.snapshot_file_path
+    filepath = 'caller_content.rb'
+    File.open(filepath, 'w') { |file| file.write(snapshot_content) }
+    filepath
+  end
+
+  #
+  # snapshot the program after the sting was executed
+  # returns the snapshot and aborts the transaction
+  #
+  def self.snapshot(module_content)
+    File.open(module_file_path, 'w') { |file| file.write(module_content) }
+    stone = Maglev::System.stone_name
+    command =  "export MAGLEV_OPTS=\"-W0 --stone #{stone}\" && "
+    command += "bundle exec "
+    command += "maglev-ruby #{snapshot_file_path}"
+    IO.popen(command) { |f|
+      line = f.gets
+      status = 1 # $? does not work here so we work around
+      while not line.nil?
+        puts line
+        line = f.gets
+      end
+      status
+    }
+    Maglev.abort_transaction
+    Maglev::PERSISTENT_ROOT['test_snapshot']
+  end
+
+  def self.shutdown
+    File.delete(snapshot_file_path)
+    File.delete(module_file_path) if File.file?(module_file_path)
+  end
+
+  #
+  # compare two sources and return the MaglevRecord Snapshot
+  #
+  def self.compare(s1, s2)
+    s1 = snapshot(s1)
+    s2 = snapshot(s2)
+    s2.changes_since(s1) unless s1.nil? or s2.nil?
+  end
+
+  def self.class_string(name, content = '')
+    "class #{name}
+      include MaglevRecord::Base
+      self.maglev_record_persistable
+      # content follows
+      #{content}
+      # content ends
+    end"
+  end
+
+  def self.clean
+    Maglev.abort_transaction
+    consts = [:MyTestClass, :MyTestClass2]
+    Maglev.persistent do
+      consts.each { |const|
+        Object.remove_const(const) if Object.const_defined? const
+      }
+    end
+    Maglev.commit_transaction
+  end
+
+  as_instance_method :class_string, :compare, :snapshot, :clean
+
+  ############### Test
+
+  def test_class_string_include_class_name
+    s = class_string('MyTestClass123123', 'xxxx')
+    assert_include? s, 'class MyTestClass123123'
+    assert_include? s, 'xxxx'
+  end
+
+end

data/test/snapshot/test_snapshotable.rb

@@ -1,4 +1,3 @@
-require "maglev_record"
 require "more_asserts"
 
 class MySnapshotableClass

data/test/temp_dir_test.rb

@@ -0,0 +1,40 @@
+require "tmpdir"
+require 'test/unit'
+
+#
+# this test creates a temporary directory for the test
+#
+
+class TempDirTest < Test::Unit::TestCase
+  def setup
+    # make temporary directory
+    # see http://ruby-doc.org/stdlib-2.0/libdoc/tmpdir/rdoc/Dir.html#method-c-mktmpdir
+    @tempdir = Dir.mktmpdir
+        @file_count = 0
+  end
+
+  def teardown
+    # remove the directory
+    FileUtils.remove_dir tempdir
+  end
+
+  def tempdir
+    @tempdir
+  end
+
+  def write_to_file(content, file_path = File.join(tempdir, "x#{@file_count += 1}.rb"))
+    File.open(file_path, 'w'){ |f| f.write content}
+    file_path
+  end
+
+  # test the project configuration
+
+  def test_tempdir_exists
+    assert File.directory?(tempdir)
+  end
+
+end
+
+
+
+

data/test/test_active_model_like_interface.rb

@@ -6,6 +6,9 @@ class ActiveModelLikeInterfaceTest < Test::Unit::TestCase
   include ActiveModel::Lint::Tests
 
   def model
-    RootedBook.example
+    b = RootedBook.example
+    # need to trigger method_missing, because respond_to? does not call method_missing
+    b.valid?
+    b
   end
 end

data/test/test_model_timestamps.rb

@@ -8,15 +8,23 @@ class ModelTimestampTest < Test::Unit::TestCase
   def test_time
     @test_time ||= Time.local(2008, 9, 1, 10, 5, 0)
   end
-  def test_created_at
+
+  def setup
     Timecop.freeze(test_time)
-    model = RootedBook.example
-    assert_equal model.created_at, test_time
   end
-
   def teardown
     Timecop.return
   end
 
+  def test_created_at
+    model = RootedBook.example
+    assert_equal model.created_at, test_time
+  end
 
-end
+  def test_updated_at
+    model = RootedBook.example
+    Timecop.freeze(test_time + 10)
+    model.author = 'Another author'
+    assert_equal model.updated_at, test_time + 10
+  end
+end

data/test/test_query_interface.rb

@@ -42,4 +42,14 @@ class QueryInterfaceTest < Test::Unit::TestCase
     assert_equal book, RootedBook.find_by_objectid(book.object_id)
   end
 
+  def test_reset
+    book = RootedBook.find { |b| b.title == "Harry Potter and the Philosopher's stone" }
+    book.author = "J. R. R. Tolkien"
+    book.title = "The Lord of the Rings"
+
+    assert_nil RootedBook.find { |b| b.title == "Harry Potter and the Philosopher's stone" }
+    MaglevRecord.reset
+    assert_not_nil RootedBook.find { |b| b.title == "Harry Potter and the Philosopher's stone" }
+  end
+
 end

data/test/test_sensibles.rb

@@ -1,16 +1,24 @@
 require "more_asserts"
 require "maglev_record"
 
-class User
-  include MaglevRecord::RootedBase
-  attr_accessor :password_digest
-
-  has_secure_password
-  # TODO: No validations so far
-  # validates_presence_of :password, :on => :create
-end
+class SensibleTest < Test::Unit::TestCase
+
+  def setup
+    Object.class_eval "
+    class User
+       include MaglevRecord::RootedBase
+       attr_accessor :password_digest
+       has_secure_password
+       validates_presence_of :password, :on => :create
+     end
+     User.maglev_record_persistable"
+  end
 
-class SensibleTest #< Test::Unit::TestCase
+  def teardown
+    Maglev.persistent do
+      Object.remove_const "User"
+    end
+  end
 
   def pass
     "some_pass"
@@ -35,4 +43,4 @@ class SensibleTest #< Test::Unit::TestCase
     assert_equal user.password, nil
     assert_equal user.password_confirmation, nil
   end
-end
+end

data/test/test_validation.rb

@@ -10,16 +10,6 @@ class ValidationTest < Test::Unit::TestCase
     MaglevRecord.save
   end
 
-  # TODO
-  # def test_reset
-  #   book = Book.find { |b| b.title == "Harry Potter and the Philosopher's stone" }
-  #   book.author = "J. R. R. Tolkien"
-  #   book.title = "The Lord of the Rings"
-
-  #   MaglevRecord.reset
-  #   assert_not_nil Book.find { |b| b.title == "Harry Potter and the Philosopher's stone" }
-  # end
-
   def test_validation_works
     book = RootedBook.new(:author => "Book")
     assert book.valid?
@@ -28,14 +18,14 @@ class ValidationTest < Test::Unit::TestCase
   end
 
   def test_validation_fails
-    book = RootedBook.new()
+    book = RootedBook.new
     assert !book.valid?
     assert book.invalid?
     MaglevRecord.save
   end
 
   def test_errors_not_empty
-    book = RootedBook.new()
+    book = RootedBook.new
     book.valid?
     assert book.errors.count > 0
   end