mongo 2.4.1 → 2.14.0

data/spec/mongo/crypt/handle_spec.rb

@@ -0,0 +1,232 @@
+require 'mongo'
+require 'base64'
+require 'lite_spec_helper'
+
+describe Mongo::Crypt::Handle do
+  require_libmongocrypt
+  include_context 'define shared FLE helpers'
+
+  describe '#initialize' do
+    let(:handle) { described_class.new(kms_providers, schema_map: schema_map) }
+    let(:schema_map) { nil }
+
+    shared_examples 'a functioning Mongo::Crypt::Handle' do
+      context 'with valid schema map' do
+        it 'does not raise an exception' do
+          expect { handle }.not_to raise_error
+        end
+      end
+
+      context 'with invalid schema map' do
+        let(:schema_map) { '' }
+
+        it 'raises an exception' do
+          expect { handle }.to raise_error(ArgumentError, /schema_map must be a Hash or nil/)
+        end
+      end
+
+      context 'with nil schema map' do
+        let(:schema_map) { nil }
+
+        it 'does not raise an exception' do
+          expect { handle }.not_to raise_error
+        end
+      end
+    end
+
+    context 'with empty kms_providers' do
+      let(:kms_providers) { {} }
+
+      it 'raises an exception' do
+        expect { handle }.to raise_error(ArgumentError, /must have one of the following keys: :aws, :local/)
+      end
+    end
+
+    context 'with invalid aws kms_providers' do
+      let(:kms_providers) { { aws: {} } }
+
+      it 'raises an exception' do
+        expect { handle }.to raise_error(ArgumentError, /kms_providers with :aws key must be in the format: { aws: { access_key_id: 'YOUR-ACCESS-KEY-ID', secret_access_key: 'SECRET-ACCESS-KEY' } }/)
+      end
+    end
+
+    context 'with invalid kms_providers key' do
+      let(:kms_providers) { { random_kms_provider: {} } }
+
+      it 'raises an exception' do
+        expect { handle }.to raise_error(ArgumentError, /must have one of the following keys: :aws, :local/)
+      end
+    end
+
+    context 'with empty local kms_providers' do
+      let(:kms_providers) { { local: {} } }
+
+      it 'raises an exception' do
+        expect { handle }.to raise_error(ArgumentError, /kms_providers with :local key must be in the format: { local: { key: 'MASTER-KEY' } }/)
+      end
+    end
+
+    context 'with invalid local kms_providers' do
+      let(:kms_providers) { { local: { invalid_key: 'Some stuff' } } }
+
+      it 'raises an exception' do
+        expect { handle }.to raise_error(ArgumentError, /kms_providers with :local key must be in the format: { local: { key: 'MASTER-KEY' } }/)
+      end
+    end
+
+    context 'with invalid local kms master key' do
+      let(:kms_providers) do
+        {
+          local: {
+            key: 'ruby' * 23 # NOT 96 bytes
+          }
+        }
+      end
+
+      it 'raises an exception' do
+        expect { handle }.to raise_error(Mongo::Error::CryptError, 'local key must be 96 bytes (libmongocrypt error code 1)')
+      end
+    end
+
+    context 'with valid local kms_providers' do
+      include_context 'with local kms_providers'
+      it_behaves_like 'a functioning Mongo::Crypt::Handle'
+    end
+
+    context 'with nil AWS kms_provider' do
+      let(:kms_providers) {
+        {
+          aws: nil
+        }
+      }
+
+      it 'raises an exception' do
+        expect do
+          handle
+        end.to raise_error(ArgumentError, /The :aws KMS provider must not be nil/)
+      end
+    end
+
+    context 'with empty AWS kms_provider' do
+      let(:kms_providers) {
+        {
+          aws: {}
+        }
+      }
+
+      it 'raises an exception' do
+        expect do
+          handle
+        end.to raise_error(ArgumentError, /The specified aws kms_providers option is invalid/)
+      end
+    end
+
+    context 'with nil AWS access_key_id' do
+      let(:kms_providers) {
+        {
+          aws: {
+            access_key_id: nil,
+            secret_access_key: SpecConfig.instance.fle_aws_secret
+          }
+        }
+      }
+
+      it 'raises an exception' do
+        expect do
+          handle
+        end.to raise_error(ArgumentError, /The aws access_key_id option must be a String with at least one character; currently have nil/)
+      end
+    end
+
+    context 'with non-string AWS access_key_id' do
+      let(:kms_providers) {
+        {
+          aws: {
+            access_key_id: 5,
+            secret_access_key: SpecConfig.instance.fle_aws_secret
+          }
+        }
+      }
+
+      it 'raises an exception' do
+        expect do
+          handle
+        end.to raise_error(ArgumentError, /The aws access_key_id option must be a String with at least one character; currently have 5/)
+      end
+    end
+
+    context 'with empty string AWS access_key_id' do
+      let(:kms_providers) {
+        {
+          aws: {
+            access_key_id: '',
+            secret_access_key: SpecConfig.instance.fle_aws_secret
+          }
+        }
+      }
+
+      it 'raises an exception' do
+        expect do
+          handle
+        end.to raise_error(ArgumentError, /The aws access_key_id option must be a String with at least one character; it is currently an empty string/)
+      end
+    end
+
+
+    context 'with nil AWS secret_access_key' do
+      let(:kms_providers) {
+        {
+          aws: {
+            access_key_id: SpecConfig.instance.fle_aws_key,
+            secret_access_key: nil
+          }
+        }
+      }
+
+      it 'raises an exception' do
+        expect do
+          handle
+        end.to raise_error(ArgumentError, /The aws secret_access_key option must be a String with at least one character; currently have nil/)
+      end
+    end
+
+    context 'with non-string AWS secret_access_key' do
+      let(:kms_providers) {
+        {
+          aws: {
+            access_key_id: SpecConfig.instance.fle_aws_key,
+            secret_access_key: 5
+          }
+        }
+      }
+
+      it 'raises an exception' do
+        expect do
+          handle
+        end.to raise_error(ArgumentError, /The aws secret_access_key option must be a String with at least one character; currently have 5/)
+      end
+    end
+
+    context 'with empty string AWS secret_access_key' do
+      let(:kms_providers) {
+        {
+          aws: {
+            access_key_id: SpecConfig.instance.fle_aws_key,
+            secret_access_key: ''
+          }
+        }
+      }
+
+      it 'raises an exception' do
+        expect do
+          handle
+        end.to raise_error(ArgumentError, /The aws secret_access_key option must be a String with at least one character; it is currently an empty string/)
+      end
+    end
+
+    context 'with valid AWS kms_providers' do
+      include_context 'with AWS kms_providers'
+      it_behaves_like 'a functioning Mongo::Crypt::Handle'
+    end
+  end
+end

