Add latest changes from gitlab-org/gitlab@master

3 files changed, 68 insertions, 127 deletions

diff --git a/spec/services/system_hooks_service_spec.rb b/spec/services/system_hooks_service_spec.rb
index d8435c72896..5d60b6e0487 100644
--- a/spec/services/system_hooks_service_spec.rb
+++ b/spec/services/system_hooks_service_spec.rb
@@ -3,133 +3,68 @@
 require 'spec_helper'
 
 RSpec.describe SystemHooksService do
-  let(:user)           { create(:user) }
-  let(:project)        { create(:project) }
-  let(:project_member) { create(:project_member) }
-  let(:key)            { create(:key, user: user) }
-  let(:deploy_key)     { create(:key) }
-  let(:group)          { create(:group) }
-  let(:group_member)   { create(:group_member) }
-
-  context 'event data' do
-    it { expect(event_data(user, :create)).to include(:event_name, :name, :created_at, :updated_at, :email, :user_id, :username) }
-    it { expect(event_data(user, :destroy)).to include(:event_name, :name, :created_at, :updated_at, :email, :user_id, :username) }
-    it { expect(event_data(project, :create)).to include(:event_name, :name, :created_at, :updated_at, :path, :project_id, :owner_name, :owner_email, :project_visibility) }
-    it { expect(event_data(project, :update)).to include(:event_name, :name, :created_at, :updated_at, :path, :project_id, :owner_name, :owner_email, :project_visibility) }
-    it { expect(event_data(project, :destroy)).to include(:event_name, :name, :created_at, :updated_at, :path, :project_id, :owner_name, :owner_email, :project_visibility) }
-    it { expect(event_data(project_member, :create)).to include(:event_name, :created_at, :updated_at, :project_name, :project_path, :project_path_with_namespace, :project_id, :user_name, :user_username, :user_email, :user_id, :access_level, :project_visibility) }
-    it { expect(event_data(project_member, :destroy)).to include(:event_name, :created_at, :updated_at, :project_name, :project_path, :project_path_with_namespace, :project_id, :user_name, :user_username, :user_email, :user_id, :access_level, :project_visibility) }
-    it { expect(event_data(project_member, :update)).to include(:event_name, :created_at, :updated_at, :project_name, :project_path, :project_path_with_namespace, :project_id, :user_name, :user_username, :user_email, :user_id, :access_level, :project_visibility) }
-    it { expect(event_data(key, :create)).to include(:username, :key, :id) }
-    it { expect(event_data(key, :destroy)).to include(:username, :key, :id) }
-    it { expect(event_data(deploy_key, :create)).to include(:key, :id) }
-    it { expect(event_data(deploy_key, :destroy)).to include(:key, :id) }
-
-    it do
-      project.old_path_with_namespace = 'renamed_from_path'
-      expect(event_data(project, :rename)).to include(
-        :event_name, :name, :created_at, :updated_at, :path, :project_id,
-        :owner_name, :owner_email, :project_visibility,
-        :old_path_with_namespace
-      )
+  describe '#execute_hooks_for' do
+    let_it_be(:user) { create(:user) }
+    let_it_be(:group) { create(:group) }
+    let_it_be(:project) { create(:project) }
+    let_it_be(:group_member) { create(:group_member, source: group, user: user) }
+    let_it_be(:project_member) { create(:project_member, source: project, user: user) }
+    let_it_be(:key) { create(:key, user: user) }
+    let_it_be(:deploy_key) { create(:key) }
+
+    let(:event) { :create }
+
+    using RSpec::Parameterized::TableSyntax
+
+    where(:model_name, :builder_class) do
+      :group_member | Gitlab::HookData::GroupMemberBuilder
+      :group | Gitlab::HookData::GroupBuilder
+      :project_member | Gitlab::HookData::ProjectMemberBuilder
+      :user | Gitlab::HookData::UserBuilder
+      :project | Gitlab::HookData::ProjectBuilder
+      :key | Gitlab::HookData::KeyBuilder
+      :deploy_key | Gitlab::HookData::KeyBuilder
     end
 
-    it do
-      project.old_path_with_namespace = 'transferred_from_path'
-      expect(event_data(project, :transfer)).to include(
-        :event_name, :name, :created_at, :updated_at, :path, :project_id,
-        :owner_name, :owner_email, :project_visibility,
-        :old_path_with_namespace
-      )
-    end
-
-    it do
-      expect(event_data(group, :create)).to include(
-        :event_name, :name, :created_at, :updated_at, :path, :group_id
-      )
-    end
+    with_them do
+      it 'builds the data with the relevant builder class and then calls #execute_hooks with the obtained data' do
+        data = double
+        model = public_send(model_name)
 
