mongo 2.5.3 → 2.6.0

data/spec/mongo/auth/scram_spec.rb

@@ -35,32 +35,63 @@ describe Mongo::Auth::SCRAM do
     Mongo::Server::Connection.new(server, TEST_OPTIONS)
   end
 
-  describe '#login' do
+  context 'when SCRAM-SHA-1 is used' do
 
-    context 'when the user is not authorized' do
+    describe '#login' do
 
-      let(:user) do
-        Mongo::Auth::User.new(
-          database: 'driver',
-          user: 'notauser',
-          password: 'password'
-        )
-      end
+      context 'when the user is not authorized' do
 
-      let(:cr) do
-        described_class.new(user)
-      end
+        let(:user) do
+          Mongo::Auth::User.new(
+            database: 'driver',
+            user: 'notauser',
+            password: 'password',
+            auth_mech: 'SCRAM-SHA-1'
+          )
+        end
 
-      it 'raises an exception', if: list_command_enabled? do
-        expect {
-          cr.login(connection)
-        }.to raise_error(Mongo::Auth::Unauthorized)
+        let(:cr) do
+          described_class.new(user)
+        end
+
+        it 'raises an exception', if: scram_sha_1_enabled? do
+          expect {
+            cr.login(connection)
+          }.to raise_error(Mongo::Auth::Unauthorized)
+        end
+
+        context 'when compression is used', if: testing_compression? do
+
+          it 'does not compress the message' do
+            expect(Mongo::Protocol::Compressed).not_to receive(:new)
+            expect {
+              cr.login(connection)
+            }.to raise_error(Mongo::Auth::Unauthorized)
+          end
+        end
       end
 
-      context 'when compression is used', if: testing_compression? do
+      context 'when the user is authorized for the database' do
 
-        it 'does not compress the message' do
-          expect(Mongo::Protocol::Compressed).not_to receive(:new)
+        let(:cr) do
+          described_class.new(root_user)
+        end
+
+        let(:login) do
+          cr.login(connection).documents[0]
+        end
+
+        after do
+          root_user.instance_variable_set(:@client_key, nil)
+        end
+
+        it 'logs the user into the connection and caches the client key', if: scram_sha_1_enabled? do
+          expect(login['ok']).to eq(1)
+          expect(root_user.send(:client_key)).not_to be_nil
+        end
+
+        it 'raises an exception when an incorrect client key is set', if: scram_sha_1_enabled? do
+          root_user.instance_variable_set(:@client_key, "incorrect client key")
           expect {
             cr.login(connection)
           }.to raise_error(Mongo::Auth::Unauthorized)
@@ -69,30 +100,68 @@ describe Mongo::Auth::SCRAM do
     end
   end
 
-  context 'when the user is authorized for the database' do
+  context 'when SCRAM-SHA-256 is used' do
 
-    let(:cr) do
-      described_class.new(root_user)
-    end
+    describe '#login' do
 
-    let(:login) do
-      cr.login(connection).documents[0]
-    end
+      context 'when the user is not authorized' do
 
-    after do
-      root_user.instance_variable_set(:@client_key, nil)
-    end
+        let(:user) do
+          Mongo::Auth::User.new(
+            database: 'driver',
+            user: 'notauser',
+            password: 'password',
+            auth_mech: 'SCRAM-SHA-256'
+          )
+        end
 
-    it 'logs the user into the connection and caches the client key', if: list_command_enabled? do
-      expect(login['ok']).to eq(1)
-      expect(root_user.send(:client_key)).not_to be_nil
-    end
+        let(:cr) do
+          described_class.new(user)
+        end
+
+        it 'raises an exception', if: scram_sha_256_enabled? do
+          expect {
+            cr.login(connection)
+          }.to raise_error(Mongo::Auth::Unauthorized)
+        end
+
+        context 'when compression is used', if: scram_sha_256_enabled? && testing_compression? do
+
+          it 'does not compress the message' do
+            expect(Mongo::Protocol::Compressed).not_to receive(:new)
+            expect {
+              cr.login(connection)
+            }.to raise_error(Mongo::Auth::Unauthorized)
+          end
+        end
+      end
+
+      context 'when the user is authorized for the database' do
+
+        let(:cr) do
+          described_class.new(test_user)
+        end
+
+        let(:login) do
+          cr.login(connection).documents[0]
+        end
+
+        after do
+          test_user.instance_variable_set(:@client_key, nil)
+        end
+
+        it 'logs the user into the connection and caches the client key', if: scram_sha_256_enabled? do
+          expect(login['ok']).to eq(1)
+          expect(test_user.send(:client_key)).not_to be_nil
+        end
 