data/spec/mongo/crypt/helpers/mongo_crypt_spec_helper.rb

@@ -0,0 +1,108 @@
+module MongoCryptSpecHelper
+  def bind_crypto_hooks(mongocrypt)
+    Mongo::Crypt::Binding.mongocrypt_setopt_crypto_hooks(
+      mongocrypt,
+      method(:aes_encrypt),
+      method(:aes_decrypt),
+      method(:random),
+      method(:hmac_sha_512),
+      method(:hmac_sha_256),
+      method(:hmac_hash),
+      nil
+    )
+  end
+  module_function :bind_crypto_hooks
+
+  def mongocrypt_binary_t_from(string)
+    bytes = string.unpack('C*')
+
+    p = FFI::MemoryPointer
+      .new(bytes.size)
+      .write_array_of_type(FFI::TYPE_UINT8, :put_uint8, bytes)
+
+    Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(p, bytes.length)
+  end
+  module_function :mongocrypt_binary_t_from
+
+  private
+
+  def string_from_binary(binary_p)
+    str_p = Mongo::Crypt::Binding.mongocrypt_binary_data(binary_p)
+    len = Mongo::Crypt::Binding.mongocrypt_binary_len(binary_p)
+    str_p.read_string(len)
+  end
+  module_function :string_from_binary
+
+  def write_to_binary(binary_p, data)
+    str_p = Mongo::Crypt::Binding.mongocrypt_binary_data(binary_p)
+    str_p.put_bytes(0, data)
+  end
+  module_function :write_to_binary
+
+  def aes_encrypt(_, key_binary_p, iv_binary_p, input_binary_p, output_binary_p,
+    response_length_p, status_p)
+    key = string_from_binary(key_binary_p)
+    iv = string_from_binary(iv_binary_p)
+    input = string_from_binary(input_binary_p)
+
+    output = Mongo::Crypt::Hooks.aes(key, iv, input)
+    write_to_binary(output_binary_p, output)
+    response_length_p.write_int(output.length)
+
+    true
+  end
+  module_function :aes_encrypt
+
+  def aes_decrypt(_, key_binary_p, iv_binary_p, input_binary_p, output_binary_p,
+    response_length_p, status_p)
+    key = string_from_binary(key_binary_p)
+    iv = string_from_binary(iv_binary_p)
+    input = string_from_binary(input_binary_p)
+
+    output = Mongo::Crypt::Hooks.aes(key, iv, input, decrypt: true)
+    write_to_binary(output_binary_p, output)
+    response_length_p.write_int(output.length)
+
+    true
+  end
+  module_function :aes_decrypt
+
+  def random(_, output_binary_p, num_bytes, status_p)
+    output = Mongo::Crypt::Hooks.random(num_bytes)
+    write_to_binary(output_binary_p, output)
+
+    true
+  end
+  module_function :random
+
+  def hmac_sha_512(_, key_binary_p, input_binary_p, output_binary_p, status_p)
+    key = string_from_binary(key_binary_p)
+    input = string_from_binary(input_binary_p)
+
+    output = Mongo::Crypt::Hooks.hmac_sha('SHA512', key, input)
+    write_to_binary(output_binary_p, output)
+
+    true
+  end
+  module_function :hmac_sha_512
+
+  def hmac_sha_256(_, key_binary_p, input_binary_p, output_binary_p, status_p)
+    key = string_from_binary(key_binary_p)
+    input = string_from_binary(input_binary_p)
+
+    output = Mongo::Crypt::Hooks.hmac_sha('SHA256', key, input)
+    write_to_binary(output_binary_p, output)
+
+    true
+  end
+  module_function :hmac_sha_256
+
+  def hmac_hash(_, input_binary_p, output_binary_p, status_p)
+    input = string_from_binary(input_binary_p)
+    output = Mongo::Crypt::Hooks.hash_sha256(input)
+    write_to_binary(output_binary_p, output)
+
+    true
+  end
+  module_function :hmac_hash
+end

