mince_migrator 0.0.1 → 1.0.0

data/spec/units/mince_migrator/migration_spec.rb

@@ -0,0 +1,119 @@
+require_relative '../../../lib/mince_migrator/migration'
+
+require 'time'
+
+describe MinceMigrator::Migration do
+  subject { described_class.new(options) }
+
+  let(:options) { { klass: klass, name: name, relative_path: relative_path, path: path } }
+  let(:klass) { mock time_created: Time.now.utc - 550000 }
+  let(:name) { "name_of_migration" }
+  let(:relative_path) { mock }
+  let(:path) { mock }
+
+  its(:time_created) { should == klass.time_created }
+  its(:relative_path) { should == relative_path }
+  its(:path) { should == path }
+  its(:age) { should == '6d' }
+
+  it 'can run the migration' do
+    return_value = mock
+    klass.should_receive(:run).and_return(return_value)
+    subject.run.should == return_value
+  end
+
+  it 'can revert the migration' do
+    return_value = mock
+    klass.should_receive(:revert).and_return(return_value)
+    subject.revert.should == return_value
+  end
+
+  context 'when there is a record of the migration being ran' do
+    let(:ran_migration) { mock }
+
+    before do
+      MinceMigrator::RanMigration.stub(:find_by_name).with(subject.name).and_return(ran_migration)
+    end
+
+    its(:ran?) { should be_true }
+    its(:status) { should == 'ran' }
+  end
+
+  context 'when there is not a record of the migration being ran' do
+   before do
+      MinceMigrator::RanMigration.stub(:find_by_name).with(subject.name).and_return(nil)
+    end
+
+    its(:ran?) { should be_false }
+  end
+end
+
+describe MinceMigrator::Migration, 'class methods:' do
+  describe 'Loading from a file' do
+    subject { described_class.load_from_file(path_to_file) }
+
+    let(:path_to_file) { mock }
+    let(:migration_file) { mock klass: mock, name: mock, full_relative_path: mock, full_path: mock }
+    let(:migration) { mock }
+
+    before do
+      described_class.stub(:new).with(klass: migration_file.klass, name: migration_file.name, relative_path: migration_file.full_relative_path, path: migration_file.full_path).and_return(migration)
+      MinceMigrator::Migrations::File.stub(:load_from_file).with(path_to_file).and_return(migration_file)
+    end
+
+    it 'returns a migration for the given migration file' do
+      subject.should == migration
+    end
+
+    it 'loads the migration file into memory' do
+      MinceMigrator::Migrations::File.should_receive(:load_from_file).with(path_to_file).and_return(migration_file)
+     
+      subject
+    end
+  end
+
+  describe 'Finding a migration for a given name' do
+    subject { described_class.find(name) }
+
+    let(:name) { mock }
+
+    context 'when the migration exists' do
+      let(:migration) { mock }
+      let(:migration_file) { mock }
+
+      before do
+        MinceMigrator::Migrations::File.stub(:find).with(name).and_return(migration_file)
+        MinceMigrator::Migration.stub(:new_from_file).with(migration_file).and_return(migration)
+      end
+
+      it 'returns the migration' do
+        subject.should == migration
+      end
+    end
+
+    context 'when the migration does not exist' do
+      before do
+        MinceMigrator::Migrations::File.stub(:find).with(name).and_return(nil)
+      end
+
+      it 'returns nothing' do
+        subject.should be_nil
+      end
+    end
+  end
+
+  describe 'initializing with a migration file' do
+    subject { described_class.new_from_file(file) }
+
+    let(:file) { mock klass: mock, name: mock, full_relative_path: mock, full_path: mock }
+    let(:migration) { mock }
+
+    before do
+      described_class.stub(:new).with(klass: file.klass, name: file.name, relative_path: file.full_relative_path, path: file.full_path).and_return(migration)
+    end
+
+    it 'returns the migration' do
+      subject.should == migration
+    end
+  end
+end

data/spec/units/mince_migrator/migrations/file_spec.rb

