mongo 2.11.2 → 2.13.0.beta1

data/spec/mongo/crypt/binding/binary_spec.rb

@@ -0,0 +1,56 @@
+require 'mongo'
+require 'support/lite_constraints'
+
+RSpec.configure do |config|
+  config.extend(LiteConstraints)
+end
+
+describe 'Mongo::Crypt::Binding' do
+  describe 'binary_t bindings' do
+    require_libmongocrypt
+
+    let(:bytes) { [104, 101, 108, 108, 111] }
+
+    let(:bytes_pointer) do
+      # FFI::MemoryPointer automatically frees memory when it goes out of scope
+      p = FFI::MemoryPointer.new(bytes.size)
+      p.write_array_of_type(FFI::TYPE_UINT8, :put_uint8, bytes)
+    end
+
+    after do
+      Mongo::Crypt::Binding.mongocrypt_binary_destroy(binary)
+    end
+
+    describe '#mongocrypt_binary_new' do
+      let(:binary) { Mongo::Crypt::Binding.mongocrypt_binary_new }
+
+      it 'returns a pointer' do
+        expect(binary).to be_a_kind_of(FFI::Pointer)
+      end
+    end
+
+    describe '#mongocrypt_binary_new_from_data' do
+      let(:binary) { Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(bytes_pointer, bytes.length) }
+
+      it 'returns a pointer' do
+        expect(binary).to be_a_kind_of(FFI::Pointer)
+      end
+    end
+
+    describe '#mongocrypt_binary_data' do
+      let(:binary) { Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(bytes_pointer, bytes.length) }
+
+      it 'returns the pointer to the data' do
+        expect(Mongo::Crypt::Binding.mongocrypt_binary_data(binary)).to eq(bytes_pointer)
+      end
+    end
+
+    describe '#mongocrypt_binary_len' do
+      let(:binary) { Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(bytes_pointer, bytes.length) }
+
+      it 'returns the length of the data' do
+        expect(Mongo::Crypt::Binding.mongocrypt_binary_len(binary)).to eq(bytes.length)
+      end
+    end
+  end
+end

data/spec/mongo/crypt/binding/context_spec.rb

