Add latest changes from gitlab-org/gitlab@master

1 files changed, 51 insertions, 121 deletions

diff --git a/spec/models/concerns/featurable_spec.rb b/spec/models/concerns/featurable_spec.rb
index 453b6f7f29a..bf104fe1b30 100644
--- a/spec/models/concerns/featurable_spec.rb
+++ b/spec/models/concerns/featurable_spec.rb
@@ -3,171 +3,101 @@
 require 'spec_helper'
 
 RSpec.describe Featurable do
-  let_it_be(:user) { create(:user) }
+  let!(:klass) do
+    Class.new(ApplicationRecord) do
+      include Featurable
 
-  let(:project) { create(:project) }
-  let(:feature_class) { subject.class }
-  let(:features) { feature_class::FEATURES }
+      self.table_name = 'project_features'
 
-  subject { project.project_feature }
+      set_available_features %i(feature1 feature2 feature3)
 
-  describe '.quoted_access_level_column' do
-    it 'returns the table name and quoted column name for a feature' do
-      expected = '"project_features"."issues_access_level"'
-
-      expect(feature_class.quoted_access_level_column(:issues)).to eq(expected)
-    end
-  end
+      def feature1_access_level
+        Featurable::DISABLED
+      end
 
-  describe '.access_level_attribute' do
-    it { expect(feature_class.access_level_attribute(:wiki)).to eq :wiki_access_level }
+      def feature2_access_level
+        Featurable::ENABLED
+      end
 
-    it 'raises error for unspecified feature' do
-      expect { feature_class.access_level_attribute(:unknown) }
-        .to raise_error(ArgumentError, /invalid feature: unknown/)
+      def feature3_access_level
+        Featurable::PRIVATE
+      end
     end
   end
 
-  describe '.set_available_features' do
-    let!(:klass) do
-      Class.new(ApplicationRecord) do
-        include Featurable
+  subject { klass.new }
 
-        self.table_name = 'project_features'
-
-        set_available_features %i(feature1 feature2)
+  describe '.set_available_features' do
+    it { expect(klass.available_features).to match_array [:feature1, :feature2, :feature3] }
+  end
 
-        def feature1_access_level
-          Featurable::DISABLED
-        end
+  describe '#*_enabled?' do
+    it { expect(subject.feature1_enabled?).to be_falsey }
+    it { expect(subject.feature2_enabled?).to be_truthy }
+  end
 
-        def feature2_access_level
-          Featurable::ENABLED
-        end
-      end
+  describe '.quoted_access_level_column' do
+    it 'returns the table name and quoted column name for a feature' do
+      expect(klass.quoted_access_level_column(:feature1)).to eq('"project_features"."feature1_access_level"')
     end
-
-    let!(:instance) { klass.new }
-
-    it { expect(klass.available_features).to eq [:feature1, :feature2] }
-    it { expect(instance.feature1_enabled?).to be_falsey }
-    it { expect(instance.feature2_enabled?).to be_truthy }
   end
 
-  describe '.available_features' do
-    it { expect(feature_class.available_features).to include(*features) }
+  describe '.access_level_attribute' do
+    it { expect(klass.access_level_attribute(:feature1)).to eq :feature1_access_level }
+
+    it 'raises error for unspecified feature' do
+      expect { klass.access_level_attribute(:unknown) }
+        .to raise_error(ArgumentError, /invalid feature: unknown/)
+    end
   end
 
   describe '#access_level' do
     it 'returns access level' do
-      expect(subject.access_level(:wiki)).to eq(subject.wiki_access_level)
+      expect(subject.access_level(:feature1)).to eq(subject.feature1_access_level)
     end
   end
 
   describe '#feature_available?' do
-    let(:features) { %w(issues wiki builds merge_requests snippets repository pages metrics_dashboard) }
-
     context 'when features are disabled' do