@@ -0,0 +1,85 @@
+require_relative '../../../../lib/mince_migrator/migrations/file'
+
+describe MinceMigrator::Migrations::File do
+  subject { described_class.new(name) }
+
+  let(:expected_class_name) { 'ChangeSpacesToUnderscores' }
+  let(:name) { "Change spaces to underscores" }
+  let(:migration_template) { mock render: mock }
+  let(:config) { MinceMigrator::Config }
+  let(:loader) { mock klass: mock, load: nil }
+
+  before do
+    MinceMigrator::Migrations::Template.stub(:new).with(expected_class_name).and_return(migration_template)
+    File.stub(:exists?).with(subject.full_path).and_return(false)
+    MinceMigrator::Migrations::Loader.stub(:new).with(full_path: subject.full_path, klass_name: subject.klass_name).and_return(loader)
+  end
+
+  its(:name) { should == "change_spaces_to_underscores" }
+  its(:filename) { should == "#{subject.name}.rb" }
+  its(:full_path) { should == File.join(config.migration_dir, subject.filename) }
+  its(:full_relative_path) { should == File.join(config.migration_relative_dir, subject.filename) }
+  its(:body) { should == migration_template.render }
+  its(:klass) { should == loader.klass }
+
+  it 'can load the migration file' do
+    loader.should_receive(:call)
+
+    subject.load
+  end
+
+  context 'when it has been written to the file system' do
+    before do
+      ::File.stub(:exists?).with(subject.full_path).and_return(true)
+    end
+
+    its(:persisted?) { should be_true }
+  end
+
+  context 'when it has not been written to the file system' do
+    before do
+      ::File.stub(:exists?).with(subject.full_path).and_return(false)
+    end
+
+    its(:persisted?) { should be_false }
+  end
+end
+
+describe MinceMigrator::Migrations::File, 'Class methods:' do
+  describe 'finding a file' do
+    subject { described_class.find(name) }
+
+    let(:name) { mock }
+    let(:file) { mock }
+
+    before do
+      described_class.stub(:new).with(name).and_return(file)
+    end
+
+    context 'when one exists' do
+      before do
+        file.stub(persisted?: true, load: nil)
+      end
+
+      it 'returns the file' do
+        subject.should == file
+      end
+
+      it 'loads the migration class' do
+        file.should_receive(:load)
+
+        subject
+      end
+    end
+
+    context 'when one does not exist' do
+      before do
+        file.stub(persisted?: false)
+      end
+
+      it 'returns nothing' do
+        subject.should be_nil
+      end
+    end
+  end
+end

data/spec/units/mince_migrator/migrations/loader_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../../../../lib/mince_migrator/migrations/loader'
+
+describe MinceMigrator::Migrations::Loader do
+  subject { described_class.new full_path: full_path, klass_name: klass_name }
+
+  context 'when the file exists and is a mince migrator migration file' do
+    let(:full_path) { File.expand_path('../../../../support/test_migration.rb', __FILE__) }
+    let(:klass_name) { 'TestMigration' }
+    let(:expected_klass) { eval "::MinceMigrator::Migrations::#{klass_name}" }
+
+    its(:klass) { should == expected_klass }
+
+    it 'loads the migration into memory' do
+      subject.call
+
+      expected_klass.should == expected_klass
+    end
+  end
+
+  context 'when the file exists but is not a mince migrator migration file' do
+    let(:full_path) { File.expand_path('../../../../support/not_a_migration.rb', __FILE__) }
+    let(:klass_name) { 'Foo' }
+
+    it 'raises an exception' do
+      expect { subject.call }.to raise_exception('invalid migration')
+    end
+  end
+
+  context 'when the file does not exist' do
+    let(:full_path) { File.expand_path('../../../../support/does_not_exist_migration.rb', __FILE__) }
+    let(:klass_name) { 'Foo' }
+
+    it 'raises an exception' do
+      expect { subject.call }.to raise_exception('migration does not exist')
+    end
+  end
+
+  context 'when the migration does not have the required interface' do
+    let(:full_path) { File.expand_path('../../../../support/invalid_interface_migration.rb', __FILE__) }
+    let(:klass_name) { 'InvalidInterfaceMigration' }
+
+    it 'raises an exception' do
+      expect { subject.call }.to raise_exception('migration does not have all required methods (:run, :revert, and :time_created)')
+    end
+  end
+end
+

