Fix cache regeneration for Geo and added Specs

app/services/geo/schedule_repo_update_service.rb

 module Geo
   class ScheduleRepoUpdateService
-    attr_reader :id, :clone_url
+    attr_reader :id, :clone_url, :push_data
 
     def initialize(params)
       @id = params[:project_id]
       @clone_url = params[:project][:git_ssh_url]
-      @push_data = { 'type': params[:object_kind], 'before': params[:before],
-                     'after': params[:newref], 'ref': params[:ref] }
+      @push_data = { 'type' => params[:object_kind], 'before' => params[:before],
+                     'after' => params[:newref], 'ref' => params[:ref] }
     end
 
     def execute

app/workers/geo_repository_update_worker.rb

@@ -5,12 +5,12 @@ class GeoRepositoryUpdateWorker
 
   attr_accessor :project
 
-  def perform(project_id, clone_url, push_data)
+  def perform(project_id, clone_url, push_data = nil)
     @project = Project.find(project_id)
     @push_data = push_data
 
     fetch_repository(clone_url)
-    process_hooks
+    process_hooks if push_data # we should be compatible with old unprocessed data
   end
 
   private
@@ -23,7 +23,7 @@ class GeoRepositoryUpdateWorker
 
   def process_hooks
     if @push_data['type'] == 'push'
-      branch = Gitlab::Git.branch_ref?(@push_data['ref'])
+      branch = Gitlab::Git.ref_name(@push_data['ref'])
       process_push(branch, @push_data['after'])
     end
   end

spec/services/geo/schedule_repo_update_service_spec.rb

+require 'spec_helper'
+
+describe Geo::ScheduleRepoUpdateService, services: true do
+  include RepoHelpers
+
+  let(:user) { create :user }
+  let(:project) { create :project }
+
+  let(:blankrev) { Gitlab::Git::BLANK_SHA }
+  let(:oldrev) { sample_commit.parent_id }
+  let(:newrev) { sample_commit.id }
+  let(:ref) { 'refs/heads/master' }
+
+  let(:service) { execute_push_service(project, user, oldrev, newrev, ref) }
+
+  before do
+    project.team << [user, :master]
+  end
+
+  subject { described_class.new(service.push_data) }
+
+  context 'parsed push_data' do
+    it 'includes required params' do
+      expect(subject.push_data).to include('type', 'before', 'after', 'ref')
+    end
+  end
+
+  context '#execute' do
+    let(:push_data) { service.push_data }
+    let(:args) do
+      [
+        project.id,
+        push_data[:project][:git_ssh_url],
+        {
+          'type' => push_data[:object_kind],
+          'before' => push_data[:before],
+          'after' => push_data[:newref],
+          'ref' => push_data[:ref]
+        }
+      ]
+    end
+
+    it 'schedule update service' do
+      expect(GeoRepositoryUpdateWorker).to receive(:perform_async).with(*args)
+
+      subject.execute
+    end
+  end
+
+  def execute_push_service(project, user, oldrev, newrev, ref)
+    service = GitPushService.new(project, user, oldrev: oldrev, newrev: newrev, ref: ref)
+    service.execute
+    service
+  end
+end

spec/workers/geo_repository_update_worker_spec.rb

+require 'spec_helper'
+
+describe GeoRepositoryUpdateWorker do
+  include RepoHelpers
+
+  let(:user) { create :user }
+  let(:project) { create :project }
+
+  let(:blankrev) { Gitlab::Git::BLANK_SHA }
+  let(:oldrev) { sample_commit.parent_id }
+  let(:newrev) { sample_commit.id }
+  let(:ref) { 'refs/heads/master' }
+
+  let(:service) { execute_push_service(project, user, oldrev, newrev, ref) }
+  let(:push_data) { service.push_data }
+  let(:parsed_push_data) do
+    {
+      'type' => push_data[:object_kind],
+      'before' => push_data[:before],
+      'after' => push_data[:after],
+      'ref' => push_data[:ref]
+    }
+  end
+
+  let(:clone_url) { push_data[:project][:git_ssh_url] }
+  let(:performed) { subject.perform(project.id, clone_url, parsed_push_data) }
+
+  before do
+    project.team << [user, :master]
+    expect(Project).to receive(:find).at_least(:once).with(project.id) { project }
+  end
+
+  context 'when no repository' do
+    before do
+      allow(project.repository).to receive(:fetch_geo_mirror)
+      allow(project).to receive(:repository_exists?) { false }
+    end
+
+    it 'creates a new repository' do
+      expect(project).to receive(:create_repository)
+
+      performed
+    end
+
+    it 'executes after_create hook' do
+      expect(project.repository).to receive(:after_create)
+
+      performed
+    end
+  end
+
+  context 'when empty repository' do
+    before do
+      allow(project.repository).to receive(:fetch_geo_mirror)
+      allow(project).to receive(:empty_repo?) { true }
+    end
+
+    it 'executes after_create hook' do
+      expect(project.repository).to receive(:after_create).at_least(:once)
+
+      performed
+    end
+  end
+
+  context '#process_hooks' do
+    before { allow(subject).to receive(:fetch_repository) }
+
+    it 'calls if push_data is present' do
+      expect(subject).to receive(:process_hooks)
+
+      performed
+    end
+
+    context 'when no push_data is present' do
+      let(:parsed_push_data) { nil }
+
+      it 'skips process_hooks' do
+        expect(subject).not_to receive(:process_hooks)
+
+        performed
+      end
+    end
+  end
+
+  context '#process_push' do
+    before { allow(subject).to receive(:fetch_repository) }
+
+    it 'executes after_push_commit' do
+      expect(project.repository).to receive(:after_push_commit).at_least(:once).with('master', newrev)
+
+      performed
+    end
+
+    context 'when removing branch' do
+      it 'executes after_remove_branch' do
+        allow(subject).to receive(:push_remove_branch?) { true }
+        expect(project.repository).to receive(:after_remove_branch)
+
+        performed
+      end
+    end
+
+    context 'when updating a new branch' do
+      it 'executes after_create_branch' do
+        allow(subject).to receive(:push_to_new_branch?) { true }
+        expect(project.repository).to receive(:after_create_branch)
+
+        performed
+      end
+    end
+  end
+
+  def execute_push_service(project, user, oldrev, newrev, ref)
+    service = GitPushService.new(project, user, oldrev: oldrev, newrev: newrev, ref: ref)
+    service.execute
+    service
+  end
+end