Merge branch 'bvl-codeowners-file-ce' into 'master'

Port changes for CODEOWNERS to CE

See merge request gitlab-org/gitlab-ce!21309

2 files changed, 50 insertions, 169 deletions

diff --git a/spec/models/concerns/case_sensitivity_spec.rb b/spec/models/concerns/case_sensitivity_spec.rb
index 5c0dfaeb4d3..1bf6c9b3404 100644
--- a/spec/models/concerns/case_sensitivity_spec.rb
+++ b/spec/models/concerns/case_sensitivity_spec.rb
@@ -3,186 +3,50 @@ require 'spec_helper'
 describe CaseSensitivity do
   describe '.iwhere' do
     let(:connection) { ActiveRecord::Base.connection }
-    let(:model)      { Class.new { include CaseSensitivity } }
-
-    describe 'using PostgreSQL' do
-      before do
-        allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
-        allow(Gitlab::Database).to receive(:mysql?).and_return(false)
-      end
-
-      describe 'with a single column/value pair' do
-        it 'returns the criteria for a column and a value' do
-          criteria = double(:criteria)
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:foo)
-            .and_return('"foo"')
-
-          expect(model).to receive(:where)
-            .with(%q{LOWER("foo") = LOWER(:value)}, value: 'bar')
-            .and_return(criteria)
-
-          expect(model.iwhere(foo: 'bar')).to eq(criteria)
-        end
-
-        it 'returns the criteria for a column with a table, and a value' do
-          criteria = double(:criteria)
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:'foo.bar')
-            .and_return('"foo"."bar"')
-
-          expect(model).to receive(:where)
-            .with(%q{LOWER("foo"."bar") = LOWER(:value)}, value: 'bar')
-            .and_return(criteria)
-
-          expect(model.iwhere('foo.bar'.to_sym => 'bar')).to eq(criteria)
-        end
-      end
-
-      describe 'with multiple column/value pairs' do
-        it 'returns the criteria for a column and a value' do
-          initial = double(:criteria)
-          final   = double(:criteria)
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:foo)
-            .and_return('"foo"')
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:bar)
-            .and_return('"bar"')
-
-          expect(model).to receive(:where)
-            .with(%q{LOWER("foo") = LOWER(:value)}, value: 'bar')
-            .and_return(initial)
-
-          expect(initial).to receive(:where)
-            .with(%q{LOWER("bar") = LOWER(:value)}, value: 'baz')
-            .and_return(final)
-
-          got = model.iwhere(foo: 'bar', bar: 'baz')
-
-          expect(got).to eq(final)
-        end
-
-        it 'returns the criteria for a column with a table, and a value' do
-          initial = double(:criteria)
-          final   = double(:criteria)
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:'foo.bar')
-            .and_return('"foo"."bar"')
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:'foo.baz')
-            .and_return('"foo"."baz"')
-
-          expect(model).to receive(:where)
-            .with(%q{LOWER("foo"."bar") = LOWER(:value)}, value: 'bar')
-            .and_return(initial)
-
-          expect(initial).to receive(:where)
-            .with(%q{LOWER("foo"."baz") = LOWER(:value)}, value: 'baz')
-            .and_return(final)
-
-          got = model.iwhere('foo.bar'.to_sym => 'bar',
-                             'foo.baz'.to_sym => 'baz')
-
-          expect(got).to eq(final)
-        end
+    let(:model) do
+      Class.new(ActiveRecord::Base) do
+        include CaseSensitivity
+        self.table_name = 'namespaces'
       end
     end
 
-    describe 'using MySQL' do
-      before do
-        allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
-        allow(Gitlab::Database).to receive(:mysql?).and_return(true)
-      end
-
-      describe 'with a single column/value pair' do
-        it 'returns the criteria for a column and a value' do
-          criteria = double(:criteria)
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:foo)
-            .and_return('`foo`')
-
-          expect(model).to receive(:where)
-            .with(%q{`foo` = :value}, value: 'bar')
-            .and_return(criteria)
+    let!(:model_1) { model.create(path: 'mOdEl-1', name: 'mOdEl 1') }
+    let!(:model_2) { model.create(path: 'mOdEl-2', name: 'mOdEl 2') }
 
-          expect(model.iwhere(foo: 'bar')).to eq(criteria)
-        end
+    it 'finds a single instance by a single attribute regardless of case' do
+      expect(model.iwhere(path: 'MODEL-1')).to contain_exactly(model_1)
+    end
 