data/spec/units/mince_migrator/migrations/name_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../../../../lib/mince_migrator/migrations/name'
+
+module MinceMigrator
+  module Migrations
+    describe Name do
+      subject { described_class.new(name) }
+
+      invalid_names = [
+        { in: '!@#$%^&*()', out: '' },
+        { in: nil, out: nil },
+        { in: '', out: '' }
+      ]
+
+      valid_names = [
+        { in: 'name', out: 'Name', filename: 'name.rb' }, 
+        { in: 'name_of_migration', out: 'Name of migration', filename: 'name_of_migration.rb' }, 
+        { in: 'name of migration', out: 'Name of migration', filename: 'name_of_migration.rb' },
+        { in: '1Name Of Migration', out: 'Name of migration', filename: 'name_of_migration.rb' },
+        { in: 'Name Of Migration 1!@#$%^&*()', out: 'Name of migration 1', filename: 'name_of_migration_1.rb' }
+      ]
+
+      valid_names.each do |name_group|
+        context "when the name is '#{name_group[:in]}'" do
+          let(:name) { name_group[:in] }
+
+          its(:value) { should == name_group[:out] }
+          its(:filename) { should == name_group[:filename] }
+          its(:valid?) { should be_true }
+        end
+      end
+
+      invalid_names.each do |name_group|
+        context "when the name is '#{name_group[:in]}'" do
+          let(:name) { name_group[:in] }
+
+          before do
+            subject.valid?
+          end
+
+          its(:value) { should == name_group[:out] }
+          its(:valid?) { should be_false }
+          its(:reasons_for_failure) { should == "Name is invalid, it must start with a character from A-Z or a-z" }
+        end
+      end
+    end
+  end
+end

data/spec/units/mince_migrator/migrations/runner_spec.rb

@@ -0,0 +1,70 @@
+require_relative '../../../../lib/mince_migrator/migrations/runner'
+
+describe MinceMigrator::Migrations::Runner do
+  subject { described_class.new(name: name) }
+
+  let(:name) { mock }
+  let(:validator) { mock }
+
+  before do
+    Mince::Config.interface = mock
+  end
+
+  describe 'initializing with a migration' do
+    subject { described_class.new(migration: migration) }
+
+    let(:migration) { mock name: 'asdf' }
+
+    its(:migration) { should == migration }
+    its(:name) { should == migration.name }
+  end
+
+  context 'when the migration exists' do
+    let(:migration) { mock ran?: false, name: mock }
+
+    before do
+      MinceMigrator::Migrations::RunnerValidator.stub(:new).with(migration).and_return(validator)
+      MinceMigrator::Migration.stub(:find).with(name).and_return(migration)
+      validator.stub(call: true, errors: [])
+    end
+
+    its(:can_run_migration?) { should be_true }
+
+    context 'when it is ran' do
+      before do
+        migration.stub(:run)
+        MinceMigrator::RanMigration.stub(:create)
+      end
+
+      it 'returns true' do
+        subject.run_migration.should be_true
+      end
+
+      it 'runs the migration' do
+        migration.should_receive(:run)
+
+        subject.run_migration
+      end
+
+      it 'stores the record that it has been ran' do
+        MinceMigrator::RanMigration.should_receive(:create).with(name: migration.name)
+
+        subject.run_migration
+      end
+    end
+  end
+
+  context 'when the runner validator has errors' do
+    let(:errors) { [mock] }
+    let(:name) { mock }
+
+    before do
+      MinceMigrator::Migrations::RunnerValidator.stub(:new).with(nil).and_return(validator)
+      validator.stub(call: false, errors: errors)
+      MinceMigrator::Migration.stub(:find).with(name).and_return(nil)
+    end
+
+    its(:can_run_migration?) { should be_false }
+    its(:reasons_for_failure) { should == errors.join(' ') }
+  end
+end

