maglevrecord 0.0.3 → 0.1.1

data/test/migration/test_remove.rb

@@ -0,0 +1,219 @@
+####
+#
+#   Test Cases for removing
+#
+#   - instance variables
+#
+#   - attributes
+#
+#   - classes
+#
+
+require "maglev_record"
+require "migration/operation_setup"
+require "more_asserts"
+require 'time'
+
+################## remove instance_variable
+
+class TestMigrationRemoveInstanceVariable < Test::Unit::TestCase
+
+  def setup
+    setup_migration_operations
+    Lecture.fill_with_examples
+  end
+
+  def migration1
+    MaglevRecord::Migration.new(Time.now, "remove instance variable") do
+      def up
+        Lecture.delete_instance_variable(:@lecturer)
+      end
+    end
+  end
+
+  def test_instance_variable_is_removed
+    migration1.do
+    assert_not Lecture.first.instance_variable_defined?(:@lecturer)
+    assert_nil Lecture.first.instance_variable_get(:@lecturer)
+  end
+
+  def migration2
+    MaglevRecord::Migration.new(Time.now, "delete instance variable") do
+      def up
+        @lecturers = []
+        Lecture.delete_instance_variable(:@lecturer) {
+          |lecturer|
+          # you could do some garbage collection help here
+          # inthis case we just save the contents of the variable
+          # to prove the block is called with the right argument
+          @lecturers << lecturer
+        }
+      end
+      def lecturers
+        @lecturers
+      end
+    end
+  end
+
+  def test_instance_variable_is_removed_with_block
+    migration2.do
+    assert_not Lecture.first.instance_variable_defined?(:@lecturer)
+    assert_nil Lecture.first.instance_variable_get(:@lecturer)
+  end
+
+  def test_block_is_called_with_deleted_content
+    lecturers = Lecture.collect{ |l| l.instance_variable_get(:@lecturer)}
+    migration = migration2
+    migration.do
+    assert_equal lecturers.sort, migration.lecturers.sort
+  end
+
+  def test_first_lecture_has_lecturer
+    assert Lecture.first.instance_variable_defined?(:@lecturer)
+    assert_not_nil Lecture.first.instance_variable_get(:@lecturer)
+  end
+
+end
+
+################## remove attribute
+
+class TestMigrationRemoveAttribute < Test::Unit::TestCase
+
+  def setup
+    setup_migration_operations
+    Lecture2.fill_with_examples
+  end
+
+  def migration1
+    MaglevRecord::Migration.new(Time.now, "remove attribute") do
+      def up
+        Lecture2.delete_attribute(:lecturer)
+      end
+    end
+  end
+
+  def test_attribute_is_removed
+    migration1.do
+    assert_nil Lecture2.first.lecturer
+  end
+
+  def migration2
+    MaglevRecord::Migration.new(Time.now, "remove attribute lecturer") do
+      def up
+        @lecturers = []
+        Lecture2.delete_attribute(:lecturer) {
+          |lecturer|
+          # you could do some garbage collection help here
+          # inthis case we just save the contents of the variable
+          # to prodo some garbage collection help
+          @lecturers << lecturer
+        }
+      end
+      def lecturers
+        @lecturers
+      end
+    end
+  end
+
+  def test_attribute_is_removed_with_block
+    migration2.do
+    assert_nil Lecture2.first.lecturer
+  end
+
+  def test_block_is_called_with_deleted_content
+    lecturers = Lecture2.collect{ |l| l.lecturer }
+    migration = migration2
+    migration.do
+    assert_equal lecturers.sort, migration.lecturers.sort
+  end
+
+  def test_first_lecture_has_lecturer
+    assert_not_nil Lecture2.first.lecturer
+  end
+
+end
+
+################## remove classes
+
+class TestMigrationRemoveClass < Test::Unit::TestCase
+
+  def setup
+    setup_migration_operations
+  end
+
+  def migration1
+    MaglevRecord::Migration.new(Time.now, "remove class Lecture") do
+      def up
+        delete_class(Lecture)
+      end
+    end
+  end
+
+  def test_class_is_not_present_after_deletion
+    migration1.do
+    assert_raise(NameError) {
+      Lecture
+    }
+  end
+
+  def test_objects_are_not_referenced_by_object_pool_after_deletion
+    object_pool = Lecture.object_pool
+    migration1.do
+    assert object_pool.empty?
+  end
+
+  def migration2
+    MaglevRecord::Migration.new(Time.now, "remove class Lecture") do
+      def up
+        @lectures = []
+        delete_class(Lecture) {
+          |lecture|
+          @lectures << lecture
+        }
+      end
+      def lectures
+        @lectures
+      end
+    end
+  end
+
+  def test_block_yields_all_instances_of_lecture
+    migration = migration2
+    instances = Lecture.all
+    migration.do
+    assert_equal instances.sort, migration.lectures.sort
+  end
+
+  def test_object_pool_is_existent_before_delete
+    pool_dict = Maglev::PERSISTENT_ROOT[MaglevRecord::PERSISTENT_ROOT_KEY]
+    object_pool = Lecture.object_pool
+    assert pool_dict.values.any?{|v| v.equal? object_pool}
+    # this test belongs to test_object_pool_removed_from_pool_dict
+  end
+
+  def test_object_pool_removed_from_pool_dict
+    pool_dict = Maglev::PERSISTENT_ROOT[MaglevRecord::PERSISTENT_ROOT_KEY]
+    object_pool = Lecture.object_pool
+    migration1.do
+    assert_not pool_dict.values.any?{|v| v.equal? object_pool}
+  end
+
+  def migration_remove_nested_class
+    MaglevRecord::Migration.new(Time.now, "remove class Lecture") do
+      def up
+        delete_class(Models::M1::Lecture)
+      end
+    end
+  end
+
+  def test_remove_nested_class
+    Models::M1::Lecture
+    migration_remove_nested_class.do
+    assert_raise(NameError){
+      Models::M1::Lecture
+    }
+  end
+
+ 
+end
+

