Move logic to ReferentialCloning. Improve specs. Refs #5283

4 files changed, 100 insertions, 67 deletions

diff --git a/app/models/referential_cloning.rb b/app/models/referential_cloning.rb
index 5bf283814..24117e6c8 100644
--- a/app/models/referential_cloning.rb
+++ b/app/models/referential_cloning.rb
@@ -2,14 +2,27 @@ class ReferentialCloning < ActiveRecord::Base
   include AASM
   belongs_to :source_referential, class_name: 'Referential'
   belongs_to :target_referential, class_name: 'Referential'
-  after_commit :perform_clone, :on => :create
+  after_commit :clone, on: :create
 
-  private
-  def perform_clone
+  def clone
     ReferentialCloningWorker.perform_async(id)
-    # ReferentialCloningWorker.new.perform(id)
   end
 
+  def clone!
+    run!
+
+    AF83::SchemaCloner
+      .new(source_referential.slug, target_referential.slug)
+      .clone_schema
+
+    successful!
+  rescue Exception => e
+    Rails.logger.error "Clone failed : #{e}"
+    failed!
+  end
+
+  private
+
   aasm column: :status do
     state :new, :initial => true
     state :pending
diff --git a/app/workers/referential_cloning_worker.rb b/app/workers/referential_cloning_worker.rb
index 6592160ec..60dc1a4bc 100644
--- a/app/workers/referential_cloning_worker.rb
+++ b/app/workers/referential_cloning_worker.rb
@@ -1,32 +1,9 @@
 class ReferentialCloningWorker
   include Sidekiq::Worker
 
-  # Replace default apartment created schema with clone schema from source referential
   def perform(id)
-    ref_cloning = ReferentialCloning.find id
-
-    source_schema = ref_cloning.source_referential.slug
-    target_schema = ref_cloning.target_referential.slug
-
-    clone_schema ref_cloning, source_schema, target_schema
-  end
-
-  private
-
-  def clone_schema ref_cloning, source_schema, target_schema
-    ref_cloning.run!
-
-    AF83::SchemaCloner
-      .new(source_schema, target_schema) 
-      .clone_schema
-
-    ref_cloning.successful!
-  rescue Exception => e
-    Rails.logger.error "ReferentialCloningWorker : #{e}"
-    ref_cloning.failed!
-  end
-
-  def execute_sql sql
-    ActiveRecord::Base.connection.execute sql
+    if operation = ReferentialCloning.find(id)
+      operation.clone!
+    end
   end
 end
diff --git a/spec/models/referential_cloning_spec.rb b/spec/models/referential_cloning_spec.rb
index 5acd433ec..c01be20a9 100644
--- a/spec/models/referential_cloning_spec.rb
+++ b/spec/models/referential_cloning_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 RSpec.describe ReferentialCloning, :type => :model do
+  alias_method :referential_cloning, :subject
+
   it 'should have a valid factory' do
     expect(FactoryGirl.build(:referential_cloning)).to be_valid
   end
@@ -8,11 +10,69 @@ RSpec.describe ReferentialCloning, :type => :model do
   it { should belong_to :source_referential }
   it { should belong_to :target_referential }
 
-  describe "ReferentialCloningWorker" do
+  describe 'after commit' do
+    let(:referential_cloning) { FactoryGirl.create(:referential_cloning) }
+
+    it 'invoke clone method' do
+    expect(referential_cloning).to receive(:clone)
+    referential_cloning.run_callbacks(:commit)
+    end
+  end
+
+  describe '#clone' do
     let(:referential_cloning) { FactoryGirl.create(:referential_cloning) }
 
     it "should schedule a job in worker" do
-      expect{referential_cloning.run_callbacks(:commit)}.to change {ReferentialCloningWorker.jobs.count}.by(1)
+      expect{referential_cloning.clone}.to change {ReferentialCloningWorker.jobs.count}.by(1)
+    end
+  end
+
+  describe '#clone!' do
+    let(:source_referential) { Referential.new slug: "source"}
+    let(:target_referential) { Referential.new slug: "target"}
+    let(:referential_cloning) do
+      ReferentialCloning.new source_referential: source_referential,
+                             target_referential: target_referential
+    end
+
+    let(:cloner) { double }
+
+    before do
+      allow(AF83::SchemaCloner).to receive(:new).and_return cloner
+      allow(cloner).to receive(:clone_schema)
     end