data/spec/units/mince_migrator/migrations/runner_validator_spec.rb

@@ -0,0 +1,46 @@
+require_relative '../../../../lib/mince_migrator/migrations/runner_validator'
+
+describe MinceMigrator::Migrations::RunnerValidator do
+  subject { described_class.new(migration) }
+
+  before do
+    Mince::Config.interface = mock
+  end
+
+  context 'when the migration exists' do
+    let(:migration) { mock }
+
+    context 'when it has already ran' do
+      before do
+        migration.stub(ran?: true)
+        subject.call
+      end
+
+      its(:call) { should be_false }
+      its(:errors) { should == ['Migration has already ran'] }
+    end
+  end
+
+  context 'when the migration does not exist' do
+    let(:migration) { nil }
+
+    before do
+      subject.call
+    end
+
+    its(:call) { should be_false }
+    its(:errors) { should == ['Migration does not exist'] }
+  end
+
+  context 'when the mince interface is not set' do
+    let(:migration) { mock }
+
+    before do
+      Mince::Config.interface = nil
+      subject.call
+    end
+
+    its(:call) { should be_false }
+    its(:errors) { should == ['Mince interface is not set'] }
+  end
+end

data/spec/units/mince_migrator/migrations/template_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../../../../lib/mince_migrator/migrations/template'
+
+describe MinceMigrator::Migrations::Template do
+  subject { described_class.new klass_name }
+
+  let(:klass_name) { 'NameOfMigration' }
+  let(:now) { mock 'time', to_s: "2013-02-23 19:03:27 UTC" }
+
+  before do
+    Time.stub_chain('now.utc' => now)
+  end
+
+  it 'renders the template' do
+    expected_content = <<-eos
+module MinceMigrator
+  module Migrations
+    require 'time'
+
+    module #{klass_name}
+      def self.run
+        # Actual migration goes here
+      end
+
+      def self.revert
+        # In case you need to revert this one migration
+      end
+
+      # So you can change the order to run more easily
+      def self.time_created
+        Time.parse "#{now.to_s}"
+      end
+
+      module Temporary
+        # Migration dependent classes go here
+      end
+    end
+  end
+end
+eos
+    subject.render.should == expected_content
+  end
+end

data/spec/units/mince_migrator/migrations/versioned_file_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../../../../lib/mince_migrator/migrations/versioned_file'
+
+describe MinceMigrator::Migrations::VersionedFile do
+  describe 'Getting the next version of a migration for a given name' do
+    subject { described_class.new(name).next_unused_version }
+
+    let(:migration_file) { mock full_path: mock, persisted?: false }
+    let(:name) { mock }
+
+    context 'when no migrations contain the same name' do
+      before do
+        MinceMigrator::Migrations::File.stub(:new).with(name).and_return(migration_file)
+      end
+
+      it 'returns the migration file' do
+        subject.should == migration_file
+      end
+    end
+
+    context 'when a single migration exists with the same name' do
+      let(:other_migration_file) { mock full_path: mock, persisted?: true }
+
+      before do
+        MinceMigrator::Migrations::File.stub(:new).with(name).and_return(other_migration_file)
+        MinceMigrator::Migrations::File.stub(:new).with("#{name}_2").and_return(migration_file)
+      end
+
+      it 'returns a migration file the second version' do
+        subject.should == migration_file
+      end
+    end
+
+    context 'when multiple migrations exist with the same name' do
+      let(:other_migration_file) { mock full_path: mock, persisted?: true }
+      let(:other_migration_file2) { mock full_path: mock, persisted?: true }
+
+      before do
+        MinceMigrator::Migrations::File.stub(:new).with(name).and_return(other_migration_file)
+        MinceMigrator::Migrations::File.stub(:new).with("#{name}_2").and_return(other_migration_file2)
+        MinceMigrator::Migrations::File.stub(:new).with("#{name}_3").and_return(migration_file)
+      end
+
+      it 'returns a migration file for the first unused version' do
+        subject.should == migration_file
+      end
+    end
+  end
+end