data/test/migration/test_rename.rb

@@ -0,0 +1,238 @@
+####
+#
+#   Test Cases for renaming
+#
+#   - instance variables
+#
+#   - attributes
+#
+#   - classes
+#
+
+
+
+
+require "maglev_record"
+require "migration/operation_setup"
+require "more_asserts"
+require 'time'
+
+
+################## rename instance variables
+
+class TestMigrationRenameInstanceVariable < Test::Unit::TestCase
+
+  def setup
+    setup_migration_operations
+    Lecture.fill_with_examples
+  end
+
+  def m1
+    MaglevRecord::Migration.new(Time.now, "rename instance variable") do
+      def up
+        Lecture.rename_instance_variable(:@lecturer , :@lecturers) {
+          |lecturer|
+          [lecturer]
+        }
+      end
+    end
+  end
+
+  def test_rename_inst_var_with_block
+    lecturer = Lecture.first.instance_variable_get(:@lecturer)
+    m1.do
+    assert_equal Lecture.first.instance_variable_get(:@lecturers), [lecturer]
+  end
+
+  def test_lecturer_exists
+    assert_not_nil Lecture.first.instance_variable_get(:@lecturer)
+  end
+
+  def m2
+    MaglevRecord::Migration.new(Time.now, "rename instance variable") do
+      def up
+        Lecture.rename_instance_variable(:@users , :@attendees)
+      end
+    end
+  end
+
+  def test_rename_inst_var
+    users = Lecture.first.instance_variable_get(:@users)
+    m2.do
+    assert_equal Lecture.first.instance_variable_get(:@attendees), users
+  end
+
+  def test_users_exists
+    assert_not_nil Lecture.first.instance_variable_get(:@users)
+  end
+
+  def test_old_instance_variable_is_removed_after_renaming
+    m2.do
+    assert_not Lecture.first.instance_variable_defined?(:@users)
+    assert_nil Lecture.first.instance_variable_get(:@users)
+  end
+end
+
+################## rename attributes
+
+
+class TestMigrationRenameAttributes < Test::Unit::TestCase
+
+  def setup
+    setup_migration_operations
+    Lecture2.fill_with_examples
+  end
+
+  def m3
+    MaglevRecord::Migration.new(Time.now, "rename attribute") do
+      def up
+        Lecture2.rename_attribute(:lecturer , :lecturers) {
+          |lecturer|
+          [lecturer]
+        }
+      end
+    end
+  end
+
+  def test_rename_attribute_with_block
+    lecturer = Lecture2.first.lecturer
+    m3.do
+    assert_equal Lecture2.first.lecturers, [lecturer]
+  end
+
+  def test_attr_lecturer_exists
+    assert_not_nil Lecture2.first.lecturer
+  end
+
+  def m4
+    MaglevRecord::Migration.new(Time.now, "rename attribute") do
+      def up
+        Lecture2.rename_attribute(:users , :attendees)
+      end
+    end
+  end
+
+  def test_rename_attribute
+    users = Lecture2.first.users
+    m4.do
+    assert_equal Lecture2.first.attendees, users
+  end
+
+  def test_attr_users_exists
+    assert_not_nil Lecture2.first.users
+    assert_not_equal Lecture2.first.users, []
+  end
+
+end
+
+################## rename classes
+
+class TestMigrationRenameClass < Test::Unit::TestCase
+
+  def setup
+    setup_migration_operations
+    Lecture3.fill_with_examples
+  end
+
+  def migration
+    MaglevRecord::Migration.new(Time.now, "rename attribute") do
+      def up
+        rename_class Lecture3, :Lecture4
+      end
+    end
+  end
+
+  def test_objects_are_in_renamed_class
+    obj = Lecture3.first
+    migration.do
+    assert_equal Lecture4.first, obj
+  end
+
+  def test_class_has_objects
+    assert_not_equal Lecture3.all, []
+  end
+
+  def test_class_with_same_name_as_renamed_class_has_no_objects
+    migration.up
+    redefine_migration_classes
+    assert_equal Lecture3.all, []
+  end
+
+  def test_renamed_class_does_not_exist
+    migration.up
+    assert_raise(NameError) {
+      Lecture3
+    }
+  end
+
+  def test_unrenamed_classes_have_distinct_objects
+    Lecture3.each{ |lecture3|
+      assert_not_include? Lecture4.all, lecture3
+    }
+  end
+
+  def test_objects_are_of_renamed_class
+    assert_equal Lecture3.first.class, Lecture3
+    migration.do
+    assert_equal Lecture4.first.class, Lecture4
+  end
+
+  def test_objects_are_not_of_original_class
+    assert_equal Lecture3.first.class, Lecture3
+    migration.do
+    redefine_migration_classes
+    assert_not_equal Lecture4.first.class, Lecture3
+  end
+
+  def test_migration_changes_class_name
+    migration.do
+    assert_equal Lecture4.first.class.name, "Lecture4"
+  end
+
+end
+
+class TestNestingList < Test::Unit::TestCase
+
+  def setup
+    setup_migration_operations
+  end
+
+  def test_Lecture_is_not_nested
+    assert_equal Lecture.nesting_list, [Object, Lecture]
+  end
+
+  def test_Models_M1_Lecture_lists_submodules_in_nesting_list
+    assert_equal Models::M1::Lecture.nesting_list, [
+                 Object, Models, Models::M1, Models::M1::Lecture]
+  end
+
+  def migration_rename_Lecture4
+    MaglevRecord::Migration.new(Time.now, "rename Lecture") do
+      def up
+        rename_class Lecture4, :Lecture5
+      end
+    end
+  end
+
+  def test_renamed_models_have_different_nesting_list
+    migration_rename_Lecture4.do
+    assert_equal Lecture5.nesting_list, [Object, Lecture5]
+  end
+
+  def migration_rename_nested_Lecture
+    MaglevRecord::Migration.new(Time.now, "rename Lecture") do
+      def up
+        rename_class Models::M1::Lecture, :Lecture3
+      end
+    end
+  end
+
+  def test_nested_renamed_class_has_different_nesting_list
+    migration_rename_nested_Lecture.do
+    assert_equal Models::M1::Lecture3.nesting_list, [
+                 Object, Models, Models::M1, Models::M1::Lecture3 ]
+  end
+
+end
+
+