-      it "returns false" do
-        update_all_project_features(project, features, ProjectFeature::DISABLED)
-
-        features.each do |feature|
-          expect(project.feature_available?(feature.to_sym, user)).to eq(false), "#{feature} failed"
-        end
+      it 'returns false' do
+        expect(subject.feature_available?(:feature1)).to eq(false)
       end
     end
 
     context 'when features are enabled only for team members' do
-      it "returns false when user is not a team member" do
-        update_all_project_features(project, features, ProjectFeature::PRIVATE)
+      let_it_be(:user) { create(:user) }
 
-        features.each do |feature|
-          expect(project.feature_available?(feature.to_sym, user)).to eq(false), "#{feature} failed"
-        end
+      before do
+        expect(subject).to receive(:member?).and_call_original
       end
 
-      it "returns true when user is a team member" do
-        project.add_developer(user)
-
-        update_all_project_features(project, features, ProjectFeature::PRIVATE)
-
-        features.each do |feature|
-          expect(project.feature_available?(feature.to_sym, user)).to eq(true), "#{feature} failed"
+      context 'when user is not present' do
+        it 'returns false' do
+          expect(subject.feature_available?(:feature3)).to eq(false)
         end
       end
 
-      it "returns true when user is a member of project group" do
-        group = create(:group)
-        project = create(:project, namespace: group)
-        group.add_developer(user)
+      context 'when user can read all resources' do
+        it 'returns true' do
+          allow(user).to receive(:can_read_all_resources?).and_return(true)
 
-        update_all_project_features(project, features, ProjectFeature::PRIVATE)
-
-        features.each do |feature|
-          expect(project.feature_available?(feature.to_sym, user)).to eq(true), "#{feature} failed"
+          expect(subject.feature_available?(:feature3, user)).to eq(true)
         end
       end
 
-      context 'when admin mode is enabled', :enable_admin_mode do
-        it "returns true if user is an admin" do
-          user.update_attribute(:admin, true)
-
-          update_all_project_features(project, features, ProjectFeature::PRIVATE)
+      context 'when user cannot read all resources' do
+        it 'raises NotImplementedError exception' do
+          expect(subject).to receive(:resource_member?).and_call_original
 
-          features.each do |feature|
-            expect(project.feature_available?(feature.to_sym, user)).to eq(true), "#{feature} failed"
-          end
-        end
-      end
-
-      context 'when admin mode is disabled' do
-        it "returns false when user is an admin" do
-          user.update_attribute(:admin, true)
-
-          update_all_project_features(project, features, ProjectFeature::PRIVATE)
-
-          features.each do |feature|
-            expect(project.feature_available?(feature.to_sym, user)).to eq(false), "#{feature} failed"
-          end
+          expect { subject.feature_available?(:feature3, user) }.to raise_error(NotImplementedError)
         end
       end
     end
 
     context 'when feature is enabled for everyone' do
-      it "returns true" do
-        expect(project.feature_available?(:issues, user)).to eq(true)
+      it 'returns true' do
+        expect(subject.feature_available?(:feature2)).to eq(true)
       end
     end
   end
-
-  describe '#*_enabled?' do
-    let(:features) { %w(wiki builds merge_requests) }
-
-    it "returns false when feature is disabled" do
-      update_all_project_features(project, features, ProjectFeature::DISABLED)
-
-      features.each do |feature|
-        expect(project.public_send("#{feature}_enabled?")).to eq(false), "#{feature} failed"
-      end
-    end
-
-    it "returns true when feature is enabled only for team members" do
-      update_all_project_features(project, features, ProjectFeature::PRIVATE)
-
-      features.each do |feature|
-        expect(project.public_send("#{feature}_enabled?")).to eq(true), "#{feature} failed"
-      end
-    end
-
-    it "returns true when feature is enabled for everyone" do
-      features.each do |feature|
-        expect(project.public_send("#{feature}_enabled?")).to eq(true), "#{feature} failed"
-      end
-    end
-  end
-
-  def update_all_project_features(project, features, value)
-    project_feature_attributes = features.to_h { |f| ["#{f}_access_level", value] }
-    project.project_feature.update!(project_feature_attributes)
-  end
 end