data/spec/units/mince_migrator/ran_migration_spec.rb

@@ -0,0 +1,60 @@
+require_relative '../../../lib/mince_migrator/ran_migration'
+
+describe MinceMigrator::RanMigration do
+  let(:name) { "Name of migration" }
+  
+  subject { described_class.new(name: name) }
+
+  its(:data_model) { should == MinceMigrator::RanMigrationDataModel }
+  its(:fields){ should == [:name] }
+  its(:name) { should == name }
+
+  it 'can be deleted' do
+    described_class.data_model.should_receive(:delete_by_params).with(name: name)
+
+    subject.delete
+  end
+end
+
+describe MinceMigrator::RanMigration, 'Class methods:' do
+  describe 'finding by name' do
+    subject { described_class.find_by_name(name) }
+
+    let(:name) { mock }
+
+    before do
+      described_class.data_model.stub(:find_by_field).with(:name, name).and_return(data)
+    end
+
+    context 'when it exists' do
+      let(:data) { mock }
+      let(:model) { mock }
+
+      before do
+        described_class.stub(:new).with(data).and_return(model)
+      end
+
+      it 'returns the model 'do
+        subject.should == model
+      end
+    end
+
+    context 'when it does not exist 'do
+      let(:data) { nil }
+
+      it 'returns nil' do
+        subject.should be_nil
+      end
+    end
+  end
+end
+
+describe MinceMigrator::RanMigrationDataModel do
+  it 'stores everything in the "migrations" collection' do
+    described_class.data_collection.should == :migrations
+  end
+
+  it 'has the name field' do
+    described_class.data_fields.should == [:name]
+  end
+end

data/spec/units/mince_migrator/reverter_spec.rb

@@ -0,0 +1,78 @@
+require_relative '../../../lib/mince_migrator/reverter'
+
+describe MinceMigrator::Reverter do
+  subject { described_class.new(name: name) }
+
+  let(:name) { mock }
+  let(:migration_name) { mock value: mock }
+
+  before do
+    MinceMigrator::Migrations::Name.stub(:new).with(name).and_return(migration_name)
+  end
+
+  describe 'initializing with a migration' do
+    subject { described_class.new(migration: migration) }
+
+    let(:migration) { mock name: name }
+
+    its(:migration) { should == migration }
+    its(:name) { should == migration_name.value }
+  end
+
+  context 'when the migration does not exist' do
+    before do
+      MinceMigrator::Migration.stub(:find).with(migration_name.value).and_return(nil)
+      subject.can_revert_migration?
+    end
+
+    its(:can_revert_migration?) { should be_false }
+    its(:reasons_for_failure) { should == "Migration does not exist with name '#{migration_name.value}'" }
+  end
+
+  context 'when the migration exists' do
+    let(:migration) { mock name: mock }
+
+    before do
+      MinceMigrator::Migration.stub(:find).with(migration_name.value).and_return(migration)
+    end
+
+    context 'and has been ran' do
+      let(:ran_migration) { mock }
+
+      before do
+        migration.stub(ran?: true, ran_migration: ran_migration)
+        migration.stub(:revert)
+        ran_migration.stub(:delete)
+      end
+
+      its(:can_revert_migration?) { should be_true }
+
+      it 'returns true' do
+        subject.revert_migration.should be_true
+      end
+
+      it 'reverts the migration' do
+        migration.should_receive(:revert)
+
+        subject.revert_migration
+      end
+
+      it 'deletes the ran migration' do
+        ran_migration.should_receive(:delete)
+
+        subject.revert_migration
+      end
+    end
+
+    context 'but has not been ran' do
+      before do
+        migration.stub(ran?: false)
+
+        subject.can_revert_migration?
+      end
+
+      its(:can_revert_migration?) { should be_false }
+      its(:reasons_for_failure) { should == "Migration has not ran" }
+    end
+  end
+end