data/test/migration/test_scenario.rb

@@ -0,0 +1,37 @@
+require "more_asserts"
+require "example_model"
+
+class MigrationScenarioTest < Test::Unit::TestCase
+  Migration = MaglevRecord::Migration
+  MigrationLoader = MaglevRecord::MigrationLoader
+  Migrator = MaglevRecord::Migrator
+
+  attr_reader :loader
+
+  def setup
+    MaglevRecord.reset
+    RootedBook.clear
+    Maglev::PERSISTENT_ROOT[Migrator::MIGRATION_KEY] = Array.new
+    @loader = MigrationLoader.new
+    RootedBook.new(:title => "Harry Potter and the Philosopher's stone")
+    RootedBook.new(:title => "Harry Potter and the Chamber of Secrets")
+    RootedBook.new(:title => "Harry Potter and the Prisoner of Azkaban")
+    MaglevRecord.save
+    loader.load_directory(migration_directory)
+  end
+
+  def migration_directory
+    File.dirname(__FILE__) + '/migrations'
+  end
+
+  def test_migration_loader_loads_correct_number_of_migrations
+    assert_equal 3, loader.migration_list.size
+  end
+
+  def test_migration_loader
+    migration_list = loader.migration_list
+    migrator = Migrator.new(migration_list)
+    migrator.up
+    assert_equal "The most recent book title", RootedBook.first.title
+  end
+end

