Merge branch 'refactor-create-service-spec' into 'master'

Refactor create service spec

## What does this MR do?
Use let instead instance variables to cache create user operation.

Union some example into one.

## Are there points in the code the reviewer needs to double check?

## Why was this MR needed?
Time before: 1 minute 11.81 seconds

Time after: 52.47 seconds

- [x] [Changelog entry](https://docs.gitlab.com/ce/development/changelog.html) added
- n/a [Documentation created/updated](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/doc/development/doc_styleguide.md)
- n/a API support added
- Tests
  - n/a Added for this feature/bug
  - [x] All builds are passing
- [x] Conform by the [merge request performance guides](http://docs.gitlab.com/ce/development/merge_request_performance_guidelines.html)
- [x] Conform by the [style guides](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/CONTRIBUTING.md#style-guides)
- [x] Branch has no merge conflicts with `master` (if it does - rebase it please)
- [x] [Squashed related commits together](https://git-scm.com/book/en/Git-Tools-Rewriting-History#Squashing-Commits)

## What are the relevant issue numbers?

See merge request !7609

changelogs/unreleased/refactor-create-service-spec.yml

+---
+title: Refactor create service spec
+merge_request: 7609
+author: Semyon Pupkov

spec/services/projects/create_service_spec.rb

 require 'spec_helper'
 
-describe Projects::CreateService, services: true do
-  describe :create_by_user do
-    before do
-      @user = create :user
-      @opts = {
-        name: "GitLab",
-        namespace: @user.namespace
-      }
-    end
+describe Projects::CreateService, '#execute', services: true do
+  let(:user) { create :user }
+  let(:opts) do
+    {
+      name: "GitLab",
+      namespace: user.namespace
+    }
+  end
 
-    it 'creates labels on Project creation if there are templates' do
-      Label.create(title: "bug", template: true)
-      project = create_project(@user, @opts)
-      project.reload
+  it 'creates labels on Project creation if there are templates' do
+    Label.create(title: "bug", template: true)
+    project = create_project(user, opts)
 
-      expect(project.labels).not_to be_empty
-    end
+    expect(project.labels).not_to be_empty
+  end
 
-    context 'user namespace' do
-      before do
-        @project = create_project(@user, @opts)
-      end
+  context 'user namespace' do
+    it do
+      project = create_project(user, opts)
 
-      it { expect(@project).to be_valid }
-      it { expect(@project.owner).to eq(@user) }
-      it { expect(@project.team.masters).to include(@user) }
-      it { expect(@project.namespace).to eq(@user.namespace) }
+      expect(project).to be_valid
+      expect(project.owner).to eq(user)
+      expect(project.team.masters).to include(user)
+      expect(project.namespace).to eq(user.namespace)
     end
+  end
 
-    context 'group namespace' do
-      before do
-        @group = create :group
-        @group.add_owner(@user)
+  context 'group namespace' do
+    let(:group) do
+      create(:group).tap do |group|
+        group.add_owner(user)
+      end
+    end
 
-        @user.refresh_authorized_projects # Ensure cache is warm
+    before do
+      user.refresh_authorized_projects # Ensure cache is warm
+    end
 
-        @opts.merge!(namespace_id: @group.id)
-        @project = create_project(@user, @opts)
-      end
+    it do
+      project = create_project(user, opts.merge!(namespace_id: group.id))
 
-      it { expect(@project).to be_valid }
-      it { expect(@project.owner).to eq(@group) }
-      it { expect(@project.namespace).to eq(@group) }
-      it { expect(@user.authorized_projects).to include(@project) }
+      expect(project).to be_valid
+      expect(project.owner).to eq(group)
+      expect(project.namespace).to eq(group)
+      expect(user.authorized_projects).to include(project)
     end
+  end
 
-    context 'error handling' do
-      it 'handles invalid options' do
-        @opts.merge!({ default_branch: 'master' } )
-        expect(create_project(@user, @opts)).to eq(nil)
-      end
+  context 'error handling' do
+    it 'handles invalid options' do
+      opts.merge!({ default_branch: 'master' } )
+      expect(create_project(user, opts)).to eq(nil)
     end
+  end
 
-    context 'wiki_enabled creates repository directory' do
-      context 'wiki_enabled true creates wiki repository directory' do
-        before do
-          @project = create_project(@user, @opts)
-          @path = ProjectWiki.new(@project, @user).send(:path_to_repo)
-        end
+  context 'wiki_enabled creates repository directory' do
+    context 'wiki_enabled true creates wiki repository directory' do
+      it do
+        project = create_project(user, opts)
+        path = ProjectWiki.new(project, user).send(:path_to_repo)
 
-        it { expect(File.exist?(@path)).to be_truthy }
+        expect(File.exist?(path)).to be_truthy
       end
+    end
 
-      context 'wiki_enabled false does not create wiki repository directory' do
-        before do
-          @opts.merge!(wiki_enabled: false)
-          @project = create_project(@user, @opts)
-          @path = ProjectWiki.new(@project, @user).send(:path_to_repo)
-        end
+    context 'wiki_enabled false does not create wiki repository directory' do
+      it do
+        opts.merge!(wiki_enabled: false)
+        project = create_project(user, opts)
+        path = ProjectWiki.new(project, user).send(:path_to_repo)
 
-        it { expect(File.exist?(@path)).to be_falsey }
+        expect(File.exist?(path)).to be_falsey
       end
     end
+  end
 
-    context 'builds_enabled global setting' do
-      let(:project) { create_project(@user, @opts) }
-
-      subject { project.builds_enabled? }
+  context 'builds_enabled global setting' do
+    let(:project) { create_project(user, opts) }
 
-      context 'global builds_enabled false does not enable CI by default' do
-        before do
-          project.project_feature.update_attribute(:builds_access_level, ProjectFeature::DISABLED)
-        end
+    subject { project.builds_enabled? }
 
-        it { is_expected.to be_falsey }
+    context 'global builds_enabled false does not enable CI by default' do
+      before do
+        project.project_feature.update_attribute(:builds_access_level, ProjectFeature::DISABLED)
       end
 
-      context 'global builds_enabled true does enable CI by default' do
-        before do
-          project.project_feature.update_attribute(:builds_access_level, ProjectFeature::ENABLED)
-        end
+      it { is_expected.to be_falsey }
+    end
 
-        it { is_expected.to be_truthy }
+    context 'global builds_enabled true does enable CI by default' do
+      before do
+        project.project_feature.update_attribute(:builds_access_level, ProjectFeature::ENABLED)
       end
+
+      it { is_expected.to be_truthy }
     end
+  end
 
-    context 'restricted visibility level' do
-      before do
-        stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC])
+  context 'restricted visibility level' do
+    before do
+      stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC])
 