data/spec/mongo/crypt/status_spec.rb

@@ -0,0 +1,147 @@
+require 'lite_spec_helper'
+
+describe Mongo::Crypt::Status do
+  require_libmongocrypt
+
+  let(:status) { described_class.new }
+
+  let(:label) { :error_client }
+  let(:code) { 401 }
+  let(:message) { 'Unauthorized' }
+
+  let(:status_with_info) do
+    status.update(label, code, message)
+  end
+
+  describe '#initialize' do
+    it 'doesn\'t throw an error' do
+      expect { status }.not_to raise_error
+    end
+  end
+
+  describe '#self.from_pointer' do
+    let(:pointer) { Mongo::Crypt::Binding.mongocrypt_status_new }
+    let(:status) { described_class.from_pointer(pointer) }
+
+    after do
+      Mongo::Crypt::Binding.mongocrypt_status_destroy(pointer)
+    end
+
+    it 'creates a status from the pointer passed in' do
+      expect do
+        status
+      end.not_to raise_error
+
+      expect(status.ref).to eq(pointer)
+    end
+  end
+
+  describe '#update' do
+    context 'with invalid label' do
+      it 'raises an exception' do
+        expect do
+          status.update(:random_label, 0, '')
+        end.to raise_error(ArgumentError, /random_label is an invalid value for a Mongo::Crypt::Status label/)
+      end
+
+      it 'works with an empty message' do
+        status.update(:ok, 0, '')
+        expect(status.message).to eq('')
+      end
+    end
+  end
+
+  describe '#label' do
+    context 'new status' do
+      it 'returns :ok' do
+        expect(status.label).to eq(:ok)
+      end
+    end
+
+    context 'status with info' do
+      it 'returns label' do
+        expect(status_with_info.label).to eq(label)
+      end
+    end
+  end
+
+  describe '#code' do
+    context 'new status' do
+      it 'returns 0' do
+        expect(status.code).to eq(0)
+      end
+    end
+
+    context 'status with info' do
+      it 'returns code' do
+        expect(status_with_info.code).to eq(code)
+      end
+    end
+  end
+
+  describe '#message' do
+    context 'new status' do
+      it 'returns an empty string' do
+        expect(status.message).to eq('')
+      end
+    end
+
+    context 'status with info' do
+      it 'returns a message' do
+        expect(status_with_info.message).to eq(message)
+      end
+    end
+  end
+
+  describe '#ok?' do
+    context 'new status' do
+      it 'returns true' do
+        expect(status.ok?).to be true
+      end
+    end
+
+    context 'status with info' do
+      it 'returns false' do
+        expect(status_with_info.ok?).to be false
+      end
+    end
+  end
+
+  describe '#crypt_error' do
+    context 'when status is ok' do
+      before do
+        status.update(:ok, 0, '')
+      end
+
+      it 'does not raise exception' do
+        expect do
+          status.raise_crypt_error
+        end.not_to raise_error
+      end
+    end
+
+    context 'when status is :error_kms' do
+      before do
+        status.update(:error_kms, 100, 'KMS error message')
+      end
+
+      it 'raises exception' do
+        expect do
+          status.raise_crypt_error
+        end.to raise_error(Mongo::Error::KmsError, 'KMS error message (libmongocrypt error code 100)')
+      end
+    end
+
+    context 'when status is error client' do
+      before do
+        status.update(:error_client, 2, 'Client Error')
+      end
+
+      it 'raises exception' do
+        expect do
+          status.raise_crypt_error
+        end.to raise_error(Mongo::Error::CryptError, 'Client Error (libmongocrypt error code 2)')
+      end
+    end
+  end
+end