data/test/migration/todo.txt

@@ -0,0 +1,17 @@
+
+  TODO
+  ====
+
+2) from rooted base to base
+4) copy from one class to another
+5) rename class from submodule
+5) remove class from submodule
+
+  DONE
+  ====
+
+
+
+
+
+

data/test/more_asserts.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'maglev_record'
+
+
+class Test::Unit::TestCase
+
+  def assert_not(bool, message = nil)
+    assert_equal false, bool, message
+  end
+
+  def assert_include?(array, element)
+    assert array.include?(element), "#{array}\n should include \n#{element}"
+  end
+
+  def assert_not_include?(array, element)
+    assert_not array.include?(element), "#{array}\n should include \n#{element}"
+  end
+
+
+  # run once before all tests
+  def self.startup
+  end
+
+  # run once after all tests
+  def self.shutdown
+  end
+
+  class << self
+    alias :old_suite :suite
+
+    def suite
+      mysuite = old_suite
+      #puts "suite: #{mysuite}"
+      def mysuite.run(*args)
+        @tests.first.class.startup() unless @tests.empty?
+        super
+        @tests.first.class.shutdown() unless @tests.empty?
+      end
+      mysuite
+    end
+  end
+
+  #
+  # make the class methods available as instance methods
+  #
+  def self.as_instance_method(*names)
+    names.each{ |name|
+      name = name.to_s
+      self.class_eval "def #{name}(*args); self.class.#{name}(*args);end"
+    }
+  end
+
+end
+
+#  class MyTest < Test::Unit::TestCase
+#    def self.startup
+#      puts 'runs only once at start2'
+#    end
+#    def self.shutdown
+#      puts 'runs only once at end2'
+#    end
+#  end
+

data/test/snapshot/test_snapshot.rb

@@ -0,0 +1,99 @@
+require "maglev_record"
+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