+
+    it 'creates a schema cloner with source and target schemas and clone schema' do
+      expect(AF83::SchemaCloner).to receive(:new).with(source_referential.slug, target_referential.slug).and_return(cloner)
+      expect(cloner).to receive(:clone_schema)
+
+      referential_cloning.clone!
+    end
+
+    context 'when clone_schema is performed without error' do
+      it "should have successful status" do
+        referential_cloning.clone!
+        expect(referential_cloning.status).to eq("successful")
+      end
+    end
+
+    context 'when clone_schema raises an error' do
+      it "should have failed status" do
+        expect(cloner).to receive(:clone_schema).and_raise("#fail")
+        referential_cloning.clone!
+        expect(referential_cloning.status).to eq("failed")
+      end
+    end
+
+    it "defines started_at" do
+      referential_cloning.clone!
+      expect(referential_cloning.started_at).not_to be(nil)
+    end
+
+    it "defines ended_at" do
+      referential_cloning.clone!
+      expect(referential_cloning.ended_at).not_to be(nil)
+    end
+
   end
 end
diff --git a/spec/workers/referential_cloning_worker_spec.rb b/spec/workers/referential_cloning_worker_spec.rb
index 7e4a2357a..2b9a54805 100644
--- a/spec/workers/referential_cloning_worker_spec.rb
+++ b/spec/workers/referential_cloning_worker_spec.rb
@@ -2,52 +2,35 @@ require 'spec_helper'
 require 'ostruct'
 
 RSpec.describe ReferentialCloningWorker do
+  alias_method :worker, :subject
 
   context "given a referential cloning" do
+    let(:id) { double }
+    let(:referential_cloning) { double }
 
-    let( :id ){ double }
+    it "invokes the clone! method of the associated ReferentialCloning" do
+      expect(ReferentialCloning).to receive(:find).with(id).and_return(referential_cloning)
+      expect(referential_cloning).to receive(:clone!)
 
-    let( :worker ){ described_class.new }
-
-    def make_referential(schema_name)
-      return OpenStruct.new( slug: schema_name )
-    end
-
-    let( :source_schema ){ "source_schema" }
-    let( :target_schema ){ "target_schema" }
-    let( :referential_cloning ){ OpenStruct.new(source_referential: make_referential(source_schema),
-                                                target_referential: make_referential(target_schema)) }
-    let( :cloner ){ 'cloner' }
-
-
-    before do
-      expect( ReferentialCloning ).to receive(:find).with(id).and_return(referential_cloning)
-      expect( AF83::SchemaCloner ).to receive(:new).with( source_schema, target_schema ).and_return(cloner)
-      expect( cloner ).to receive(:clone_schema)
-
-      expect( referential_cloning ).to receive(:run!)
-    end
-
-    it "invokes the correct stored procedure, updates the database and the AASM" do
-      expect( referential_cloning ).to receive(:successful!)
       worker.perform(id)
     end
   end
 
-  it "should clone an existing Referential" do
-    source_referential = create :referential
-
-    source_referential.switch
-    source_time_table = create :time_table
+  context 'with existing Referential' do
+    it "preserve existing data" do
+      source_referential = create :referential
 
-    target_referential = create :referential, created_from: source_referential
+      source_referential.switch
+      source_time_table = create :time_table
 
-    cloning = ReferentialCloning.create source_referential: source_referential, target_referential: target_referential
-    ReferentialCloningWorker.new.perform(cloning)
+      target_referential = create :referential, created_from: source_referential
 
-    target_referential.switch
-    expect(Chouette::TimeTable.where(objectid: source_time_table.objectid).exists?)
-  end
+      cloning = ReferentialCloning.create source_referential: source_referential, target_referential: target_referential
+      worker.perform(cloning.id)
 
+      target_referential.switch
 
+      expect(Chouette::TimeTable.where(objectid: source_time_table.objectid).exists?)
+    end
+  end
 end