-    it do
-      expect(event_data(group, :destroy)).to include(
-        :event_name, :name, :created_at, :updated_at, :path, :group_id
-      )
-    end
+        expect_next_instance_of(builder_class, model) do |builder|
+          expect(builder).to receive(:build).with(event).and_return(data)
+        end
 
-    it do
-      expect(event_data(group_member, :create)).to include(
-        :event_name, :created_at, :updated_at, :group_name, :group_path,
-        :group_id, :user_id, :user_username, :user_name, :user_email, :group_access
-      )
-    end
+        service = described_class.new
 
-    it do
-      expect(event_data(group_member, :destroy)).to include(
-        :event_name, :created_at, :updated_at, :group_name, :group_path,
-        :group_id, :user_id, :user_username, :user_name, :user_email, :group_access
-      )
-    end
-
-    it do
-      expect(event_data(group_member, :update)).to include(
-        :event_name, :created_at, :updated_at, :group_name, :group_path,
-        :group_id, :user_id, :user_username, :user_name, :user_email, :group_access
-      )
-    end
-
-    it 'includes the correct project visibility level' do
-      data = event_data(project, :create)
-
-      expect(data[:project_visibility]).to eq('private')
-    end
+        expect_next_instance_of(SystemHooksService) do |system_hook_service|
+          expect(system_hook_service).to receive(:execute_hooks).with(data)
+        end
 
-    it 'handles nil datetime columns' do
-      user.update!(created_at: nil, updated_at: nil)
-      data = event_data(user, :destroy)
-
-      expect(data[:created_at]).to be(nil)
-      expect(data[:updated_at]).to be(nil)
+        service.execute_hooks_for(model, event)
+      end
     end
+  end
 
-    context 'group_rename' do
-      it 'contains old and new path' do
-        allow(group).to receive(:path_before_last_save).and_return('old-path')
+  describe '#execute_hooks' do
+    let(:data) { { key: :value } }
 
-        data = event_data(group, :rename)
+    subject { described_class.new.execute_hooks(data) }
 
-        expect(data).to include(:event_name, :name, :created_at, :updated_at, :full_path, :path, :group_id, :old_path, :old_full_path)
-        expect(data[:path]).to eq(group.path)
-        expect(data[:full_path]).to eq(group.path)
-        expect(data[:old_path]).to eq(group.path_before_last_save)
-        expect(data[:old_full_path]).to eq(group.path_before_last_save)
-      end
+    it 'executes system hooks with the given data' do
+      hook = create(:system_hook)
 
-      it 'contains old and new full_path for subgroup' do
-        subgroup = create(:group, parent: group)
-        allow(subgroup).to receive(:path_before_last_save).and_return('old-path')
+      allow(SystemHook).to receive_message_chain(:hooks_for, :find_each).and_yield(hook)
 
-        data = event_data(subgroup, :rename)
+      expect(hook).to receive(:async_execute).with(data, 'system_hooks')
 
-        expect(data[:full_path]).to eq(subgroup.full_path)
-        expect(data[:old_path]).to eq('old-path')
-      end
+      subject
     end
-  end
 
-  context 'event names' do
-    it { expect(event_name(project, :create)).to eq "project_create" }
-    it { expect(event_name(project, :destroy)).to eq "project_destroy" }
-    it { expect(event_name(project, :rename)).to eq "project_rename" }
-    it { expect(event_name(project, :transfer)).to eq "project_transfer" }
-    it { expect(event_name(project, :update)).to eq "project_update" }
-    it { expect(event_name(key, :create)).to eq 'key_create' }
-    it { expect(event_name(key, :destroy)).to eq 'key_destroy' }
-  end
+    it 'executes FileHook with the given data' do
+      expect(Gitlab::FileHook).to receive(:execute_all_async).with(data)
 
-  def event_data(*args)
-    SystemHooksService.new.send :build_event_data, *args
-  end
-
-  def event_name(*args)
-    SystemHooksService.new.send :build_event_name, *args
+      subject
+    end
   end
 end
diff --git a/spec/services/todo_service_spec.rb b/spec/services/todo_service_spec.rb
index 35503010b53..6a8e6dc8970 100644
--- a/spec/services/todo_service_spec.rb
+++ b/spec/services/todo_service_spec.rb
@@ -348,7 +348,7 @@ RSpec.describe TodoService do
         create(:todo, state: :pending, target: issue, user: author, author: author, project: issue.project)
         create(:todo, state: :done, target: issue, user: assignee, author: assignee, project: issue.project)
 