-    it 'raises an exception when an incorrect client key is set', if: list_command_enabled? do
-      root_user.instance_variable_set(:@client_key, "incorrect client key")
-      expect {
-        cr.login(connection)
-      }.to raise_error(Mongo::Auth::Unauthorized)
+        it 'raises an exception when an incorrect client key is set', if: scram_sha_256_enabled? do
+          test_user.instance_variable_set(:@client_key, "incorrect client key")
+          expect {
+            cr.login(connection)
+          }.to raise_error(Mongo::Auth::Unauthorized)
+        end
+      end
     end
   end
 end

data/spec/mongo/auth/stringprep/profiles/sasl_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Mongo::Auth::StringPrep::Profiles::SASL do
+  let(:prepared_data) do
+    Mongo::Auth::StringPrep.prepare(
+      data,
+      mappings,
+      prohibited,
+      options
+    )
+  end
+
+  let(:mappings) do
+    Mongo::Auth::StringPrep::Profiles::SASL::MAPPINGS
+  end
+
+  let(:prohibited) do
+    Mongo::Auth::StringPrep::Profiles::SASL::PROHIBITED
+  end
+
+  let(:options) do
+    {
+      normalize: true,
+      bidi: true
+    }
+  end
+
+  describe 'StringPrep#prepare' do
+    context 'when there is unnecessary punctuation' do
+      let(:data) do
+        "I\u00ADX"
+      end
+
+      it 'removes the punctuation' do
+        expect(prepared_data).to eq('IX')
+      end
+    end
+
+    context 'when there are non-ASCII spaces' do
+      let(:data) do
+        "I\u2000X"
+      end
+
+      it 'replaces them with ASCII spaces' do
+        expect(prepared_data).to eq('I X')
+      end
+    end
+
+    context 'when the input is ASCII' do
+      let(:data) do
+        'user'
+      end
+
+      it 'returns the same string' do
+        expect(prepared_data).to eq('user')
+      end
+    end
+
+    context 'when the data contains uppercase characters' do
+      let(:data) do
+        'USER'
+      end
+
+      it 'preserves case' do
+        expect(prepared_data).to eq('USER')
+      end
+    end
+
+    context 'when the data contains single-character codes' do
+      let(:data) do
+        "\u00AA"
+      end
+
+      it 'normalizes the codes' do
+        expect(prepared_data).to eq('a')
+      end
+    end
+
+    context 'when the data contains multi-character codes' do
+      let(:data) do
+        "\u2168"
+      end
+
+      it 'normalizes the codes' do
+        expect(prepared_data).to eq('IX')
+      end
+    end
+
+    context 'when the data contains prohibited input' do
+      let(:data) do
+        "\u0007"
+      end
+
+      it 'raises an error' do
+        expect {
+          prepared_data
+        }.to raise_error(Mongo::Error::FailedStringPrepValidation)
+      end
+    end
+
+    context 'when the data contains invalid bidi input' do
+      let(:data) do
+        "\u0627\u0031"
+      end
+
+      it 'raises an error' do
+        expect {
+          prepared_data
+        }.to raise_error(Mongo::Error::FailedStringPrepValidation)
+      end
+    end
+  end
+end

