rails_redshift_replicator 0.0.1

data/spec/lib/rails_redshift_replicator/exporters/identity_replicator_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe RailsRedshiftReplicator::Exporters::IdentityReplicator do
+  let(:replicable)    { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: :users) }
+  let(:file_manager)  { RailsRedshiftReplicator::FileManager.new}
+  let(:s3_bucket)     { Aws::S3::Bucket.new(name: RailsRedshiftReplicator.s3_bucket_params[:bucket], client: file_manager.s3_client) }
+  describe "#replication_field", :focus do
+    it "returns the replicable replication_field" do
+      expect(RailsRedshiftReplicator::Exporters::IdentityReplicator.new(replicable).replication_field).to eq 'id'
+    end
+  end
+  describe 'Integration Test' do
+    before(:all) { recreate_users_table }
+    it "exports identity replicator type replication" do
+      model = :user
+      # first export
+      instance = create model
+      RailsRedshiftReplicator::Exporters::IdentityReplicator.new(replicable).export_and_upload
+      replication1 = RailsRedshiftReplicator::Replication.from_table(model.to_s.pluralize).last
+      expect(replication1.state).to eq "uploaded"
+      expect(replication1.record_count).to eq 1
+      file_body = s3_bucket.object("#{replication1.key}.aa").get.body.read
+      expect(file_body).to match(/#{instance.id},#{instance.login},#{instance.age}/)
+      # export without new records
+      RailsRedshiftReplicator::Exporters::IdentityReplicator.new(replicable).export_and_upload
+      expect(RailsRedshiftReplicator::Replication.from_table(model.to_s.pluralize).last).to eq replication1
+      replication1.imported!
+      # export after creating new records
+      3.times {create model}
+      RailsRedshiftReplicator::Exporters::IdentityReplicator.new(replicable).export_and_upload
+      replication2 = RailsRedshiftReplicator::Replication.from_table(model.to_s.pluralize).last
+      expect(replication2.record_count).to eq 3
+      replication2.imported!
+      # export after updating first record
+      instance.touch
+      RailsRedshiftReplicator::Exporters::IdentityReplicator.new(replicable).export_and_upload
+      expect(RailsRedshiftReplicator::Replication.from_table(model.to_s.pluralize).last).to eq replication2
+    end
+  end
+end

data/spec/lib/rails_redshift_replicator/exporters/timed_replicator_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe RailsRedshiftReplicator::Exporters::TimedReplicator do
+  let(:file_manager)  { RailsRedshiftReplicator::FileManager.new}
+  let(:replicable)    { RailsRedshiftReplicator::Replicable.new(:full_replicator, source_table: :tags_users) }
+  let(:s3_bucket)     { Aws::S3::Bucket.new(name: RailsRedshiftReplicator.s3_bucket_params[:bucket], client: file_manager.s3_client) }
+  let(:replicable)    { RailsRedshiftReplicator::Replicable.new(:timed_replicator, source_table: :posts) }
+  describe "#replication_field", :focus do
+    it "returns the replicable replication_field" do
+      expect(RailsRedshiftReplicator::Exporters::TimedReplicator.new(replicable).replication_field).to eq 'updated_at'
+    end
+  end
+  describe 'Integration Test' do
+    before(:all) { recreate_posts_table }
+    it "exports timed replicator type replication" do
+      model = :post
+      # first export
+      instance = create model
+      RailsRedshiftReplicator::Exporters::TimedReplicator.new(replicable).export_and_upload
+      replication1 = RailsRedshiftReplicator::Replication.from_table(model.to_s.pluralize).last
+      expect(replication1.state).to eq "uploaded"
+      expect(replication1.record_count).to eq 1
+      file_body = s3_bucket.object("#{replication1.key}.aa").get.body.read
+      # file_body = RailsRedshiftReplicator::Exporters::Base.replication_bucket.files.get("#{replication1.key}.aa").body
+      expect(file_body).to match(/#{instance.id},#{instance.user_id},#{instance.content}/)
+      # export without new records
+      RailsRedshiftReplicator::Exporters::TimedReplicator.new(replicable).export_and_upload
+      expect(RailsRedshiftReplicator::Replication.from_table(model.to_s.pluralize).last).to eq replication1
+      replication1.imported!
+      # export after creating new records
+      3.times {create model}
+      RailsRedshiftReplicator::Exporters::TimedReplicator.new(replicable).export_and_upload
+      replication2 = RailsRedshiftReplicator::Replication.from_table(model.to_s.pluralize).last
+      expect(replication2.record_count).to eq 3
+      replication2.imported!
+      # export after updating first record
+      instance.touch
+      RailsRedshiftReplicator::Exporters::TimedReplicator.new(replicable).export_and_upload
+      replication3 = RailsRedshiftReplicator::Replication.from_table(model.to_s.pluralize).last
+      expect(replication3.record_count).to eq 1
+    end
+  end
+end

data/spec/lib/rails_redshift_replicator/file_manager_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe RailsRedshiftReplicator::FileManager do
+  let(:user_replicable)  { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: :users)}
+  let(:replication)      { build :redshift_replication, slices: 4 }
+  let(:user_exporter)    { RailsRedshiftReplicator::Exporters::IdentityReplicator.new(user_replicable, replication) }
+  let(:file_manager)     { RailsRedshiftReplicator::FileManager.new(user_exporter)}
+
+  describe ".s3_file_key" do
+    it "returns s3 handler for file" do
+      expect(RailsRedshiftReplicator::FileManager.s3_file_key("users","file.csv")).to eq "rrr/users/file.csv"
+    end
+  end
+
+  describe "#s3_client" do
+    it "returns connection to s3" do
+      expect(file_manager.s3_client).to be_a Aws::S3::Client
+    end
+  end
+
+
+  describe "#row_count_threshold" do
+    before { user_exporter.replication = build :redshift_replication, slices: 3 }
+    it "returns number of lines to split export files" do
+      expect(file_manager.row_count_threshold(200)).to eq 67
+    end
+  end
+
+  describe "#write_csv" do
+  end
+
+  describe "#split_file" do
+    before do
+      allow(file_manager).to receive(:local_file).and_return "/tmp/test"
+    end
+
+    it "splits file in 4 parts" do
+      f = File.open("/tmp/test", "w")
+      100.times{ f.puts "nothing here" }
+      f.close
+      file_manager.split_file("test", 4)
+      %w(aa ab ac ad).each do |suffix|
+        File.exists?("/tmp/test.#{suffix}").should be true
+      end
+    end
+  end
+
+  describe "#file_key_in_format" do
+    context "with csv format" do
+      let(:file) { file_manager.file_key_in_format("file.csv", "csv") }
+      it "returns file handler on s3" do
+        expect(file).to eq "rrr/users/file.csv"
+      end
+    end
+    context "with gzip format" do
+      let(:file) { file_manager.file_key_in_format("file.csv", "gzip") }
+      it "returns file handler on s3" do
+        expect(file).to eq "rrr/users/file.gz"
+      end
+    end
+
+  end
+
+  describe "#gzipped" do
+    it "returns gz file extension" do
+      expect(file_manager.gzipped("file.csv")).to eq "file.gz"
+    end
+  end
+
+  describe "#upload_csv", focus: true do
+    let(:bucket) { RailsRedshiftReplicator.s3_bucket_params[:bucket]}
+    let(:s3_bucket) { Aws::S3::Bucket.new(name: bucket, client: file_manager.s3_client) }
+    let(:file_names) { ["file", "file.aa", "file.ab"] }
+    let!(:files) { file_names.map{ |f| File.open("/tmp/#{f}", "w") } }
+    before { user_exporter.replication = build(:redshift_replication, key: "file") }
+    it "uploads the splitted files" do
+      file_manager.upload_csv(files.map(&:path))
+      expect(s3_bucket.object('rrr/users/file').exists?).to be false
+      expect(s3_bucket.object('rrr/users/file.aa').exists?).to be true
+      expect(s3_bucket.object('rrr/users/file.ab').exists?).to be true
+    end
+
+    it "deletes local files afterwards" do
+      file_manager.upload_csv(files.map(&:path))
+      file_names.each do |file|
+        expect(File.exists?("/tmp/#{file}")).to be false
+      end
+    end
+  end
+end

data/spec/lib/rails_redshift_replicator/importers/base_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe RailsRedshiftReplicator::Importers::Base do
+  let(:replication) { build :redshift_replication, target_table: "users", key: 'rrr/users/users_1.csv.0'}
+  let(:importer) { RailsRedshiftReplicator::Importers::IdentityReplicator.new(replication) }
+
+  describe '#evaluate_history_cap' do
+    before { 10.times {create :redshift_replication, source_table: 'users'} }
+    let!(:keep1) { create :redshift_replication, source_table: 'users' }
+    let!(:keep2) { create :redshift_replication, source_table: 'users' }
+    let!(:keep3) { create :redshift_replication, source_table: 'users' }
+    before { RailsRedshiftReplicator.history_cap = 3 }
+    it 'keeps only the records allowed by the history cap' do
+      importer.evaluate_history_cap
+      expect(RailsRedshiftReplicator::Replication.where(source_table: 'users')).to contain_exactly(keep1, keep2, keep3)
+    end
+  end
+  describe "#copy" do
+    let(:exporter) { user_exporter }
+    before(:all) do
+      recreate_users_table
+      file_manager = RailsRedshiftReplicator::FileManager.new
+      # exporter = RailsRedshiftReplicator::Exporters::Base
+      file_manager.s3_client.put_object key: RailsRedshiftReplicator::FileManager.s3_file_key('users','valid_user.csv'), body: replication_file("valid_user.csv"), bucket: RailsRedshiftReplicator.s3_bucket_params[:bucket]
+      file_manager.s3_client.put_object key: RailsRedshiftReplicator::FileManager.s3_file_key('users','invalid_user.csv'), body: replication_file("invalid_user.csv"), bucket: RailsRedshiftReplicator.s3_bucket_params[:bucket]
+      # exporter.replication_bucket.files.create key: exporter.s3_file_key('users','invalid_user.csv'), body: replication_file("invalid_user.csv")
+    end
+    context "with valid file" do
+      before { importer.replication.key = RailsRedshiftReplicator::FileManager.s3_file_key('users','valid_user.csv')}
+      context "when flag as imported option is set to true" do
+        let(:options) { {mark_as_imported: true} }
+        it "flags as imported" do
+          expect{ importer.copy(importer.replication.target_table, options) }.to change(importer.replication, :state).to("imported")
+        end
+      end
+      context "when option to flag as imported is false" do
+        let(:options) { {mark_as_imported: false} }
+        it "doesn't flag as imported" do
+          expect{importer.copy(importer.replication.target_table, options)}.not_to change(importer.replication, :state)
+        end
+      end
+    end
+    context "with invalid file" do
+      let(:options) { {mark_as_imported: true} }
+      before { importer.replication.key = RailsRedshiftReplicator::FileManager.s3_file_key('users','invalid_user.csv')}
+      it "finds error on redshift" do
+        expect(importer).to receive(:get_redshift_error)
+        importer.copy(importer.replication.target_table, options)
+      end
+      it "notifies error" do
+        expect(importer).to receive(:notify_error)
+        importer.copy(importer.replication.target_table, options)
+      end
+      it "doesn't drop target table on error by default" do
+        expect(importer).not_to receive(:drop_table)
+        importer.copy(importer.replication.target_table, options)
+      end
+      context 'when can drop temporary table on error' do
+        let(:options) { {mark_as_imported: true, can_drop_target_on_error: true} }
+        it 'drops table' do
+          expect(importer).to receive(:drop_table)
+          importer.copy(importer.replication.target_table, options)
+        end
+      end
+    end
+  end
+
+  describe "#import_file" do
+    it "returns s3 location for file" do
+      expect(importer.import_file).to eq('s3://rrr-s3-test/rrr/users/users_1.csv.0')
+    end
+  end
+
+  describe "#copy_statement" do
+    before do
+      allow(importer).to receive(:import_file).and_return('users')
+      allow(RailsRedshiftReplicator).to receive(:aws_credentials).and_return({key: 1, secret: 2})
+    end
+    let(:statement) { "COPY users from 'users' REGION 'us-east-1' credentials 'aws_access_key_id=1;aws_secret_access_key=2' maxerror 0 acceptinvchars STATUPDATE true CSV"}
+    it "returns sql to execute COPY" do
+      expect(importer.copy_statement("users")).to eq(statement)
+    end
+  end
+
+  describe "#drop_table" do
+    let(:sql) { "drop table if exists table_name" }
+    it "drops the temporary table created for the replication" do
+      expect(RailsRedshiftReplicator.connection).to receive(:exec).with(sql).once
+      importer.drop_table("table_name")
+    end
+  end
+
+  describe "#temporary_table_name" do
+    it "returns a random name for the temporary table" do
+      Timecop.freeze do
+        now = Time.now.to_i
+        expect(importer.temporary_table_name).to eq("temp_users_#{now}")
+      end
+    end
+  end
+
+end

data/spec/lib/rails_redshift_replicator/importers/full_replicator_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'RailsRedshiftReplicator::Importers::FullReplicator' do
+  let(:exporter) { RailsRedshiftReplicator::Exporters::Base  }
+  let(:file_manager) { RailsRedshiftReplicator::FileManager.new }
+  describe "import" do
+    before(:all) { recreate_tags_users_table }
+    let!(:replication) do
+      create :redshift_replication,
+             target_table: 'tags_users',
+             key: RailsRedshiftReplicator::FileManager.s3_file_key('tags_users','valid_tags_users.csv'),
+             state: 'uploaded',
+             replication_type: 'FullReplicator',
+             export_format: 'csv'
+    end
+    let(:full_importer) { RailsRedshiftReplicator::Importers::FullReplicator.new(replication) }
+    before do
+      file_manager.s3_client.put_object key: RailsRedshiftReplicator::FileManager.s3_file_key('tags_users','valid_tags_users.csv'),
+        body: replication_file("valid_tags_users.csv"),
+        bucket: RailsRedshiftReplicator.s3_bucket_params[:bucket]
+    end
+    it "performs import" do
+      expect { full_importer.import; replication.reload }.to change(replication, :state).from("uploaded").to("imported")
+    end
+  end
+end
+

data/spec/lib/rails_redshift_replicator/importers/identity_replicator_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe 'RailsRedshiftReplicator::Importers::IdentityReplicator' do
+  let(:exporter) { RailsRedshiftReplicator::Exporters::Base  }
+  let(:file_manager) { RailsRedshiftReplicator::FileManager.new }
+  describe "import" do
+    before(:all) { recreate_users_table }
+    let!(:replication) do
+      create :redshift_replication,
+             target_table: 'users',
+             key: RailsRedshiftReplicator::FileManager.s3_file_key('users','valid_user.csv'),
+             state: 'uploaded',
+             replication_type: 'IdentityReplicator',
+             export_format: 'csv'
+    end
+    let(:user_importer)    { RailsRedshiftReplicator::Importers::IdentityReplicator.new(replication) }
+    before do
+      file_manager.s3_client.put_object key: RailsRedshiftReplicator::FileManager.s3_file_key('users','valid_user.csv'),
+        body: replication_file("valid_user.csv"),
+        bucket: RailsRedshiftReplicator.s3_bucket_params[:bucket]
+    end
+    it "performs import" do
+      expect { user_importer.import; replication.reload }.to change(replication, :state).from("uploaded").to("imported")
+    end
+  end
+end

data/spec/lib/rails_redshift_replicator/importers/timed_replicator_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe 'RailsRedshiftReplicator::Importers::TimedReplicator' do
+  let(:exporter) { RailsRedshiftReplicator::Exporters::Base  }
+  let(:file_manager) { RailsRedshiftReplicator::FileManager.new }
+  describe "import" do
+    before(:all) { recreate_posts_table }
+    let!(:replication) do
+      create :redshift_replication,
+             target_table: 'posts',
+             key: RailsRedshiftReplicator::FileManager.s3_file_key('posts','valid_post.csv'),
+             state: 'uploaded',
+             replication_type: 'TimedReplicator',
+             export_format: 'csv'
+    end
+    let(:post_importer) { RailsRedshiftReplicator::Importers::TimedReplicator.new(replication) }
+    before do
+      file_manager.s3_client.put_object key: RailsRedshiftReplicator::FileManager.s3_file_key('posts','valid_post.csv'),
+        body: replication_file("valid_post.csv"),
+        bucket: RailsRedshiftReplicator.s3_bucket_params[:bucket]
+    end
+    it "performs import" do
+      expect { post_importer.import; replication.reload }.to change(replication, :state).from("uploaded").to("imported")
+    end
+  end
+end

data/spec/lib/rails_redshift_replicator/model/extension_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe RailsRedshiftReplicator::Model::Extension do
+  before { RailsRedshiftReplicator.debug_mode = true }
+
+  describe '.export', focus: true do
+    it 'forwards the command to its replicable class' do
+      expect(RailsRedshiftReplicator.replicables['users']).to receive(:export)
+      User.rrr_export
+    end
+  end
+  describe '.import', focus: true do
+    it 'forwards the command to its replicable class' do
+      expect(RailsRedshiftReplicator.replicables['users']).to receive(:import)
+      User.rrr_import
+    end
+  end
+  describe '.replicate', focus: true do
+    it 'forwards the command to its replicable class' do
+      expect(RailsRedshiftReplicator.replicables['users']).to receive(:replicate)
+      User.rrr_replicate
+    end
+  end
+  describe '.vacuum', focus: true do
+    it 'forwards the command to its replicable class' do
+      expect(RailsRedshiftReplicator.replicables['users']).to receive(:vacuum)
+      User.rrr_vacuum
+    end
+  end
+  describe '.analyze', focus: true do
+    it 'forwards the command to its replicable class' do
+      expect(RailsRedshiftReplicator.replicables['users']).to receive(:analyze)
+      User.rrr_analyze
+    end
+  end
+end

data/spec/lib/rails_redshift_replicator/replicable_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+describe RailsRedshiftReplicator::Replicable do
+  
+  describe 'initialization' do
+    context 'when all options are given' do
+      let(:replicable) { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: 'users', target_table: 'custom_users', replication_field: 'created_at') }  
+      it 'has the right properties' do
+        expect(replicable.source_table).to eq 'users'
+        expect(replicable.target_table).to eq 'custom_users'
+        expect(replicable.replication_field).to eq 'created_at'
+        expect(replicable.replication_type).to eq :identity_replicator
+      end
+    end
+    context 'with default options(idendity)' do
+      let(:replicable) { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: 'users') }  
+      it 'has the right properties' do
+        expect(replicable.source_table).to eq 'users'
+        expect(replicable.target_table).to eq 'users'
+        expect(replicable.replication_field).to eq 'id'
+        expect(replicable.replication_type).to eq :identity_replicator
+      end
+    end
+    context 'with default options(timed)' do
+      let(:replicable) { RailsRedshiftReplicator::Replicable.new(:timed_replicator, source_table: 'users') }  
+      it 'has the right properties' do
+        expect(replicable.source_table).to eq 'users'
+        expect(replicable.target_table).to eq 'users'
+        expect(replicable.replication_field).to eq 'updated_at'
+        expect(replicable.replication_type).to eq :timed_replicator
+      end
+    end
+    context 'with default options(full)' do
+      let(:replicable) { RailsRedshiftReplicator::Replicable.new(:full_replicator, source_table: 'users') }  
+      it 'has the right properties' do
+        expect(replicable.source_table).to eq 'users'
+        expect(replicable.target_table).to eq 'users'
+        expect(replicable.replication_field).to be_nil
+        expect(replicable.replication_type).to eq :full_replicator
+      end
+    end
+  end
+
+  describe '#exporter_class' do
+    context 'when exists' do
+      let(:replicable) { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: 'users') }  
+      it 'returns exporter class' do
+        expect(replicable.exporter_class).to eq RailsRedshiftReplicator::Exporters::IdentityReplicator
+      end
+    end
+    context "when doesn't exist" do
+      let(:replicable) { RailsRedshiftReplicator::Replicable.new(:none, source_table: 'users') }  
+      it 'raises error' do
+        expect{replicable.exporter_class}.to raise_error(StandardError)
+      end
+    end
+  end
+  describe '#importer_class' do
+    context 'when exists' do
+      let(:replicable) { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: 'users') }  
+      it 'returns exporter class' do
+        expect(replicable.importer_class).to eq RailsRedshiftReplicator::Importers::IdentityReplicator
+      end
+    end
+    context "when doesn't exist" do
+      let(:replicable) { RailsRedshiftReplicator::Replicable.new(:none, source_table: 'users') }  
+      it 'raises error' do
+        expect{replicable.importer_class}.to raise_error(StandardError)
+      end
+    end
+  end
+
+  describe '#export' do
+    let(:replicable) { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: 'users') }  
+    context 'without previous replications' do
+      it 'calls the correspondent exporter class' do
+        allow(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive_message_chain(:new, :export_and_upload)
+        expect(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive(:new).with(replicable, nil)
+        replicable.export
+      end
+    end
+    context 'with previous imported replication' do
+      let!(:previous_replication) { create :redshift_replication, source_table: 'users', replication_type: 'identity_replicator', state: 'imported'}
+      it 'calls the correspondent exporter class' do
+        allow(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive_message_chain(:new, :export_and_upload)
+        expect(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive(:new).with(replicable, nil)
+        replicable.export
+      end
+    end
+    context 'with previous uploading replication' do
+      let!(:previous_replication) { create :redshift_replication, source_table: 'users', replication_type: 'identity_replicator', state: 'uploading' }
+      context 'and max_retries is defined' do
+        before { RailsRedshiftReplicator.max_retries = 0 }
+        context 'and max_retries was reached' do
+          it 'calls the correspondent exporter class without the previous replication' do
+            allow(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive_message_chain(:new, :export_and_upload)
+            expect(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive(:new).with(replicable, nil)
+            replicable.export
+          end
+          it 'cancels the previous replication' do
+            allow(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive_message_chain(:new, :export_and_upload)
+            replicable.export
+            expect(previous_replication.reload).to be_canceled
+          end
+        end
+        context "and max_retries wasn't reached" do
+          before { RailsRedshiftReplicator.max_retries = 1 }
+          it 'calls the correspondent exporter class with previous replication' do
+            allow(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive_message_chain(:new, :export_and_upload)
+            expect(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive(:new).with(replicable, previous_replication)
+            replicable.export
+          end
+        end
+      end
+      context 'and max_retries is nil' do
+        before { RailsRedshiftReplicator.max_retries = nil }
+        it 'calls the correspondent exporter class with previous replication' do
+          allow(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive_message_chain(:new, :export_and_upload)
+          expect(RailsRedshiftReplicator::Exporters::IdentityReplicator).to receive(:new).with(replicable, previous_replication)
+          replicable.export
+        end
+      end
+
+    end
+    context 'with previous importing replication' do
+      before { RailsRedshiftReplicator.max_retries = nil }
+      let!(:previous_replication) { create :redshift_replication, source_table: 'users', replication_type: 'identity_replicator', state: 'importing' }
+      it 'calls the correspondent importer class' do
+        allow(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive_message_chain(:new, :import)
+        expect(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive(:new).with(previous_replication)
+        replicable.export
+      end
+    end
+  end
+
+  describe 'import' do
+    let(:replicable)    { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: 'users') }  
+    let!(:replication1) { create :redshift_replication, source_table: 'users', state: 'imported' }
+    let!(:replication2) { create :redshift_replication, source_table: 'posts' }
+    context 'without last replication' do
+      it 'does not call import' do
+        allow(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive_message_chain(:new, :import)
+        expect(RailsRedshiftReplicator::Importers::IdentityReplicator).not_to receive(:new)
+        replicable.import
+      end
+    end
+    context 'with last replication' do
+      context 'and last replication is uploaded' do
+        let!(:replication)  { create :redshift_replication, source_table: 'users', state: 'uploaded' }
+        it 'calls import with the last uploaded replication' do
+          allow(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive_message_chain(:new, :import)
+          expect(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive(:new).with(replication)
+          replicable.import
+        end
+      end
+      context 'and last replication is imported' do
+        it 'does not call import' do
+          allow(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive_message_chain(:new, :import)
+          expect(RailsRedshiftReplicator::Importers::IdentityReplicator).not_to receive(:new)
+          replicable.import
+        end
+      end
+      context 'and last replication is importing' do
+        let!(:replication)  { create :redshift_replication, source_table: 'users', state: 'importing' }
+        context 'and max_retries is not set' do
+          before { RailsRedshiftReplicator.max_retries = nil }
+          it 'calls the correspondent importer class resuming the replication' do
+            allow(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive_message_chain(:new, :import)
+            expect(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive(:new).with(replication)
+            replicable.import
+          end
+        end
+        context 'and max_retries is set' do
+          context "but wasn't reached" do
+            before { RailsRedshiftReplicator.max_retries = 2 }
+            it 'calls the correspondent importer class resuming the replication' do
+              allow(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive_message_chain(:new, :import)
+              expect(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive(:new).with(replication)
+              replicable.import
+            end
+          end
+          context 'and was reached' do
+            before { RailsRedshiftReplicator.max_retries = 0 }
+            it 'calls the correspondent importer class resuming the replication' do
+              allow(RailsRedshiftReplicator::Importers::IdentityReplicator).to receive_message_chain(:new, :import)
+              expect(RailsRedshiftReplicator::Importers::IdentityReplicator).not_to receive(:new).with(replication)
+              replicable.import
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#reset_last_record' do
+    let(:replicable) { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: 'users') }  
+    context 'when there is no previous imported replications' do
+      it 'does not try to update' do
+        expect_any_instance_of(RailsRedshiftReplicator::Replication).not_to receive(:update_attribute)
+        replicable.reset_last_record
+      end
+    end
+    context 'when there is a previous imported replication' do
+      let!(:replication) { create :redshift_replication, source_table: 'users', state:'imported', last_record: '2' }
+      it 'resets most recent imported replication last record to perform full replication afterwards' do
+        replicable.reset_last_record
+        expect(replication.reload.last_record).to be_nil
+      end
+    end
+
+  end
+
+  describe '#vacuum' do
+    let(:replicable) { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: 'users', target_table: 'custom_users') }  
+    it 'calls the central vacuum method' do
+      expect(RailsRedshiftReplicator).to receive(:vacuum).with('custom_users')
+      replicable.vacuum
+    end
+  end
+
+  describe '#analyze' do
+    let(:replicable) { RailsRedshiftReplicator::Replicable.new(:identity_replicator, source_table: 'users', target_table: 'custom_users') }  
+    it 'calls the central vacuum method' do
+      expect(RailsRedshiftReplicator).to receive(:analyze).with('custom_users')
+      replicable.analyze
+    end
+  end
+
+
+
+end