data/spec/mongo/cursor/builder/get_more_command_spec.rb

@@ -5,11 +5,18 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
   describe '#specification' do
 
     let(:reply) do
-      Mongo::Protocol::Reply.allocate
+      Mongo::Protocol::Reply.allocate.tap do |reply|
+        allow(reply).to receive(:cursor_id).and_return(8000)
+      end
+    end
+
+    let(:description) do
+      Mongo::Server::Description.new(double('description address'),
+        'minWireVersion' => 0, 'maxWireVersion' => 2)
     end
 
     let(:result) do
-      Mongo::Operation::Result.new(reply)
+      Mongo::Operation::Result.new(reply, description)
     end
 
     let(:cursor) do
@@ -28,14 +35,33 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
       specification[:selector]
     end
 
-    shared_examples_for 'a getmore command builder' do
+    context 'when the operation has a session' do
+
+      let(:view) do
+        Mongo::Collection::View.new(authorized_collection)
+      end
+
+      let(:session) do
+        double('session')
+      end
+
+      let(:builder) do
+        described_class.new(cursor, session)
+      end
+
+      it 'adds the session to the specification' do
+        expect(builder.specification[:session]).to be(session)
+      end
+    end
+
+    shared_examples_for 'a getMore command builder' do
 
       it 'includes the database name' do
-        expect(specification[:db_name]).to eq(TEST_DB)
+        expect(specification[:db_name]).to eq(SpecConfig.instance.test_db)
       end
 
-      it 'includes getmore with cursor id' do
-        expect(selector[:getMore]).to eq(cursor.id)
+      it 'includes getMore with cursor id' do
+        expect(selector[:getMore]).to eq(BSON::Int64.new(8000))
       end
 
       it 'includes the collection name' do
@@ -49,7 +75,7 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
         Mongo::Collection::View.new(authorized_collection)
       end
 
-      it_behaves_like 'a getmore command builder'
+      it_behaves_like 'a getMore command builder'
 
       it 'does not include max time' do
         expect(selector[:maxTimeMS]).to be_nil