-        expect_next(Users::UpdateTodoCountCacheService, [author, assignee]).to receive(:execute)
+        expect_next(Users::UpdateTodoCountCacheService, [author.id, assignee.id]).to receive(:execute)
 
         service.destroy_target(issue) { issue.destroy! }
       end
@@ -1094,7 +1094,7 @@ RSpec.describe TodoService do
   it 'updates cached counts when a todo is created' do
     issue = create(:issue, project: project, assignees: [john_doe], author: author)
 
-    expect_next(Users::UpdateTodoCountCacheService, [john_doe]).to receive(:execute)
+    expect_next(Users::UpdateTodoCountCacheService, [john_doe.id]).to receive(:execute)
 
     service.new_issue(issue, author)
   end
diff --git a/spec/services/users/update_todo_count_cache_service_spec.rb b/spec/services/users/update_todo_count_cache_service_spec.rb
index 3e3618b1291..3d96af928df 100644
--- a/spec/services/users/update_todo_count_cache_service_spec.rb
+++ b/spec/services/users/update_todo_count_cache_service_spec.rb
@@ -14,13 +14,21 @@ RSpec.describe Users::UpdateTodoCountCacheService do
     let_it_be(:todo5) { create(:todo, user: user2, state: :pending) }
     let_it_be(:todo6) { create(:todo, user: user2, state: :pending) }
 
+    def execute_all
+      described_class.new([user1.id, user2.id]).execute
+    end
+
+    def execute_single
+      described_class.new([user1.id]).execute
+    end
+
     it 'updates the todos_counts for users', :use_clean_rails_memory_store_caching do
       Rails.cache.write(['users', user1.id, 'todos_done_count'], 0)
       Rails.cache.write(['users', user1.id, 'todos_pending_count'], 0)
       Rails.cache.write(['users', user2.id, 'todos_done_count'], 0)
       Rails.cache.write(['users', user2.id, 'todos_pending_count'], 0)
 
-      expect { described_class.new([user1, user2]).execute }
+      expect { execute_all }
         .to change(user1, :todos_done_count).from(0).to(2)
         .and change(user1, :todos_pending_count).from(0).to(1)
         .and change(user2, :todos_done_count).from(0).to(1)
@@ -28,7 +36,7 @@ RSpec.describe Users::UpdateTodoCountCacheService do
 
       Todo.delete_all
 
-      expect { described_class.new([user1, user2]).execute }
+      expect { execute_all }
         .to change(user1, :todos_done_count).from(2).to(0)
         .and change(user1, :todos_pending_count).from(1).to(0)
         .and change(user2, :todos_done_count).from(1).to(0)
@@ -36,26 +44,24 @@ RSpec.describe Users::UpdateTodoCountCacheService do
     end
 
     it 'avoids N+1 queries' do
-      control_count = ActiveRecord::QueryRecorder.new { described_class.new([user1]).execute }.count
+      control_count = ActiveRecord::QueryRecorder.new { execute_single }.count
 
-      expect { described_class.new([user1, user2]).execute }.not_to exceed_query_limit(control_count)
+      expect { execute_all }.not_to exceed_query_limit(control_count)
     end
 
     it 'executes one query per batch of users' do
       stub_const("#{described_class}::QUERY_BATCH_SIZE", 1)
 
-      expect(ActiveRecord::QueryRecorder.new { described_class.new([user1]).execute }.count).to eq(1)
-      expect(ActiveRecord::QueryRecorder.new { described_class.new([user1, user2]).execute }.count).to eq(2)
+      expect(ActiveRecord::QueryRecorder.new { execute_single }.count).to eq(1)
+      expect(ActiveRecord::QueryRecorder.new { execute_all }.count).to eq(2)
     end
 
-    it 'sets the cache expire time to the users count_cache_validity_period' do
-      allow(user1).to receive(:count_cache_validity_period).and_return(1.minute)
-      allow(user2).to receive(:count_cache_validity_period).and_return(1.hour)
-
-      expect(Rails.cache).to receive(:write).with(['users', user1.id, anything], anything, expires_in: 1.minute).twice
-      expect(Rails.cache).to receive(:write).with(['users', user2.id, anything], anything, expires_in: 1.hour).twice
+    it 'sets the correct cache expire time' do
+      expect(Rails.cache).to receive(:write)
+        .with(['users', user1.id, anything], anything, expires_in: User::COUNT_CACHE_VALIDITY_PERIOD)
+        .twice
 
-      described_class.new([user1, user2]).execute
+      execute_single
     end
   end
 end