-        @opts.merge!(
-          visibility_level: Gitlab::VisibilityLevel.options['Public']
-        )
-      end
+      opts.merge!(
+        visibility_level: Gitlab::VisibilityLevel.options['Public']
+      )
+    end
 
-      it 'does not allow a restricted visibility level for non-admins' do
-        project = create_project(@user, @opts)
-        expect(project).to respond_to(:errors)
-        expect(project.errors.messages).to have_key(:visibility_level)
-        expect(project.errors.messages[:visibility_level].first).to(
-          match('restricted by your GitLab administrator')
-        )
-      end
+    it 'does not allow a restricted visibility level for non-admins' do
+      project = create_project(user, opts)
+      expect(project).to respond_to(:errors)
+      expect(project.errors.messages).to have_key(:visibility_level)
+      expect(project.errors.messages[:visibility_level].first).to(
+        match('restricted by your GitLab administrator')
+      )
+    end
 
-      it 'allows a restricted visibility level for admins' do
-        admin = create(:admin)
-        project = create_project(admin, @opts)
+    it 'allows a restricted visibility level for admins' do
+      admin = create(:admin)
+      project = create_project(admin, opts)
 
-        expect(project.errors.any?).to be(false)
-        expect(project.saved?).to be(true)
-      end
+      expect(project.errors.any?).to be(false)
+      expect(project.saved?).to be(true)
     end
+  end
 
-    context 'repository creation' do
-      it 'synchronously creates the repository' do
-        expect_any_instance_of(Project).to receive(:create_repository)
+  context 'repository creation' do
+    it 'synchronously creates the repository' do
+      expect_any_instance_of(Project).to receive(:create_repository)
 
-        project = create_project(@user, @opts)
-        expect(project).to be_valid
-        expect(project.owner).to eq(@user)
-        expect(project.namespace).to eq(@user.namespace)
-      end
+      project = create_project(user, opts)
+      expect(project).to be_valid
+      expect(project.owner).to eq(user)
+      expect(project.namespace).to eq(user.namespace)
     end
+  end
 
-    context 'when there is an active service template' do
-      before do
-        create(:service, project: nil, template: true, active: true)
-      end
+  context 'when there is an active service template' do
+    before do
+      create(:service, project: nil, template: true, active: true)
+    end
 
-      it 'creates a service from this template' do
-        project = create_project(@user, @opts)
-        project.reload
+    it 'creates a service from this template' do
+      project = create_project(user, opts)
 
-        expect(project.services.count).to eq 1
-      end
+      expect(project.services.count).to eq 1
     end
   end