-        it 'returns the criteria for a column with a table, and a value' do
-          criteria = double(:criteria)
+    it 'finds multiple instances by a single attribute regardless of case' do
+      expect(model.iwhere(path: %w(MODEL-1 model-2))).to contain_exactly(model_1, model_2)
+    end
 
-          expect(connection).to receive(:quote_table_name)
-            .with(:'foo.bar')
-            .and_return('`foo`.`bar`')
+    it 'finds instances by multiple attributes' do
+      expect(model.iwhere(path: %w(MODEL-1 model-2), name: 'model 1'))
+        .to contain_exactly(model_1)
+    end
 
-          expect(model).to receive(:where)
-            .with(%q{`foo`.`bar` = :value}, value: 'bar')
-            .and_return(criteria)
+    # Using `mysql` & `postgresql` metadata-tags here because both adapters build
+    # the query slightly differently
+    context 'for MySQL', :mysql do
+      it 'builds a simple query' do
+        query = model.iwhere(path: %w(MODEL-1 model-2), name: 'model 1').to_sql
+        expected_query = <<~QRY.strip
+        SELECT `namespaces`.* FROM `namespaces` WHERE (`namespaces`.`path` IN ('MODEL-1', 'model-2')) AND (`namespaces`.`name` = 'model 1')
+        QRY
 
-          expect(model.iwhere('foo.bar'.to_sym => 'bar'))
-            .to eq(criteria)
-        end
+        expect(query).to eq(expected_query)
       end
+    end
 
-      describe 'with multiple column/value pairs' do
-        it 'returns the criteria for a column and a value' do
-          initial = double(:criteria)
-          final   = double(:criteria)
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:foo)
-            .and_return('`foo`')
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:bar)
-            .and_return('`bar`')
-
-          expect(model).to receive(:where)
-            .with(%q{`foo` = :value}, value: 'bar')
-            .and_return(initial)
-
-          expect(initial).to receive(:where)
-            .with(%q{`bar` = :value}, value: 'baz')
-            .and_return(final)
-
-          got = model.iwhere(foo: 'bar', bar: 'baz')
-
-          expect(got).to eq(final)
-        end
-
-        it 'returns the criteria for a column with a table, and a value' do
-          initial = double(:criteria)
-          final   = double(:criteria)
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:'foo.bar')
-            .and_return('`foo`.`bar`')
-
-          expect(connection).to receive(:quote_table_name)
-            .with(:'foo.baz')
-            .and_return('`foo`.`baz`')
-
-          expect(model).to receive(:where)
-            .with(%q{`foo`.`bar` = :value}, value: 'bar')
-            .and_return(initial)
-
-          expect(initial).to receive(:where)
-            .with(%q{`foo`.`baz` = :value}, value: 'baz')
-            .and_return(final)
-
-          got = model.iwhere('foo.bar'.to_sym => 'bar',
-                             'foo.baz'.to_sym => 'baz')
+    context 'for PostgreSQL', :postgresql do
+      it 'builds a query using LOWER' do
+        query = model.iwhere(path: %w(MODEL-1 model-2), name: 'model 1').to_sql
+        expected_query = <<~QRY.strip
+        SELECT \"namespaces\".* FROM \"namespaces\" WHERE (LOWER(\"namespaces\".\"path\") IN (LOWER('MODEL-1'), LOWER('model-2'))) AND (LOWER(\"namespaces\".\"name\") = LOWER('model 1'))
+        QRY
 
-          expect(got).to eq(final)
-        end
+        expect(query).to eq(expected_query)
       end
     end
   end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index fd99acb3bb2..2a7aff39240 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -405,6 +405,23 @@ describe User do
         end
       end
     end
+
+    describe '.by_username' do
+      it 'finds users regardless of the case passed' do
+        user = create(:user, username: 'CaMeLcAsEd')
+        user2 = create(:user, username: 'UPPERCASE')
+
+        expect(described_class.by_username(%w(CAMELCASED uppercase)))
+          .to contain_exactly(user, user2)
+      end
+
+      it 'finds a single user regardless of the case passed' do
+        user = create(:user, username: 'CaMeLcAsEd')
+
+        expect(described_class.by_username('CAMELCASED'))
+          .to contain_exactly(user)
+      end
+    end
   end
 
   describe "Respond to" do