@@ -66,7 +92,7 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
         Mongo::Collection::View.new(authorized_collection, {}, batch_size: 10)
       end
 
-      it_behaves_like 'a getmore command builder'
+      it_behaves_like 'a getMore command builder'
 
       it 'does not include max time' do
         expect(selector[:maxTimeMS]).to be_nil
@@ -85,7 +111,7 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
           Mongo::Collection::View.new(authorized_collection, {}, max_await_time_ms: 100)
         end
 
-        it_behaves_like 'a getmore command builder'
+        it_behaves_like 'a getMore command builder'
 
         it 'does not include max time' do
           expect(selector[:maxTimeMS]).to be_nil
@@ -114,7 +140,7 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
             )
           end
 
-          it_behaves_like 'a getmore command builder'
+          it_behaves_like 'a getMore command builder'
 
           it 'includes max time' do
             expect(selector[:maxTimeMS]).to eq(100)
@@ -140,7 +166,7 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
             )
           end
 
-          it_behaves_like 'a getmore command builder'
+          it_behaves_like 'a getMore command builder'
 
           it 'does not include max time' do
             expect(selector[:maxTimeMS]).to be_nil

data/spec/mongo/cursor/builder/op_get_more_spec.rb

@@ -5,11 +5,18 @@ describe Mongo::Cursor::Builder::OpGetMore do
   describe '#specification' do
 
     let(:reply) do
-      Mongo::Protocol::Reply.allocate
+      Mongo::Protocol::Reply.allocate.tap do |reply|
+        allow(reply).to receive(:cursor_id).and_return(8000)
+      end
+    end
+
+    let(:description) do
+      Mongo::Server::Description.new(double('description address'),
+        'minWireVersion' => 0, 'maxWireVersion' => 2)
     end
 
     let(:result) do
-      Mongo::Operation::Result.new(reply)
+      Mongo::Operation::Result.new(reply, description)
     end
 
     let(:view) do
@@ -38,11 +45,11 @@ describe Mongo::Cursor::Builder::OpGetMore do
     end
 
     it 'includes the cursor id' do
-      expect(specification[:cursor_id]).to eq(cursor.id)
+      expect(specification[:cursor_id]).to eq(BSON::Int64.new(8000))
     end
 
     it 'includes the database name' do
-      expect(specification[:db_name]).to eq(TEST_DB)
+      expect(specification[:db_name]).to eq(SpecConfig.instance.test_db)
     end
 
     it 'includes the collection name' do

data/spec/mongo/cursor/builder/op_kill_cursors_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Mongo::Cursor::Builder::OpKillCursors do
+
+  let(:reply) do
+    Mongo::Protocol::Reply.allocate.tap do |reply|
+      allow(reply).to receive(:cursor_id).and_return(8000)
+    end
+  end
+
+  let(:description) do
+    Mongo::Server::Description.new(double('description address'),
+      'minWireVersion' => 0, 'maxWireVersion' => 2)
+  end
+
+  let(:result) do
+    Mongo::Operation::Result.new(reply, description)
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(
+      authorized_collection,
+      {},
+      tailable: true,
+      max_time_ms: 100
+    )
+  end
+
+  let(:cursor) do
+    Mongo::Cursor.new(view, result, authorized_primary)
+  end
+
+  let(:builder) do
+    described_class.new(cursor)
+  end
+
+  describe '#specification' do
+
+    let(:specification) do
+      builder.specification
+    end
+
+    it 'includes the cursor ids' do
+      expect(specification[:cursor_ids]).to eq([BSON::Int64.new(8000)])
+    end
+
+    it 'includes the database name' do
+      expect(specification[:db_name]).to eq(SpecConfig.instance.test_db)
+    end
+
+    it 'includes the collection name' do
+      expect(specification[:coll_name]).to eq(TEST_COLL)
+    end
+  end
+
+  describe '.get_cursors_list' do
+    it 'returns integer cursor ids' do
+      expect(described_class.get_cursors_list(builder.specification)).to eq([8000])
+    end
+  end
+end