@@ -0,0 +1,257 @@
+require 'mongo'
+require 'support/lite_constraints'
+require 'mongo/crypt/helpers/mongo_crypt_spec_helper'
+
+RSpec.configure do |config|
+  config.extend(LiteConstraints)
+end
+
+shared_context 'initialized for data key creation' do
+  let(:master_key) { "ru\xfe\x00" * 24 }
+  let(:binary) { MongoCryptSpecHelper.mongocrypt_binary_t_from(master_key)}
+
+  before do
+    Mongo::Crypt::Binding.mongocrypt_setopt_kms_provider_local(mongocrypt, binary)
+    MongoCryptSpecHelper.bind_crypto_hooks(mongocrypt)
+    Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+
+    Mongo::Crypt::Binding.mongocrypt_ctx_setopt_masterkey_local(context)
+  end
+
+  after do
+    Mongo::Crypt::Binding.mongocrypt_binary_destroy(binary)
+  end
+end
+
+shared_context 'initialized for explicit encryption' do
+  # TODO: replace with code showing how to generate this value
+  let(:key_id) { "\xDEd\x00\xDC\x0E\xF8J\x99\x97\xFA\xCC\x04\xBF\xAA\x00\xF5" }
+  let(:key_id_binary) { MongoCryptSpecHelper.mongocrypt_binary_t_from(key_id) }
+
+  let(:value) do
+    { 'v': 'Hello, world!' }.to_bson.to_s
+  end
+
+  let(:value_binary) { MongoCryptSpecHelper.mongocrypt_binary_t_from(value) }
+
+  before do
+    MongoCryptSpecHelper.bind_crypto_hooks(mongocrypt)
+    Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+
+    Mongo::Crypt::Binding.mongocrypt_ctx_setopt_key_id(context, key_id_binary)
+    Mongo::Crypt::Binding.mongocrypt_ctx_setopt_algorithm(
+      context,
+      'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+      -1
+    )
+  end
+
+  after do
+    Mongo::Crypt::Binding.mongocrypt_binary_destroy(key_id_binary)
+    Mongo::Crypt::Binding.mongocrypt_binary_destroy(value_binary)
+  end
+end
+
+describe 'Mongo::Crypt::Binding' do
+  describe 'mongocrypt_ctx_t bindings' do
+    require_libmongocrypt
+    fails_on_jruby
+
+    let(:mongocrypt) { Mongo::Crypt::Binding.mongocrypt_new }
+    let(:context) { Mongo::Crypt::Binding.mongocrypt_ctx_new(mongocrypt) }
+
+    after do
+      Mongo::Crypt::Binding.mongocrypt_destroy(mongocrypt)
+      Mongo::Crypt::Binding.mongocrypt_ctx_destroy(context)
+    end
+
+    describe '#mongocrypt_ctx_new' do
+      it 'returns a pointer' do
+        expect(context).to be_a_kind_of(FFI::Pointer)
+      end
+    end
+
+    describe '#mongocrypt_ctx_status' do
+      let(:status) { Mongo::Crypt::Binding.mongocrypt_status_new }
+
+      after do
+        Mongo::Crypt::Binding.mongocrypt_status_destroy(status)
+      end
+
+      context 'for a new mongocrypt_ctx_t object' do
+        it 'returns an ok status' do
+          Mongo::Crypt::Binding.mongocrypt_ctx_status(context, status)
+          expect(Mongo::Crypt::Binding.mongocrypt_status_type(status)).to eq(:ok)
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_setopt_masterkey_local' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_setopt_masterkey_local(context)
+      end
+
+      before do
+        Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+      end
+
+      it 'returns true' do
+        expect(result).to be true
+      end
+    end
+
+    describe '#mongocrypt_ctx_datakey_init' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_datakey_init(context)
+      end
+
+      context 'a master key option and KMS provider have been set' do
+        include_context 'initialized for data key creation'
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_setopt_key_id' do
+      let(:binary) { MongoCryptSpecHelper.mongocrypt_binary_t_from(uuid) }
+
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_setopt_key_id(context, binary)
+      end
+
+      before do
+        Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+      end
+
+      after do
+        Mongo::Crypt::Binding.mongocrypt_binary_destroy(binary)
+      end
+
+      context 'with valid key id' do
+        # 16-byte binary uuid string
+        # TODO: replace with code showing how to generate this value
+        let(:uuid) { "\xDEd\x00\xDC\x0E\xF8J\x99\x97\xFA\xCC\x04\xBF\xAA\x00\xF5" }
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+
+      context 'with invalid key id' do
+        # invalid uuid string -- a truncated string of bytes
+        let(:uuid) { "\xDEd\x00\xDC\x0E\xF8J\x99\x97\xFA\xCC\x04\xBF" }
+
+        it 'returns false' do
+          expect(result).to be false
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_setopt_algorithm' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_setopt_algorithm(
+          context,
+          algo,
+          -1
+        )
+      end
+
+      before do
+        Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+      end
+
+      context 'with deterministic algorithm' do
+        let(:algo) { 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic' }
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+
+      context 'with random algorithm' do
+        let(:algo) { 'AEAD_AES_256_CBC_HMAC_SHA_512-Random' }
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+
+      context 'with invalid algorithm' do
+        let(:algo) { 'fake-algorithm' }
+
+        it 'returns false' do
+          expect(result).to be false
+        end
+      end
+
+      context 'with nil algorithm' do
+        let(:algo) { nil }
+
+        it 'returns false' do
+          expect(result).to be false
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_explicit_encrypt_init' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_explicit_encrypt_init(context, value_binary)
+      end
+
+      context 'a key_id and algorithm have been set' do
+        include_context 'initialized for explicit encryption'
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_mongo_op' do
+      context 'ctx is initialized for explicit encryption' do
+        include_context 'initialized for explicit encryption'
+
+        before do
+          Mongo::Crypt::Binding.mongocrypt_ctx_explicit_encrypt_init(context, value_binary)
+        end
+
+        let(:out_binary) { Mongo::Crypt::Binding.mongocrypt_binary_new }
+        let(:result) { Mongo::Crypt::Binding.mongocrypt_ctx_mongo_op(context, out_binary) }
+
+        after do
+          Mongo::Crypt::Binding.mongocrypt_binary_destroy(out_binary)
+        end
+
+        it 'returns a BSON document' do
+          expect(result).to be true
+
+          data = Mongo::Crypt::Binding.mongocrypt_binary_data(out_binary)
+          len = Mongo::Crypt::Binding.mongocrypt_binary_len(out_binary)
+
+          response = data.get_array_of_uint8(0, len).pack('C*')
+          expect(response).to be_a_kind_of(String)
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_state' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_state(context)
+      end
+
+      context 'the mongocrypt_ctx has been properly initialized' do
+        include_context 'initialized for data key creation'
+
+        before do
+          Mongo::Crypt::Binding.mongocrypt_ctx_datakey_init(context)
+        end
+
+        it 'returns ready state' do
+          expect(result).to eq(:ready)
+        end
+      end
+    end
+  end
+end

data/spec/mongo/crypt/binding/helpers_spec.rb

@@ -0,0 +1,46 @@
+require 'mongo'
+require 'support/lite_constraints'
+
+RSpec.configure do |config|
+  config.extend(LiteConstraints)
+end
+
+describe 'Mongo::Crypt::Binding' do
+  describe 'helper methods' do
+    require_libmongocrypt
+
+    describe '#validate_document' do
+      context 'with BSON::Document data' do
+        it 'does not raise an exception' do
+          expect do
+            Mongo::Crypt::Binding.validate_document(BSON::Document.new)
+          end.not_to raise_error
+        end
+      end
+
+      context 'with Hash data' do
+        it 'does not raise an exception' do
+          expect do
+            Mongo::Crypt::Binding.validate_document({})
+          end.not_to raise_error
+        end
+      end
+
+      context 'with nil data' do
+        it 'raises an exception' do
+          expect do
+            Mongo::Crypt::Binding.validate_document(nil)
+          end.to raise_error(Mongo::Error::CryptError, /Attempted to pass nil data to libmongocrypt/)
+        end
+      end
+
+      context 'with non-document data' do
+        it 'raises an exception' do
+          expect do
+            Mongo::Crypt::Binding.validate_document('not a bson document')
+          end.to raise_error(Mongo::Error::CryptError, /Attempted to pass invalid data to libmongocrypt/)
+        end
+      end
+    end
+  end
+end

data/spec/mongo/crypt/binding/mongocrypt_spec.rb

@@ -0,0 +1,144 @@
+require 'mongo'
+require 'support/lite_constraints'
+require 'mongo/crypt/helpers/mongo_crypt_spec_helper'
+
+RSpec.configure do |config|
+  config.extend(LiteConstraints)
+end
+
+describe 'Mongo::Crypt::Binding' do
+  describe 'mongocrypt_t binding' do
+    require_libmongocrypt
+
+    after do
+      Mongo::Crypt::Binding.mongocrypt_destroy(mongocrypt)
+    end
+
+    describe '#mongocrypt_new' do
+      let(:mongocrypt) { Mongo::Crypt::Binding.mongocrypt_new }
+
+      it 'returns a pointer' do
+        expect(mongocrypt).to be_a_kind_of(FFI::Pointer)
+      end
+    end
+
+    describe '#mongocrypt_setopt_kms_provider_local' do
+      let(:mongocrypt) { Mongo::Crypt::Binding.mongocrypt_new }
+
+      let(:binary) do
+        p = FFI::MemoryPointer.new(key_bytes.size)
+              .write_array_of_type(FFI::TYPE_UINT8, :put_uint8, key_bytes)
+
+        Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(p, key_bytes.length)
+      end
+
+      after do
+        Mongo::Crypt::Binding.mongocrypt_binary_destroy(binary)
+      end
+
+      context 'with valid key' do
+        let(:key_bytes) { [114, 117, 98, 121] * 24 } # 96 bytes
+
+        it 'returns true' do
+          expect(Mongo::Crypt::Binding.mongocrypt_setopt_kms_provider_local(mongocrypt, binary)).to be true
+        end
+      end
+
+      context 'with invalid key' do
+        let(:key_bytes) { [114, 117, 98, 121] * 23 } # NOT 96 bytes
+
+        it 'returns false' do
+          expect(Mongo::Crypt::Binding.mongocrypt_setopt_kms_provider_local(mongocrypt, binary)).to be false
+        end
+      end
+    end
+
+    describe '#mongocrypt_init' do
+      let(:key_bytes) { [114, 117, 98, 121] * 24 } # 96 bytes
+
+      let(:binary) do
+        p = FFI::MemoryPointer.new(key_bytes.size)
+              .write_array_of_type(FFI::TYPE_UINT8, :put_uint8, key_bytes)
+
+        Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(p, key_bytes.length)
+      end
+
+      let(:mongocrypt) do
+        mongocrypt = Mongo::Crypt::Binding.mongocrypt_new
+        Mongo::Crypt::Binding.mongocrypt_setopt_kms_provider_local(mongocrypt, binary)
+
+        mongocrypt
+      end
+
+      after do
+        Mongo::Crypt::Binding.mongocrypt_binary_destroy(binary)
+      end
+
+      context 'with valid kms option' do
+        before do
+          MongoCryptSpecHelper.bind_crypto_hooks(mongocrypt)
+        end
+
+        it 'returns true' do
+          expect(Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)).to be true
+        end
+      end
+
+      context 'without binding crypto hooks' do
+        it 'returns false' do
+          expect(Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)).to be false
+        end
+      end
+
+      context 'with invalid kms option' do
+        before do
+          MongoCryptSpecHelper.bind_crypto_hooks(mongocrypt)
+        end
+
+        let(:key_bytes) { [114, 117, 98, 121] * 23 } # NOT 96 bytes
+
+        it 'returns false' do
+          expect(Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)).to be false
+        end
+      end
+    end
+
+    describe '#mongocrypt_status' do
+      let(:status) { Mongo::Crypt::Binding.mongocrypt_status_new }
+      let(:mongocrypt) { mongocrypt = Mongo::Crypt::Binding.mongocrypt_new }
+
+      after do
+        Mongo::Crypt::Binding.mongocrypt_status_destroy(status)
+      end
+
+      context 'for a new mongocrypt_t object' do
+        it 'returns an ok status' do
+          Mongo::Crypt::Binding.mongocrypt_status(mongocrypt, status)
+          expect(Mongo::Crypt::Binding.mongocrypt_status_type(status)).to eq(:ok)
+        end
+      end
+
+      context 'for a mongocrypt_t object with invalid kms options' do
+        let(:key_bytes) { [114, 117, 98, 121] * 23 } # NOT 96 bytes
+
+        let(:binary) do
+          p = FFI::MemoryPointer.new(key_bytes.size)
+                .write_array_of_type(FFI::TYPE_UINT8, :put_uint8, key_bytes)
+
+          Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(p, key_bytes.length)
+        end
+
+        after do
+          Mongo::Crypt::Binding.mongocrypt_binary_destroy(binary)
+        end
+
+        it 'returns a error_client status' do
+          Mongo::Crypt::Binding.mongocrypt_setopt_kms_provider_local(mongocrypt, binary)
+
+          Mongo::Crypt::Binding.mongocrypt_status(mongocrypt, status)
+          expect(Mongo::Crypt::Binding.mongocrypt_status_type(status)).to eq(:error_client)
+        end
+      end
+    end
+  end
+end