data/spec/mongo/auth/stringprep_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe Mongo::Auth::StringPrep do
+  include Mongo::Auth::StringPrep
+
+  describe '#prepare' do
+    let(:prepared_data) do
+      prepare(data, mappings, prohibited, options)
+    end
+
+    context 'with no options' do
+      let(:mappings) do
+        []
+      end
+
+      let(:prohibited) do
+        []
+      end
+
+      let(:options) do
+        {}
+      end
+
+      context 'when the data has invalid bidi' do
+        let(:data) do
+          "\u0627\u0031"
+        end
+
+        it 'does not raise an error' do
+          expect(prepared_data).to eq("\u0627\u0031")
+        end
+      end
+
+      context 'when the data has unicode codes' do
+        let(:data) do
+          "ua\u030Aer"
+        end
+
+        it 'does not normalize the data' do
+          expect(prepared_data).to eq("ua\u030Aer")
+        end
+      end
+    end
+
+    context 'with options specified' do
+      let (:mappings) do
+        [Mongo::Auth::StringPrep::Tables::B1, Mongo::Auth::StringPrep::Tables::B2]
+      end
+
+      let (:prohibited) do
+        [
+          Mongo::Auth::StringPrep::Tables::C1_1,
+          Mongo::Auth::StringPrep::Tables::C1_2,
+          Mongo::Auth::StringPrep::Tables::C6,
+        ]
+      end
+
+      let (:options) do
+        {
+          normalize: true,
+          bidi: true,
+        }
+      end
+
+      context 'when the input is empty' do
+        let(:data) do
+          ''
+        end
+
+        it 'returns the empty string' do
+          expect(prepared_data).to eq('')
+        end
+      end
+
+      context 'when the input is ASCII' do
+        let(:data) do
+          'user'
+        end
+
+        it 'returns the same string on ASCII input' do
+          expect(prepared_data).to eq('user')
+        end
+      end
+
+      context 'when the input contains zero-width spaces' do
+        let(:data) do
+          "u\u200Ber"
+        end
+
+        it 'removes the zero-width spaces' do
+          expect(prepared_data).to eq('uer')
+        end
+      end
+
+      context 'when the input contains non-ASCII characters' do
+        let(:data) do
+          "u\u00DFer"
+        end
+
+        it 'maps the non-ASCII characters to ASCII' do
+          expect(prepared_data).to eq('usser')
+        end
+      end
+
+      context 'when the input contains unicode codes' do
+        let(:data) do
+          "ua\u030Aer"
+        end
+
+        it 'unicode normalizes the input' do
+          expect(prepared_data).to eq("u\u00e5er")
+        end
+      end
+
+      context 'when the input contains prohibited characters' do
+        let(:data) do
+          "u\uFFFDer"
+        end
+
+        it 'raises an error' do
+          expect {
+            prepared_data
+          }.to raise_error(Mongo::Error::FailedStringPrepValidation)
+        end
+      end
+
+      context 'when the data is proper bidi' do
+        let(:data) do
+          "\u0627\u0031\u0628"
+        end
+
+        it 'does not raise an error' do
+          expect(
+            prepared_data
+          ).to eq("\u0627\u0031\u0628")
+        end
+      end
+
+      context 'when bidi input contains prohibited bidi characters' do
+        let(:data) do
+          "\u0627\u0589\u0628"
+        end
+
+        it 'raises an error' do
+          expect {
+            prepared_data
+          }.to raise_error(Mongo::Error::FailedStringPrepValidation)
+        end
+      end
+
+      context 'when bidi input has an invalid first bidi character' do
+        let(:data) do
+          "\u0031\u0627"
+        end
+
+        it 'raises an error' do
+          expect {
+            prepared_data
+          }.to raise_error(Mongo::Error::FailedStringPrepValidation)
+        end
+      end
+
+      context 'when bidi input has an invalid last bidi character' do
+        let(:data) do
+          "\u0627\u0031"
+        end
+
+        it 'raises an error' do
+          expect {
+            prepared_data
+          }.to raise_error(Mongo::Error::FailedStringPrepValidation)
+        end
+      end
+
+      context 'when bidi input has a bad character' do
+        let(:data) do
+          "\u206D"
+        end
+
+        it 'raises an error' do
+          expect {
+            prepared_data
+          }.to raise_error(Mongo::Error::FailedStringPrepValidation)
+        end
+      end
+    end
+  end
+end